mirror of https://github.com/milvus-io/milvus.git
Add GetQuerySegmentInfo
Signed-off-by: zhenshan.cao <zhenshan.cao@zilliz.com>pull/4973/head^2
zhenshan.cao
yefu.chen
parent
71b6c88c6e
commit
b89e5a3240
File diff suppressed because it is too large
Load Diff
|
|
@ -50,7 +50,7 @@ struct TableStruct_milvus_2eproto {
|
|||
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
||||
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
|
||||
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
||||
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[44]
|
||||
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[47]
|
||||
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
||||
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
|
||||
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
|
||||
|
|
@ -156,6 +156,15 @@ extern PlaceholderGroupDefaultTypeInternal _PlaceholderGroup_default_instance_;
|
|||
class PlaceholderValue;
|
||||
class PlaceholderValueDefaultTypeInternal;
|
||||
extern PlaceholderValueDefaultTypeInternal _PlaceholderValue_default_instance_;
|
||||
class QuerySegmentInfo;
|
||||
class QuerySegmentInfoDefaultTypeInternal;
|
||||
extern QuerySegmentInfoDefaultTypeInternal _QuerySegmentInfo_default_instance_;
|
||||
class QuerySegmentInfoRequest;
|
||||
class QuerySegmentInfoRequestDefaultTypeInternal;
|
||||
extern QuerySegmentInfoRequestDefaultTypeInternal _QuerySegmentInfoRequest_default_instance_;
|
||||
class QuerySegmentInfoResponse;
|
||||
class QuerySegmentInfoResponseDefaultTypeInternal;
|
||||
extern QuerySegmentInfoResponseDefaultTypeInternal _QuerySegmentInfoResponse_default_instance_;
|
||||
class RegisterLinkResponse;
|
||||
class RegisterLinkResponseDefaultTypeInternal;
|
||||
extern RegisterLinkResponseDefaultTypeInternal _RegisterLinkResponse_default_instance_;
|
||||
|
|
@ -228,6 +237,9 @@ template<> ::milvus::proto::milvus::PersistentSegmentInfoRequest* Arena::CreateM
|
|||
template<> ::milvus::proto::milvus::PersistentSegmentInfoResponse* Arena::CreateMaybeMessage<::milvus::proto::milvus::PersistentSegmentInfoResponse>(Arena*);
|
||||
template<> ::milvus::proto::milvus::PlaceholderGroup* Arena::CreateMaybeMessage<::milvus::proto::milvus::PlaceholderGroup>(Arena*);
|
||||
template<> ::milvus::proto::milvus::PlaceholderValue* Arena::CreateMaybeMessage<::milvus::proto::milvus::PlaceholderValue>(Arena*);
|
||||
template<> ::milvus::proto::milvus::QuerySegmentInfo* Arena::CreateMaybeMessage<::milvus::proto::milvus::QuerySegmentInfo>(Arena*);
|
||||
template<> ::milvus::proto::milvus::QuerySegmentInfoRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::QuerySegmentInfoRequest>(Arena*);
|
||||
template<> ::milvus::proto::milvus::QuerySegmentInfoResponse* Arena::CreateMaybeMessage<::milvus::proto::milvus::QuerySegmentInfoResponse>(Arena*);
|
||||
template<> ::milvus::proto::milvus::RegisterLinkResponse* Arena::CreateMaybeMessage<::milvus::proto::milvus::RegisterLinkResponse>(Arena*);
|
||||
template<> ::milvus::proto::milvus::ReleaseCollectionRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::ReleaseCollectionRequest>(Arena*);
|
||||
template<> ::milvus::proto::milvus::ReleasePartitionRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::ReleasePartitionRequest>(Arena*);
|
||||
|
|
@ -7248,6 +7260,492 @@ class PersistentSegmentInfoResponse :
|
|||
};
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
class QuerySegmentInfo :
|
||||
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.QuerySegmentInfo) */ {
|
||||
public:
|
||||
QuerySegmentInfo();
|
||||
virtual ~QuerySegmentInfo();
|
||||
|
||||
QuerySegmentInfo(const QuerySegmentInfo& from);
|
||||
QuerySegmentInfo(QuerySegmentInfo&& from) noexcept
|
||||
: QuerySegmentInfo() {
|
||||
*this = ::std::move(from);
|
||||
}
|
||||
|
||||
inline QuerySegmentInfo& operator=(const QuerySegmentInfo& from) {
|
||||
CopyFrom(from);
|
||||
return *this;
|
||||
}
|
||||
inline QuerySegmentInfo& operator=(QuerySegmentInfo&& from) noexcept {
|
||||
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||||
if (this != &from) InternalSwap(&from);
|
||||
} else {
|
||||
CopyFrom(from);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
||||
return GetDescriptor();
|
||||
}
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
||||
return GetMetadataStatic().descriptor;
|
||||
}
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
||||
return GetMetadataStatic().reflection;
|
||||
}
|
||||
static const QuerySegmentInfo& default_instance();
|
||||
|
||||
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||||
static inline const QuerySegmentInfo* internal_default_instance() {
|
||||
return reinterpret_cast<const QuerySegmentInfo*>(
|
||||
&_QuerySegmentInfo_default_instance_);
|
||||
}
|
||||
static constexpr int kIndexInFileMessages =
|
||||
43;
|
||||
|
||||
friend void swap(QuerySegmentInfo& a, QuerySegmentInfo& b) {
|
||||
a.Swap(&b);
|
||||
}
|
||||
inline void Swap(QuerySegmentInfo* other) {
|
||||
if (other == this) return;
|
||||
InternalSwap(other);
|
||||
}
|
||||
|
||||
// implements Message ----------------------------------------------
|
||||
|
||||
inline QuerySegmentInfo* New() const final {
|
||||
return CreateMaybeMessage<QuerySegmentInfo>(nullptr);
|
||||
}
|
||||
|
||||
QuerySegmentInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
||||
return CreateMaybeMessage<QuerySegmentInfo>(arena);
|
||||
}
|
||||
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
||||
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
||||
void CopyFrom(const QuerySegmentInfo& from);
|
||||
void MergeFrom(const QuerySegmentInfo& from);
|
||||
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
||||
bool IsInitialized() const final;
|
||||
|
||||
size_t ByteSizeLong() const final;
|
||||
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
|
||||
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
||||
#else
|
||||
bool MergePartialFromCodedStream(
|
||||
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
|
||||
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
|
||||
void SerializeWithCachedSizes(
|
||||
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
|
||||
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
|
||||
::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
|
||||
int GetCachedSize() const final { return _cached_size_.Get(); }
|
||||
|
||||
private:
|
||||
inline void SharedCtor();
|
||||
inline void SharedDtor();
|
||||
void SetCachedSize(int size) const final;
|
||||
void InternalSwap(QuerySegmentInfo* other);
|
||||
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
||||
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
||||
return "milvus.proto.milvus.QuerySegmentInfo";
|
||||
}
|
||||
private:
|
||||
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
|
||||
return nullptr;
|
||||
}
|
||||
inline void* MaybeArenaPtr() const {
|
||||
return nullptr;
|
||||
}
|
||||
public:
|
||||
|
||||
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
||||
private:
|
||||
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
|
||||
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
|
||||
return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
// nested types ----------------------------------------------------
|
||||
|
||||
// accessors -------------------------------------------------------
|
||||
|
||||
enum : int {
|
||||
kIndexNameFieldNumber = 6,
|
||||
kSegmentIDFieldNumber = 1,
|
||||
kCollectionIDFieldNumber = 2,
|
||||
kPartitionIDFieldNumber = 3,
|
||||
kMemSizeFieldNumber = 4,
|
||||
kNumRowsFieldNumber = 5,
|
||||
kIndexIDFieldNumber = 7,
|
||||
};
|
||||
// string index_name = 6;
|
||||
void clear_index_name();
|
||||
const std::string& index_name() const;
|
||||
void set_index_name(const std::string& value);
|
||||
void set_index_name(std::string&& value);
|
||||
void set_index_name(const char* value);
|
||||
void set_index_name(const char* value, size_t size);
|
||||
std::string* mutable_index_name();
|
||||
std::string* release_index_name();
|
||||
void set_allocated_index_name(std::string* index_name);
|
||||
|
||||
// int64 segmentID = 1;
|
||||
void clear_segmentid();
|
||||
::PROTOBUF_NAMESPACE_ID::int64 segmentid() const;
|
||||
void set_segmentid(::PROTOBUF_NAMESPACE_ID::int64 value);
|
||||
|
||||
// int64 collectionID = 2;
|
||||
void clear_collectionid();
|
||||
::PROTOBUF_NAMESPACE_ID::int64 collectionid() const;
|
||||
void set_collectionid(::PROTOBUF_NAMESPACE_ID::int64 value);
|
||||
|
||||
// int64 partitionID = 3;
|
||||
void clear_partitionid();
|
||||
::PROTOBUF_NAMESPACE_ID::int64 partitionid() const;
|
||||
void set_partitionid(::PROTOBUF_NAMESPACE_ID::int64 value);
|
||||
|
||||
// int64 mem_size = 4;
|
||||
void clear_mem_size();
|
||||
::PROTOBUF_NAMESPACE_ID::int64 mem_size() const;
|
||||
void set_mem_size(::PROTOBUF_NAMESPACE_ID::int64 value);
|
||||
|
||||
// int64 num_rows = 5;
|
||||
void clear_num_rows();
|
||||
::PROTOBUF_NAMESPACE_ID::int64 num_rows() const;
|
||||
void set_num_rows(::PROTOBUF_NAMESPACE_ID::int64 value);
|
||||
|
||||
// int64 indexID = 7;
|
||||
void clear_indexid();
|
||||
::PROTOBUF_NAMESPACE_ID::int64 indexid() const;
|
||||
void set_indexid(::PROTOBUF_NAMESPACE_ID::int64 value);
|
||||
|
||||
// @@protoc_insertion_point(class_scope:milvus.proto.milvus.QuerySegmentInfo)
|
||||
private:
|
||||
class _Internal;
|
||||
|
||||
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
|
||||
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr index_name_;
|
||||
::PROTOBUF_NAMESPACE_ID::int64 segmentid_;
|
||||
::PROTOBUF_NAMESPACE_ID::int64 collectionid_;
|
||||
::PROTOBUF_NAMESPACE_ID::int64 partitionid_;
|
||||
::PROTOBUF_NAMESPACE_ID::int64 mem_size_;
|
||||
::PROTOBUF_NAMESPACE_ID::int64 num_rows_;
|
||||
::PROTOBUF_NAMESPACE_ID::int64 indexid_;
|
||||
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
||||
friend struct ::TableStruct_milvus_2eproto;
|
||||
};
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
class QuerySegmentInfoRequest :
|
||||
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.QuerySegmentInfoRequest) */ {
|
||||
public:
|
||||
QuerySegmentInfoRequest();
|
||||
virtual ~QuerySegmentInfoRequest();
|
||||
|
||||
QuerySegmentInfoRequest(const QuerySegmentInfoRequest& from);
|
||||
QuerySegmentInfoRequest(QuerySegmentInfoRequest&& from) noexcept
|
||||
: QuerySegmentInfoRequest() {
|
||||
*this = ::std::move(from);
|
||||
}
|
||||
|
||||
inline QuerySegmentInfoRequest& operator=(const QuerySegmentInfoRequest& from) {
|
||||
CopyFrom(from);
|
||||
return *this;
|
||||
}
|
||||
inline QuerySegmentInfoRequest& operator=(QuerySegmentInfoRequest&& from) noexcept {
|
||||
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||||
if (this != &from) InternalSwap(&from);
|
||||
} else {
|
||||
CopyFrom(from);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
||||
return GetDescriptor();
|
||||
}
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
||||
return GetMetadataStatic().descriptor;
|
||||
}
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
||||
return GetMetadataStatic().reflection;
|
||||
}
|
||||
static const QuerySegmentInfoRequest& default_instance();
|
||||
|
||||
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||||
static inline const QuerySegmentInfoRequest* internal_default_instance() {
|
||||
return reinterpret_cast<const QuerySegmentInfoRequest*>(
|
||||
&_QuerySegmentInfoRequest_default_instance_);
|
||||
}
|
||||
static constexpr int kIndexInFileMessages =
|
||||
44;
|
||||
|
||||
friend void swap(QuerySegmentInfoRequest& a, QuerySegmentInfoRequest& b) {
|
||||
a.Swap(&b);
|
||||
}
|
||||
inline void Swap(QuerySegmentInfoRequest* other) {
|
||||
if (other == this) return;
|
||||
InternalSwap(other);
|
||||
}
|
||||
|
||||
// implements Message ----------------------------------------------
|
||||
|
||||
inline QuerySegmentInfoRequest* New() const final {
|
||||
return CreateMaybeMessage<QuerySegmentInfoRequest>(nullptr);
|
||||
}
|
||||
|
||||
QuerySegmentInfoRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
||||
return CreateMaybeMessage<QuerySegmentInfoRequest>(arena);
|
||||
}
|
||||
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
||||
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
||||
void CopyFrom(const QuerySegmentInfoRequest& from);
|
||||
void MergeFrom(const QuerySegmentInfoRequest& from);
|
||||
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
||||
bool IsInitialized() const final;
|
||||
|
||||
size_t ByteSizeLong() const final;
|
||||
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
|
||||
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
||||
#else
|
||||
bool MergePartialFromCodedStream(
|
||||
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
|
||||
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
|
||||
void SerializeWithCachedSizes(
|
||||
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
|
||||
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
|
||||
::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
|
||||
int GetCachedSize() const final { return _cached_size_.Get(); }
|
||||
|
||||
private:
|
||||
inline void SharedCtor();
|
||||
inline void SharedDtor();
|
||||
void SetCachedSize(int size) const final;
|
||||
void InternalSwap(QuerySegmentInfoRequest* other);
|
||||
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
||||
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
||||
return "milvus.proto.milvus.QuerySegmentInfoRequest";
|
||||
}
|
||||
private:
|
||||
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
|
||||
return nullptr;
|
||||
}
|
||||
inline void* MaybeArenaPtr() const {
|
||||
return nullptr;
|
||||
}
|
||||
public:
|
||||
|
||||
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
||||
private:
|
||||
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
|
||||
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
|
||||
return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
// nested types ----------------------------------------------------
|
||||
|
||||
// accessors -------------------------------------------------------
|
||||
|
||||
enum : int {
|
||||
kDbNameFieldNumber = 2,
|
||||
kCollectionNameFieldNumber = 3,
|
||||
kBaseFieldNumber = 1,
|
||||
};
|
||||
// string dbName = 2;
|
||||
void clear_dbname();
|
||||
const std::string& dbname() const;
|
||||
void set_dbname(const std::string& value);
|
||||
void set_dbname(std::string&& value);
|
||||
void set_dbname(const char* value);
|
||||
void set_dbname(const char* value, size_t size);
|
||||
std::string* mutable_dbname();
|
||||
std::string* release_dbname();
|
||||
void set_allocated_dbname(std::string* dbname);
|
||||
|
||||
// string collectionName = 3;
|
||||
void clear_collectionname();
|
||||
const std::string& collectionname() const;
|
||||
void set_collectionname(const std::string& value);
|
||||
void set_collectionname(std::string&& value);
|
||||
void set_collectionname(const char* value);
|
||||
void set_collectionname(const char* value, size_t size);
|
||||
std::string* mutable_collectionname();
|
||||
std::string* release_collectionname();
|
||||
void set_allocated_collectionname(std::string* collectionname);
|
||||
|
||||
// .milvus.proto.common.MsgBase base = 1;
|
||||
bool has_base() const;
|
||||
void clear_base();
|
||||
const ::milvus::proto::common::MsgBase& base() const;
|
||||
::milvus::proto::common::MsgBase* release_base();
|
||||
::milvus::proto::common::MsgBase* mutable_base();
|
||||
void set_allocated_base(::milvus::proto::common::MsgBase* base);
|
||||
|
||||
// @@protoc_insertion_point(class_scope:milvus.proto.milvus.QuerySegmentInfoRequest)
|
||||
private:
|
||||
class _Internal;
|
||||
|
||||
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
|
||||
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_;
|
||||
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collectionname_;
|
||||
::milvus::proto::common::MsgBase* base_;
|
||||
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
||||
friend struct ::TableStruct_milvus_2eproto;
|
||||
};
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
class QuerySegmentInfoResponse :
|
||||
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.QuerySegmentInfoResponse) */ {
|
||||
public:
|
||||
QuerySegmentInfoResponse();
|
||||
virtual ~QuerySegmentInfoResponse();
|
||||
|
||||
QuerySegmentInfoResponse(const QuerySegmentInfoResponse& from);
|
||||
QuerySegmentInfoResponse(QuerySegmentInfoResponse&& from) noexcept
|
||||
: QuerySegmentInfoResponse() {
|
||||
*this = ::std::move(from);
|
||||
}
|
||||
|
||||
inline QuerySegmentInfoResponse& operator=(const QuerySegmentInfoResponse& from) {
|
||||
CopyFrom(from);
|
||||
return *this;
|
||||
}
|
||||
inline QuerySegmentInfoResponse& operator=(QuerySegmentInfoResponse&& from) noexcept {
|
||||
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||||
if (this != &from) InternalSwap(&from);
|
||||
} else {
|
||||
CopyFrom(from);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
||||
return GetDescriptor();
|
||||
}
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
||||
return GetMetadataStatic().descriptor;
|
||||
}
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
||||
return GetMetadataStatic().reflection;
|
||||
}
|
||||
static const QuerySegmentInfoResponse& default_instance();
|
||||
|
||||
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||||
static inline const QuerySegmentInfoResponse* internal_default_instance() {
|
||||
return reinterpret_cast<const QuerySegmentInfoResponse*>(
|
||||
&_QuerySegmentInfoResponse_default_instance_);
|
||||
}
|
||||
static constexpr int kIndexInFileMessages =
|
||||
45;
|
||||
|
||||
friend void swap(QuerySegmentInfoResponse& a, QuerySegmentInfoResponse& b) {
|
||||
a.Swap(&b);
|
||||
}
|
||||
inline void Swap(QuerySegmentInfoResponse* other) {
|
||||
if (other == this) return;
|
||||
InternalSwap(other);
|
||||
}
|
||||
|
||||
// implements Message ----------------------------------------------
|
||||
|
||||
inline QuerySegmentInfoResponse* New() const final {
|
||||
return CreateMaybeMessage<QuerySegmentInfoResponse>(nullptr);
|
||||
}
|
||||
|
||||
QuerySegmentInfoResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
||||
return CreateMaybeMessage<QuerySegmentInfoResponse>(arena);
|
||||
}
|
||||
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
||||
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
||||
void CopyFrom(const QuerySegmentInfoResponse& from);
|
||||
void MergeFrom(const QuerySegmentInfoResponse& from);
|
||||
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
||||
bool IsInitialized() const final;
|
||||
|
||||
size_t ByteSizeLong() const final;
|
||||
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
|
||||
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
||||
#else
|
||||
bool MergePartialFromCodedStream(
|
||||
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
|
||||
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
|
||||
void SerializeWithCachedSizes(
|
||||
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
|
||||
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
|
||||
::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
|
||||
int GetCachedSize() const final { return _cached_size_.Get(); }
|
||||
|
||||
private:
|
||||
inline void SharedCtor();
|
||||
inline void SharedDtor();
|
||||
void SetCachedSize(int size) const final;
|
||||
void InternalSwap(QuerySegmentInfoResponse* other);
|
||||
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
||||
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
||||
return "milvus.proto.milvus.QuerySegmentInfoResponse";
|
||||
}
|
||||
private:
|
||||
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
|
||||
return nullptr;
|
||||
}
|
||||
inline void* MaybeArenaPtr() const {
|
||||
return nullptr;
|
||||
}
|
||||
public:
|
||||
|
||||
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
||||
private:
|
||||
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
|
||||
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
|
||||
return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
// nested types ----------------------------------------------------
|
||||
|
||||
// accessors -------------------------------------------------------
|
||||
|
||||
enum : int {
|
||||
kInfosFieldNumber = 2,
|
||||
kStatusFieldNumber = 1,
|
||||
};
|
||||
// repeated .milvus.proto.milvus.QuerySegmentInfo infos = 2;
|
||||
int infos_size() const;
|
||||
void clear_infos();
|
||||
::milvus::proto::milvus::QuerySegmentInfo* mutable_infos(int index);
|
||||
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::milvus::QuerySegmentInfo >*
|
||||
mutable_infos();
|
||||
const ::milvus::proto::milvus::QuerySegmentInfo& infos(int index) const;
|
||||
::milvus::proto::milvus::QuerySegmentInfo* add_infos();
|
||||
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::milvus::QuerySegmentInfo >&
|
||||
infos() const;
|
||||
|
||||
// .milvus.proto.common.Status status = 1;
|
||||
bool has_status() const;
|
||||
void clear_status();
|
||||
const ::milvus::proto::common::Status& status() const;
|
||||
::milvus::proto::common::Status* release_status();
|
||||
::milvus::proto::common::Status* mutable_status();
|
||||
void set_allocated_status(::milvus::proto::common::Status* status);
|
||||
|
||||
// @@protoc_insertion_point(class_scope:milvus.proto.milvus.QuerySegmentInfoResponse)
|
||||
private:
|
||||
class _Internal;
|
||||
|
||||
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
|
||||
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::milvus::QuerySegmentInfo > infos_;
|
||||
::milvus::proto::common::Status* status_;
|
||||
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
||||
friend struct ::TableStruct_milvus_2eproto;
|
||||
};
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
class RegisterLinkResponse :
|
||||
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.RegisterLinkResponse) */ {
|
||||
public:
|
||||
|
|
@ -7290,7 +7788,7 @@ class RegisterLinkResponse :
|
|||
&_RegisterLinkResponse_default_instance_);
|
||||
}
|
||||
static constexpr int kIndexInFileMessages =
|
||||
43;
|
||||
46;
|
||||
|
||||
friend void swap(RegisterLinkResponse& a, RegisterLinkResponse& b) {
|
||||
a.Swap(&b);
|
||||
|
|
@ -13552,6 +14050,375 @@ PersistentSegmentInfoResponse::infos() const {
|
|||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// QuerySegmentInfo
|
||||
|
||||
// int64 segmentID = 1;
|
||||
inline void QuerySegmentInfo::clear_segmentid() {
|
||||
segmentid_ = PROTOBUF_LONGLONG(0);
|
||||
}
|
||||
inline ::PROTOBUF_NAMESPACE_ID::int64 QuerySegmentInfo::segmentid() const {
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfo.segmentID)
|
||||
return segmentid_;
|
||||
}
|
||||
inline void QuerySegmentInfo::set_segmentid(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
||||
|
||||
segmentid_ = value;
|
||||
// @@protoc_insertion_point(field_set:milvus.proto.milvus.QuerySegmentInfo.segmentID)
|
||||
}
|
||||
|
||||
// int64 collectionID = 2;
|
||||
inline void QuerySegmentInfo::clear_collectionid() {
|
||||
collectionid_ = PROTOBUF_LONGLONG(0);
|
||||
}
|
||||
inline ::PROTOBUF_NAMESPACE_ID::int64 QuerySegmentInfo::collectionid() const {
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfo.collectionID)
|
||||
return collectionid_;
|
||||
}
|
||||
inline void QuerySegmentInfo::set_collectionid(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
||||
|
||||
collectionid_ = value;
|
||||
// @@protoc_insertion_point(field_set:milvus.proto.milvus.QuerySegmentInfo.collectionID)
|
||||
}
|
||||
|
||||
// int64 partitionID = 3;
|
||||
inline void QuerySegmentInfo::clear_partitionid() {
|
||||
partitionid_ = PROTOBUF_LONGLONG(0);
|
||||
}
|
||||
inline ::PROTOBUF_NAMESPACE_ID::int64 QuerySegmentInfo::partitionid() const {
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfo.partitionID)
|
||||
return partitionid_;
|
||||
}
|
||||
inline void QuerySegmentInfo::set_partitionid(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
||||
|
||||
partitionid_ = value;
|
||||
// @@protoc_insertion_point(field_set:milvus.proto.milvus.QuerySegmentInfo.partitionID)
|
||||
}
|
||||
|
||||
// int64 mem_size = 4;
|
||||
inline void QuerySegmentInfo::clear_mem_size() {
|
||||
mem_size_ = PROTOBUF_LONGLONG(0);
|
||||
}
|
||||
inline ::PROTOBUF_NAMESPACE_ID::int64 QuerySegmentInfo::mem_size() const {
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfo.mem_size)
|
||||
return mem_size_;
|
||||
}
|
||||
inline void QuerySegmentInfo::set_mem_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
||||
|
||||
mem_size_ = value;
|
||||
// @@protoc_insertion_point(field_set:milvus.proto.milvus.QuerySegmentInfo.mem_size)
|
||||
}
|
||||
|
||||
// int64 num_rows = 5;
|
||||
inline void QuerySegmentInfo::clear_num_rows() {
|
||||
num_rows_ = PROTOBUF_LONGLONG(0);
|
||||
}
|
||||
inline ::PROTOBUF_NAMESPACE_ID::int64 QuerySegmentInfo::num_rows() const {
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfo.num_rows)
|
||||
return num_rows_;
|
||||
}
|
||||
inline void QuerySegmentInfo::set_num_rows(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
||||
|
||||
num_rows_ = value;
|
||||
// @@protoc_insertion_point(field_set:milvus.proto.milvus.QuerySegmentInfo.num_rows)
|
||||
}
|
||||
|
||||
// string index_name = 6;
|
||||
inline void QuerySegmentInfo::clear_index_name() {
|
||||
index_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
||||
}
|
||||
inline const std::string& QuerySegmentInfo::index_name() const {
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfo.index_name)
|
||||
return index_name_.GetNoArena();
|
||||
}
|
||||
inline void QuerySegmentInfo::set_index_name(const std::string& value) {
|
||||
|
||||
index_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
|
||||
// @@protoc_insertion_point(field_set:milvus.proto.milvus.QuerySegmentInfo.index_name)
|
||||
}
|
||||
inline void QuerySegmentInfo::set_index_name(std::string&& value) {
|
||||
|
||||
index_name_.SetNoArena(
|
||||
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||||
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.QuerySegmentInfo.index_name)
|
||||
}
|
||||
inline void QuerySegmentInfo::set_index_name(const char* value) {
|
||||
GOOGLE_DCHECK(value != nullptr);
|
||||
|
||||
index_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||||
// @@protoc_insertion_point(field_set_char:milvus.proto.milvus.QuerySegmentInfo.index_name)
|
||||
}
|
||||
inline void QuerySegmentInfo::set_index_name(const char* value, size_t size) {
|
||||
|
||||
index_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
||||
::std::string(reinterpret_cast<const char*>(value), size));
|
||||
// @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.QuerySegmentInfo.index_name)
|
||||
}
|
||||
inline std::string* QuerySegmentInfo::mutable_index_name() {
|
||||
|
||||
// @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QuerySegmentInfo.index_name)
|
||||
return index_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
||||
}
|
||||
inline std::string* QuerySegmentInfo::release_index_name() {
|
||||
// @@protoc_insertion_point(field_release:milvus.proto.milvus.QuerySegmentInfo.index_name)
|
||||
|
||||
return index_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
||||
}
|
||||
inline void QuerySegmentInfo::set_allocated_index_name(std::string* index_name) {
|
||||
if (index_name != nullptr) {
|
||||
|
||||
} else {
|
||||
|
||||
}
|
||||
index_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), index_name);
|
||||
// @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.QuerySegmentInfo.index_name)
|
||||
}
|
||||
|
||||
// int64 indexID = 7;
|
||||
inline void QuerySegmentInfo::clear_indexid() {
|
||||
indexid_ = PROTOBUF_LONGLONG(0);
|
||||
}
|
||||
inline ::PROTOBUF_NAMESPACE_ID::int64 QuerySegmentInfo::indexid() const {
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfo.indexID)
|
||||
return indexid_;
|
||||
}
|
||||
inline void QuerySegmentInfo::set_indexid(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
||||
|
||||
indexid_ = value;
|
||||
// @@protoc_insertion_point(field_set:milvus.proto.milvus.QuerySegmentInfo.indexID)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// QuerySegmentInfoRequest
|
||||
|
||||
// .milvus.proto.common.MsgBase base = 1;
|
||||
inline bool QuerySegmentInfoRequest::has_base() const {
|
||||
return this != internal_default_instance() && base_ != nullptr;
|
||||
}
|
||||
inline const ::milvus::proto::common::MsgBase& QuerySegmentInfoRequest::base() const {
|
||||
const ::milvus::proto::common::MsgBase* p = base_;
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfoRequest.base)
|
||||
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::MsgBase*>(
|
||||
&::milvus::proto::common::_MsgBase_default_instance_);
|
||||
}
|
||||
inline ::milvus::proto::common::MsgBase* QuerySegmentInfoRequest::release_base() {
|
||||
// @@protoc_insertion_point(field_release:milvus.proto.milvus.QuerySegmentInfoRequest.base)
|
||||
|
||||
::milvus::proto::common::MsgBase* temp = base_;
|
||||
base_ = nullptr;
|
||||
return temp;
|
||||
}
|
||||
inline ::milvus::proto::common::MsgBase* QuerySegmentInfoRequest::mutable_base() {
|
||||
|
||||
if (base_ == nullptr) {
|
||||
auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaNoVirtual());
|
||||
base_ = p;
|
||||
}
|
||||
// @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QuerySegmentInfoRequest.base)
|
||||
return base_;
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_allocated_base(::milvus::proto::common::MsgBase* base) {
|
||||
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
|
||||
if (message_arena == nullptr) {
|
||||
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_);
|
||||
}
|
||||
if (base) {
|
||||
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
|
||||
if (message_arena != submessage_arena) {
|
||||
base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
||||
message_arena, base, submessage_arena);
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
}
|
||||
base_ = base;
|
||||
// @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.QuerySegmentInfoRequest.base)
|
||||
}
|
||||
|
||||
// string dbName = 2;
|
||||
inline void QuerySegmentInfoRequest::clear_dbname() {
|
||||
dbname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
||||
}
|
||||
inline const std::string& QuerySegmentInfoRequest::dbname() const {
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfoRequest.dbName)
|
||||
return dbname_.GetNoArena();
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_dbname(const std::string& value) {
|
||||
|
||||
dbname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
|
||||
// @@protoc_insertion_point(field_set:milvus.proto.milvus.QuerySegmentInfoRequest.dbName)
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_dbname(std::string&& value) {
|
||||
|
||||
dbname_.SetNoArena(
|
||||
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||||
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.QuerySegmentInfoRequest.dbName)
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_dbname(const char* value) {
|
||||
GOOGLE_DCHECK(value != nullptr);
|
||||
|
||||
dbname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||||
// @@protoc_insertion_point(field_set_char:milvus.proto.milvus.QuerySegmentInfoRequest.dbName)
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_dbname(const char* value, size_t size) {
|
||||
|
||||
dbname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
||||
::std::string(reinterpret_cast<const char*>(value), size));
|
||||
// @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.QuerySegmentInfoRequest.dbName)
|
||||
}
|
||||
inline std::string* QuerySegmentInfoRequest::mutable_dbname() {
|
||||
|
||||
// @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QuerySegmentInfoRequest.dbName)
|
||||
return dbname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
||||
}
|
||||
inline std::string* QuerySegmentInfoRequest::release_dbname() {
|
||||
// @@protoc_insertion_point(field_release:milvus.proto.milvus.QuerySegmentInfoRequest.dbName)
|
||||
|
||||
return dbname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_allocated_dbname(std::string* dbname) {
|
||||
if (dbname != nullptr) {
|
||||
|
||||
} else {
|
||||
|
||||
}
|
||||
dbname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dbname);
|
||||
// @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.QuerySegmentInfoRequest.dbName)
|
||||
}
|
||||
|
||||
// string collectionName = 3;
|
||||
inline void QuerySegmentInfoRequest::clear_collectionname() {
|
||||
collectionname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
||||
}
|
||||
inline const std::string& QuerySegmentInfoRequest::collectionname() const {
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfoRequest.collectionName)
|
||||
return collectionname_.GetNoArena();
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_collectionname(const std::string& value) {
|
||||
|
||||
collectionname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
|
||||
// @@protoc_insertion_point(field_set:milvus.proto.milvus.QuerySegmentInfoRequest.collectionName)
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_collectionname(std::string&& value) {
|
||||
|
||||
collectionname_.SetNoArena(
|
||||
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||||
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.QuerySegmentInfoRequest.collectionName)
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_collectionname(const char* value) {
|
||||
GOOGLE_DCHECK(value != nullptr);
|
||||
|
||||
collectionname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||||
// @@protoc_insertion_point(field_set_char:milvus.proto.milvus.QuerySegmentInfoRequest.collectionName)
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_collectionname(const char* value, size_t size) {
|
||||
|
||||
collectionname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
||||
::std::string(reinterpret_cast<const char*>(value), size));
|
||||
// @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.QuerySegmentInfoRequest.collectionName)
|
||||
}
|
||||
inline std::string* QuerySegmentInfoRequest::mutable_collectionname() {
|
||||
|
||||
// @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QuerySegmentInfoRequest.collectionName)
|
||||
return collectionname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
||||
}
|
||||
inline std::string* QuerySegmentInfoRequest::release_collectionname() {
|
||||
// @@protoc_insertion_point(field_release:milvus.proto.milvus.QuerySegmentInfoRequest.collectionName)
|
||||
|
||||
return collectionname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
||||
}
|
||||
inline void QuerySegmentInfoRequest::set_allocated_collectionname(std::string* collectionname) {
|
||||
if (collectionname != nullptr) {
|
||||
|
||||
} else {
|
||||
|
||||
}
|
||||
collectionname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collectionname);
|
||||
// @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.QuerySegmentInfoRequest.collectionName)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// QuerySegmentInfoResponse
|
||||
|
||||
// .milvus.proto.common.Status status = 1;
|
||||
inline bool QuerySegmentInfoResponse::has_status() const {
|
||||
return this != internal_default_instance() && status_ != nullptr;
|
||||
}
|
||||
inline const ::milvus::proto::common::Status& QuerySegmentInfoResponse::status() const {
|
||||
const ::milvus::proto::common::Status* p = status_;
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfoResponse.status)
|
||||
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::Status*>(
|
||||
&::milvus::proto::common::_Status_default_instance_);
|
||||
}
|
||||
inline ::milvus::proto::common::Status* QuerySegmentInfoResponse::release_status() {
|
||||
// @@protoc_insertion_point(field_release:milvus.proto.milvus.QuerySegmentInfoResponse.status)
|
||||
|
||||
::milvus::proto::common::Status* temp = status_;
|
||||
status_ = nullptr;
|
||||
return temp;
|
||||
}
|
||||
inline ::milvus::proto::common::Status* QuerySegmentInfoResponse::mutable_status() {
|
||||
|
||||
if (status_ == nullptr) {
|
||||
auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual());
|
||||
status_ = p;
|
||||
}
|
||||
// @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QuerySegmentInfoResponse.status)
|
||||
return status_;
|
||||
}
|
||||
inline void QuerySegmentInfoResponse::set_allocated_status(::milvus::proto::common::Status* status) {
|
||||
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
|
||||
if (message_arena == nullptr) {
|
||||
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
|
||||
}
|
||||
if (status) {
|
||||
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
|
||||
if (message_arena != submessage_arena) {
|
||||
status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
||||
message_arena, status, submessage_arena);
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
}
|
||||
status_ = status;
|
||||
// @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.QuerySegmentInfoResponse.status)
|
||||
}
|
||||
|
||||
// repeated .milvus.proto.milvus.QuerySegmentInfo infos = 2;
|
||||
inline int QuerySegmentInfoResponse::infos_size() const {
|
||||
return infos_.size();
|
||||
}
|
||||
inline void QuerySegmentInfoResponse::clear_infos() {
|
||||
infos_.Clear();
|
||||
}
|
||||
inline ::milvus::proto::milvus::QuerySegmentInfo* QuerySegmentInfoResponse::mutable_infos(int index) {
|
||||
// @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QuerySegmentInfoResponse.infos)
|
||||
return infos_.Mutable(index);
|
||||
}
|
||||
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::milvus::QuerySegmentInfo >*
|
||||
QuerySegmentInfoResponse::mutable_infos() {
|
||||
// @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.QuerySegmentInfoResponse.infos)
|
||||
return &infos_;
|
||||
}
|
||||
inline const ::milvus::proto::milvus::QuerySegmentInfo& QuerySegmentInfoResponse::infos(int index) const {
|
||||
// @@protoc_insertion_point(field_get:milvus.proto.milvus.QuerySegmentInfoResponse.infos)
|
||||
return infos_.Get(index);
|
||||
}
|
||||
inline ::milvus::proto::milvus::QuerySegmentInfo* QuerySegmentInfoResponse::add_infos() {
|
||||
// @@protoc_insertion_point(field_add:milvus.proto.milvus.QuerySegmentInfoResponse.infos)
|
||||
return infos_.Add();
|
||||
}
|
||||
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::milvus::QuerySegmentInfo >&
|
||||
QuerySegmentInfoResponse::infos() const {
|
||||
// @@protoc_insertion_point(field_list:milvus.proto.milvus.QuerySegmentInfoResponse.infos)
|
||||
return infos_;
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// RegisterLinkResponse
|
||||
|
||||
// .milvus.proto.common.Address address = 1;
|
||||
|
|
@ -13733,6 +14600,12 @@ inline void RegisterLinkResponse::set_allocated_status(::milvus::proto::common::
|
|||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
|
||||
// @@protoc_insertion_point(namespace_scope)
|
||||
|
||||
|
|
|
|||
|
|
@ -82,14 +82,12 @@ func TestDataSyncService_Start(t *testing.T) {
|
|||
insertChannels := Params.InsertChannelNames
|
||||
ddChannels := Params.DDChannelNames
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
insertStream := pulsarms.NewPulsarMsgStream(ctx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
insertStream.SetPulsarClient(pulsarURL)
|
||||
insertStream.CreatePulsarProducers(insertChannels)
|
||||
factory := pulsarms.NewFactory(pulsarURL, receiveBufSize, 1024)
|
||||
insertStream, _ := factory.NewMsgStream(ctx)
|
||||
insertStream.AsProducer(insertChannels)
|
||||
|
||||
ddStream := pulsarms.NewPulsarMsgStream(ctx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
ddStream.SetPulsarClient(pulsarURL)
|
||||
ddStream.CreatePulsarProducers(ddChannels)
|
||||
ddStream, _ := factory.NewMsgStream(ctx)
|
||||
ddStream.AsProducer(ddChannels)
|
||||
|
||||
var insertMsgStream msgstream.MsgStream = insertStream
|
||||
insertMsgStream.Start()
|
||||
|
|
|
|||
|
|
@ -664,26 +664,23 @@ func newInsertBufferNode(ctx context.Context, flushMeta *metaTable,
|
|||
}
|
||||
minioPrefix := Params.InsertBinlogRootPath
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
|
||||
//input stream, data node time tick
|
||||
wTt := pulsarms.NewPulsarMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
wTt.SetPulsarClient(Params.PulsarAddress)
|
||||
wTt.CreatePulsarProducers([]string{Params.TimeTickChannelName})
|
||||
wTt, _ := factory.NewMsgStream(ctx)
|
||||
wTt.AsProducer([]string{Params.TimeTickChannelName})
|
||||
var wTtMsgStream msgstream.MsgStream = wTt
|
||||
wTtMsgStream.Start()
|
||||
|
||||
// update statistics channel
|
||||
segS := pulsarms.NewPulsarMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
segS.SetPulsarClient(Params.PulsarAddress)
|
||||
segS.CreatePulsarProducers([]string{Params.SegmentStatisticsChannelName})
|
||||
segS, _ := factory.NewMsgStream(ctx)
|
||||
segS.AsProducer([]string{Params.SegmentStatisticsChannelName})
|
||||
var segStatisticsMsgStream msgstream.MsgStream = segS
|
||||
segStatisticsMsgStream.Start()
|
||||
|
||||
// segment flush completed channel
|
||||
cf := pulsarms.NewPulsarMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
cf.SetPulsarClient(Params.PulsarAddress)
|
||||
cf.CreatePulsarProducers([]string{Params.CompleteFlushChannelName})
|
||||
cf, _ := factory.NewMsgStream(ctx)
|
||||
cf.AsProducer([]string{Params.CompleteFlushChannelName})
|
||||
var completeFlushStream msgstream.MsgStream = cf
|
||||
completeFlushStream.Start()
|
||||
|
||||
|
|
|
|||
|
|
@ -15,11 +15,9 @@ func newDmInputNode(ctx context.Context) *flowgraph.InputNode {
|
|||
consumeChannels := Params.InsertChannelNames
|
||||
consumeSubName := Params.MsgChannelSubName
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
insertStream := pulsarms.NewPulsarTtMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
insertStream.SetPulsarClient(Params.PulsarAddress)
|
||||
|
||||
insertStream.CreatePulsarConsumers(consumeChannels, consumeSubName)
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
insertStream, _ := factory.NewTtMsgStream(ctx)
|
||||
insertStream.AsConsumer(consumeChannels, consumeSubName)
|
||||
|
||||
var stream msgstream.MsgStream = insertStream
|
||||
node := flowgraph.NewInputNode(&stream, "dmInputNode", maxQueueLength, maxParallelism)
|
||||
|
|
@ -32,10 +30,9 @@ func newDDInputNode(ctx context.Context) *flowgraph.InputNode {
|
|||
maxParallelism := Params.FlowGraphMaxParallelism
|
||||
consumeSubName := Params.MsgChannelSubName
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
tmpStream := pulsarms.NewPulsarTtMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
tmpStream.SetPulsarClient(Params.PulsarAddress)
|
||||
tmpStream.CreatePulsarConsumers(Params.DDChannelNames, consumeSubName)
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
tmpStream, _ := factory.NewTtMsgStream(ctx)
|
||||
tmpStream.AsConsumer(Params.DDChannelNames, consumeSubName)
|
||||
|
||||
var stream msgstream.MsgStream = tmpStream
|
||||
node := flowgraph.NewInputNode(&stream, "ddInputNode", maxQueueLength, maxParallelism)
|
||||
|
|
|
|||
|
|
@ -183,7 +183,7 @@ func (meta *meta) UpdateSegment(segmentInfo *datapb.SegmentInfo) error {
|
|||
|
||||
func (meta *meta) DropSegment(segmentID UniqueID) error {
|
||||
meta.ddLock.Lock()
|
||||
defer meta.ddLock.Unlock()
|
||||
meta.ddLock.Unlock()
|
||||
|
||||
if _, ok := meta.segID2Info[segmentID]; !ok {
|
||||
return newErrSegmentNotFound(segmentID)
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ type (
|
|||
}
|
||||
)
|
||||
|
||||
func newSegmentAllocator(meta *meta, allocator allocator) *segmentAllocatorImpl {
|
||||
func newSegmentAllocator(meta *meta, allocator allocator) (*segmentAllocatorImpl, error) {
|
||||
segmentAllocator := &segmentAllocatorImpl{
|
||||
mt: meta,
|
||||
segments: make(map[UniqueID]*segmentStatus),
|
||||
|
|
@ -80,7 +80,7 @@ func newSegmentAllocator(meta *meta, allocator allocator) *segmentAllocatorImpl
|
|||
segmentThresholdFactor: Params.SegmentSizeFactor,
|
||||
allocator: allocator,
|
||||
}
|
||||
return segmentAllocator
|
||||
return segmentAllocator, nil
|
||||
}
|
||||
|
||||
func (allocator *segmentAllocatorImpl) OpenSegment(segmentInfo *datapb.SegmentInfo) error {
|
||||
|
|
|
|||
|
|
@ -17,7 +17,8 @@ func TestAllocSegment(t *testing.T) {
|
|||
mockAllocator := newMockAllocator()
|
||||
meta, err := newMemoryMeta(mockAllocator)
|
||||
assert.Nil(t, err)
|
||||
segAllocator := newSegmentAllocator(meta, mockAllocator)
|
||||
segAllocator, err := newSegmentAllocator(meta, mockAllocator)
|
||||
assert.Nil(t, err)
|
||||
|
||||
schema := newTestSchema()
|
||||
collID, err := mockAllocator.allocID()
|
||||
|
|
@ -67,7 +68,8 @@ func TestSealSegment(t *testing.T) {
|
|||
mockAllocator := newMockAllocator()
|
||||
meta, err := newMemoryMeta(mockAllocator)
|
||||
assert.Nil(t, err)
|
||||
segAllocator := newSegmentAllocator(meta, mockAllocator)
|
||||
segAllocator, err := newSegmentAllocator(meta, mockAllocator)
|
||||
assert.Nil(t, err)
|
||||
|
||||
schema := newTestSchema()
|
||||
collID, err := mockAllocator.allocID()
|
||||
|
|
@ -103,7 +105,8 @@ func TestExpireSegment(t *testing.T) {
|
|||
mockAllocator := newMockAllocator()
|
||||
meta, err := newMemoryMeta(mockAllocator)
|
||||
assert.Nil(t, err)
|
||||
segAllocator := newSegmentAllocator(meta, mockAllocator)
|
||||
segAllocator, err := newSegmentAllocator(meta, mockAllocator)
|
||||
assert.Nil(t, err)
|
||||
|
||||
schema := newTestSchema()
|
||||
collID, err := mockAllocator.allocID()
|
||||
|
|
|
|||
|
|
@ -134,7 +134,10 @@ func (s *Server) Start() error {
|
|||
return err
|
||||
}
|
||||
s.statsHandler = newStatsHandler(s.meta)
|
||||
s.segAllocator = newSegmentAllocator(s.meta, s.allocator)
|
||||
s.segAllocator, err = newSegmentAllocator(s.meta, s.allocator)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
s.ddHandler = newDDHandler(s.meta, s.segAllocator)
|
||||
s.initSegmentInfoChannel()
|
||||
if err = s.loadMetaFromMaster(); err != nil {
|
||||
|
|
@ -170,25 +173,22 @@ func (s *Server) initMeta() error {
|
|||
}
|
||||
|
||||
func (s *Server) initSegmentInfoChannel() {
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
segmentInfoStream := pulsarms.NewPulsarMsgStream(s.ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
segmentInfoStream.SetPulsarClient(Params.PulsarAddress)
|
||||
segmentInfoStream.CreatePulsarProducers([]string{Params.SegmentInfoChannelName})
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
segmentInfoStream, _ := factory.NewMsgStream(s.ctx)
|
||||
segmentInfoStream.AsProducer([]string{Params.SegmentInfoChannelName})
|
||||
s.segmentInfoStream = segmentInfoStream
|
||||
s.segmentInfoStream.Start()
|
||||
}
|
||||
func (s *Server) initMsgProducer() error {
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
ttMsgStream := pulsarms.NewPulsarMsgStream(s.ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
ttMsgStream.SetPulsarClient(Params.PulsarAddress)
|
||||
ttMsgStream.CreatePulsarConsumers([]string{Params.TimeTickChannelName}, Params.DataServiceSubscriptionName)
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
ttMsgStream, _ := factory.NewMsgStream(s.ctx)
|
||||
ttMsgStream.AsConsumer([]string{Params.TimeTickChannelName}, Params.DataServiceSubscriptionName)
|
||||
s.ttMsgStream = ttMsgStream
|
||||
s.ttMsgStream.Start()
|
||||
timeTickBarrier := timesync.NewHardTimeTickBarrier(s.ttMsgStream, s.cluster.GetNodeIDs())
|
||||
dataNodeTTWatcher := newDataNodeTimeTickWatcher(s.meta, s.segAllocator, s.cluster)
|
||||
k2sStream := pulsarms.NewPulsarMsgStream(s.ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
k2sStream.SetPulsarClient(Params.PulsarAddress)
|
||||
k2sStream.CreatePulsarProducers(Params.K2SChannelNames)
|
||||
k2sStream, _ := factory.NewMsgStream(s.ctx)
|
||||
k2sStream.AsProducer(Params.K2SChannelNames)
|
||||
s.k2sMsgStream = k2sStream
|
||||
s.k2sMsgStream.Start()
|
||||
k2sMsgWatcher := timesync.NewMsgTimeTickWatcher(s.k2sMsgStream)
|
||||
|
|
@ -308,10 +308,9 @@ func (s *Server) startServerLoop() {
|
|||
|
||||
func (s *Server) startStatsChannel(ctx context.Context) {
|
||||
defer s.serverLoopWg.Done()
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
statsStream := pulsarms.NewPulsarMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
statsStream.SetPulsarClient(Params.PulsarAddress)
|
||||
statsStream.CreatePulsarConsumers([]string{Params.StatisticsChannelName}, Params.DataServiceSubscriptionName)
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
statsStream, _ := factory.NewMsgStream(ctx)
|
||||
statsStream.AsConsumer([]string{Params.StatisticsChannelName}, Params.DataServiceSubscriptionName)
|
||||
statsStream.Start()
|
||||
defer statsStream.Close()
|
||||
for {
|
||||
|
|
@ -335,10 +334,9 @@ func (s *Server) startStatsChannel(ctx context.Context) {
|
|||
|
||||
func (s *Server) startSegmentFlushChannel(ctx context.Context) {
|
||||
defer s.serverLoopWg.Done()
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
flushStream := pulsarms.NewPulsarMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
flushStream.SetPulsarClient(Params.PulsarAddress)
|
||||
flushStream.CreatePulsarConsumers([]string{Params.SegmentInfoChannelName}, Params.DataServiceSubscriptionName)
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
flushStream, _ := factory.NewMsgStream(ctx)
|
||||
flushStream.AsConsumer([]string{Params.SegmentInfoChannelName}, Params.DataServiceSubscriptionName)
|
||||
flushStream.Start()
|
||||
defer flushStream.Close()
|
||||
for {
|
||||
|
|
@ -371,10 +369,9 @@ func (s *Server) startSegmentFlushChannel(ctx context.Context) {
|
|||
|
||||
func (s *Server) startDDChannel(ctx context.Context) {
|
||||
defer s.serverLoopWg.Done()
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
ddStream := pulsarms.NewPulsarMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
ddStream.SetPulsarClient(Params.PulsarAddress)
|
||||
ddStream.CreatePulsarConsumers([]string{s.ddChannelName}, Params.DataServiceSubscriptionName)
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
ddStream, _ := factory.NewMsgStream(ctx)
|
||||
ddStream.AsConsumer([]string{s.ddChannelName}, Params.DataServiceSubscriptionName)
|
||||
ddStream.Start()
|
||||
defer ddStream.Close()
|
||||
for {
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ func TestDataNodeTTWatcher(t *testing.T) {
|
|||
allocator := newMockAllocator()
|
||||
meta, err := newMemoryMeta(allocator)
|
||||
assert.Nil(t, err)
|
||||
segAllocator := newSegmentAllocator(meta, allocator)
|
||||
segAllocator, err := newSegmentAllocator(meta, allocator)
|
||||
assert.Nil(t, err)
|
||||
watcher := newDataNodeTimeTickWatcher(meta, segAllocator, cluster)
|
||||
|
||||
|
|
|
|||
|
|
@ -324,3 +324,8 @@ func (s *Server) GetDdChannel(ctx context.Context, request *commonpb.Empty) (*mi
|
|||
func (s *Server) GetPersistentSegmentInfo(ctx context.Context, request *milvuspb.PersistentSegmentInfoRequest) (*milvuspb.PersistentSegmentInfoResponse, error) {
|
||||
return s.impl.GetPersistentSegmentInfo(request)
|
||||
}
|
||||
|
||||
func (s *Server) GetQuerySegmentInfo(ctx context.Context, request *milvuspb.QuerySegmentInfoRequest) (*milvuspb.QuerySegmentInfoResponse, error) {
|
||||
return s.impl.GetQuerySegmentInfo(request)
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -402,7 +402,6 @@ func (c *Core) tsLoop() {
|
|||
}
|
||||
}
|
||||
func (c *Core) setMsgStreams() error {
|
||||
dispatcherFactory := ms.ProtoUDFactory{}
|
||||
|
||||
if Params.PulsarAddress == "" {
|
||||
return errors.Errorf("PulsarAddress is empty")
|
||||
|
|
@ -415,26 +414,25 @@ func (c *Core) setMsgStreams() error {
|
|||
if Params.ProxyTimeTickChannel == "" {
|
||||
return errors.Errorf("ProxyTimeTickChannel is empty")
|
||||
}
|
||||
proxyTimeTickStream := pulsarms.NewPulsarMsgStream(c.ctx, 1024, 1024, dispatcherFactory.NewUnmarshalDispatcher())
|
||||
proxyTimeTickStream.SetPulsarClient(Params.PulsarAddress)
|
||||
proxyTimeTickStream.CreatePulsarConsumers([]string{Params.ProxyTimeTickChannel}, Params.MsgChannelSubName)
|
||||
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
proxyTimeTickStream, _ := factory.NewMsgStream(c.ctx)
|
||||
proxyTimeTickStream.AsConsumer([]string{Params.ProxyTimeTickChannel}, Params.MsgChannelSubName)
|
||||
proxyTimeTickStream.Start()
|
||||
|
||||
// master time tick channel
|
||||
if Params.TimeTickChannel == "" {
|
||||
return errors.Errorf("TimeTickChannel is empty")
|
||||
}
|
||||
timeTickStream := pulsarms.NewPulsarMsgStream(c.ctx, 1024, 1024, dispatcherFactory.NewUnmarshalDispatcher())
|
||||
timeTickStream.SetPulsarClient(Params.PulsarAddress)
|
||||
timeTickStream.CreatePulsarProducers([]string{Params.TimeTickChannel})
|
||||
timeTickStream, _ := factory.NewMsgStream(c.ctx)
|
||||
timeTickStream.AsProducer([]string{Params.TimeTickChannel})
|
||||
|
||||
// master dd channel
|
||||
if Params.DdChannel == "" {
|
||||
return errors.Errorf("DdChannel is empty")
|
||||
}
|
||||
ddStream := pulsarms.NewPulsarMsgStream(c.ctx, 1024, 1024, dispatcherFactory.NewUnmarshalDispatcher())
|
||||
ddStream.SetPulsarClient(Params.PulsarAddress)
|
||||
ddStream.CreatePulsarProducers([]string{Params.DdChannel})
|
||||
ddStream, _ := factory.NewMsgStream(c.ctx)
|
||||
ddStream.AsProducer([]string{Params.DdChannel})
|
||||
|
||||
c.SendTimeTick = func(t typeutil.Timestamp) error {
|
||||
msgPack := ms.MsgPack{}
|
||||
|
|
@ -567,9 +565,8 @@ func (c *Core) setMsgStreams() error {
|
|||
if Params.DataServiceSegmentChannel == "" {
|
||||
return errors.Errorf("DataServiceSegmentChannel is empty")
|
||||
}
|
||||
dataServiceStream := pulsarms.NewPulsarMsgStream(c.ctx, 1024, 1024, dispatcherFactory.NewUnmarshalDispatcher())
|
||||
dataServiceStream.SetPulsarClient(Params.PulsarAddress)
|
||||
dataServiceStream.CreatePulsarConsumers([]string{Params.DataServiceSegmentChannel}, Params.MsgChannelSubName)
|
||||
dataServiceStream, _ := factory.NewMsgStream(c.ctx)
|
||||
dataServiceStream.AsConsumer([]string{Params.DataServiceSegmentChannel}, Params.MsgChannelSubName)
|
||||
dataServiceStream.Start()
|
||||
c.DataServiceSegmentChan = make(chan *datapb.SegmentInfo, 1024)
|
||||
c.DataNodeSegmentFlushCompletedChan = make(chan typeutil.UniqueID, 1024)
|
||||
|
|
|
|||
|
|
@ -105,6 +105,17 @@ func (idx *indexMock) getFileArray() []string {
|
|||
return ret
|
||||
}
|
||||
|
||||
func consumeMsgChan(timeout time.Duration, targetChan <-chan *ms.MsgPack) {
|
||||
for {
|
||||
select {
|
||||
case <-time.After(timeout):
|
||||
return
|
||||
case <-targetChan:
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMasterService(t *testing.T) {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
|
|
@ -146,23 +157,19 @@ func TestMasterService(t *testing.T) {
|
|||
err = core.Start()
|
||||
assert.Nil(t, err)
|
||||
|
||||
factory := ms.ProtoUDFactory{}
|
||||
proxyTimeTickStream := pulsarms.NewPulsarMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
proxyTimeTickStream.SetPulsarClient(Params.PulsarAddress)
|
||||
proxyTimeTickStream.CreatePulsarProducers([]string{Params.ProxyTimeTickChannel})
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
proxyTimeTickStream, _ := factory.NewMsgStream(ctx)
|
||||
proxyTimeTickStream.AsProducer([]string{Params.ProxyTimeTickChannel})
|
||||
|
||||
dataServiceSegmentStream := pulsarms.NewPulsarMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
dataServiceSegmentStream.SetPulsarClient(Params.PulsarAddress)
|
||||
dataServiceSegmentStream.CreatePulsarProducers([]string{Params.DataServiceSegmentChannel})
|
||||
dataServiceSegmentStream, _ := factory.NewMsgStream(ctx)
|
||||
dataServiceSegmentStream.AsProducer([]string{Params.DataServiceSegmentChannel})
|
||||
|
||||
timeTickStream := pulsarms.NewPulsarMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
timeTickStream.SetPulsarClient(Params.PulsarAddress)
|
||||
timeTickStream.CreatePulsarConsumers([]string{Params.TimeTickChannel}, Params.MsgChannelSubName)
|
||||
timeTickStream, _ := factory.NewMsgStream(ctx)
|
||||
timeTickStream.AsConsumer([]string{Params.TimeTickChannel}, Params.MsgChannelSubName)
|
||||
timeTickStream.Start()
|
||||
|
||||
ddStream := pulsarms.NewPulsarMsgStream(ctx, 1024, 1024, factory.NewUnmarshalDispatcher())
|
||||
ddStream.SetPulsarClient(Params.PulsarAddress)
|
||||
ddStream.CreatePulsarConsumers([]string{Params.DdChannel}, Params.MsgChannelSubName)
|
||||
ddStream, _ := factory.NewMsgStream(ctx)
|
||||
ddStream.AsConsumer([]string{Params.DdChannel}, Params.MsgChannelSubName)
|
||||
ddStream.Start()
|
||||
|
||||
time.Sleep(time.Second)
|
||||
|
|
@ -405,6 +412,7 @@ func TestMasterService(t *testing.T) {
|
|||
CollectionName: "testColl",
|
||||
PartitionName: "testPartition",
|
||||
}
|
||||
consumeMsgChan(time.Second, ddStream.Chan())
|
||||
status, err := core.CreatePartition(req)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, status.ErrorCode, commonpb.ErrorCode_SUCCESS)
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
package msgstream
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
|
||||
"github.com/zilliztech/milvus-distributed/internal/util/typeutil"
|
||||
)
|
||||
|
|
@ -24,9 +26,17 @@ type MsgStream interface {
|
|||
Start()
|
||||
Close()
|
||||
Chan() <-chan *MsgPack
|
||||
AsProducer(channels []string)
|
||||
AsConsumer(channels []string, subName string)
|
||||
SetRepackFunc(repackFunc RepackFunc)
|
||||
|
||||
Produce(*MsgPack) error
|
||||
Broadcast(*MsgPack) error
|
||||
Consume() *MsgPack
|
||||
Seek(offset *MsgPosition) error
|
||||
}
|
||||
|
||||
type Factory interface {
|
||||
NewMsgStream(ctx context.Context) (MsgStream, error)
|
||||
NewTtMsgStream(ctx context.Context) (MsgStream, error)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,32 @@
|
|||
package pulsarms
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/zilliztech/milvus-distributed/internal/msgstream"
|
||||
)
|
||||
|
||||
type Factory struct {
|
||||
dispatcherFactory msgstream.ProtoUDFactory
|
||||
address string
|
||||
receiveBufSize int64
|
||||
pulsarBufSize int64
|
||||
}
|
||||
|
||||
func (f *Factory) NewMsgStream(ctx context.Context) (msgstream.MsgStream, error) {
|
||||
return newPulsarMsgStream(ctx, f.address, f.receiveBufSize, f.pulsarBufSize, f.dispatcherFactory.NewUnmarshalDispatcher())
|
||||
}
|
||||
|
||||
func (f *Factory) NewTtMsgStream(ctx context.Context) (msgstream.MsgStream, error) {
|
||||
return NewPulsarTtMsgStream(ctx, f.address, f.receiveBufSize, f.pulsarBufSize, f.dispatcherFactory.NewUnmarshalDispatcher())
|
||||
}
|
||||
|
||||
func NewFactory(address string, receiveBufSize int64, pulsarBufSize int64) *Factory {
|
||||
f := &Factory{
|
||||
dispatcherFactory: msgstream.ProtoUDFactory{},
|
||||
address: address,
|
||||
receiveBufSize: receiveBufSize,
|
||||
pulsarBufSize: pulsarBufSize,
|
||||
}
|
||||
return f
|
||||
}
|
||||
|
|
@ -141,18 +141,16 @@ func TestStream_task_Insert(t *testing.T) {
|
|||
msgPack.Msgs = append(msgPack.Msgs, getInsertTask(3, 3))
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
inputStream := NewPulsarMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.SetPulsarClient(pulsarAddress)
|
||||
inputStream.CreatePulsarProducers(producerChannels)
|
||||
inputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.AsProducer(producerChannels)
|
||||
inputStream.SetRepackFunc(newRepackFunc)
|
||||
inputStream.Start()
|
||||
|
||||
dispatcher := factory.NewUnmarshalDispatcher()
|
||||
outputStream := NewPulsarMsgStream(context.Background(), 100, 100, dispatcher)
|
||||
outputStream.SetPulsarClient(pulsarAddress)
|
||||
outputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, dispatcher)
|
||||
testTask := InsertTask{}
|
||||
dispatcher.AddMsgTemplate(commonpb.MsgType_kInsert, testTask.Unmarshal)
|
||||
outputStream.CreatePulsarConsumers(consumerChannels, consumerSubName)
|
||||
outputStream.AsConsumer(consumerChannels, consumerSubName)
|
||||
outputStream.Start()
|
||||
|
||||
err := inputStream.Produce(&msgPack)
|
||||
|
|
@ -161,7 +159,7 @@ func TestStream_task_Insert(t *testing.T) {
|
|||
}
|
||||
receiveCount := 0
|
||||
for {
|
||||
result := (*outputStream).Consume()
|
||||
result := outputStream.Consume()
|
||||
if len(result.Msgs) > 0 {
|
||||
msgs := result.Msgs
|
||||
for _, v := range msgs {
|
||||
|
|
|
|||
|
|
@ -52,7 +52,12 @@ type PulsarMsgStream struct {
|
|||
pulsarBufSize int64
|
||||
}
|
||||
|
||||
func NewPulsarMsgStream(ctx context.Context, receiveBufSize int64, pulsarBufSize int64, unmarshal UnmarshalDispatcher) *PulsarMsgStream {
|
||||
func newPulsarMsgStream(ctx context.Context,
|
||||
address string,
|
||||
receiveBufSize int64,
|
||||
pulsarBufSize int64,
|
||||
unmarshal UnmarshalDispatcher) (*PulsarMsgStream, error) {
|
||||
|
||||
streamCtx, streamCancel := context.WithCancel(ctx)
|
||||
producers := make([]Producer, 0)
|
||||
consumers := make([]Consumer, 0)
|
||||
|
|
@ -66,19 +71,17 @@ func NewPulsarMsgStream(ctx context.Context, receiveBufSize int64, pulsarBufSize
|
|||
unmarshal: unmarshal,
|
||||
pulsarBufSize: pulsarBufSize,
|
||||
}
|
||||
stream.receiveBuf = make(chan *MsgPack, receiveBufSize)
|
||||
return stream
|
||||
}
|
||||
|
||||
func (ms *PulsarMsgStream) SetPulsarClient(address string) {
|
||||
client, err := pulsar.NewClient(pulsar.ClientOptions{URL: address})
|
||||
if err != nil {
|
||||
log.Printf("Set pulsar client failed, error = %v", err)
|
||||
return nil, err
|
||||
}
|
||||
ms.client = client
|
||||
stream.client = client
|
||||
stream.receiveBuf = make(chan *MsgPack, receiveBufSize)
|
||||
return stream, nil
|
||||
}
|
||||
|
||||
func (ms *PulsarMsgStream) CreatePulsarProducers(channels []string) {
|
||||
func (ms *PulsarMsgStream) AsProducer(channels []string) {
|
||||
for i := 0; i < len(channels); i++ {
|
||||
fn := func() error {
|
||||
pp, err := ms.client.CreateProducer(pulsar.ProducerOptions{Topic: channels[i]})
|
||||
|
|
@ -100,7 +103,7 @@ func (ms *PulsarMsgStream) CreatePulsarProducers(channels []string) {
|
|||
}
|
||||
}
|
||||
|
||||
func (ms *PulsarMsgStream) CreatePulsarConsumers(channels []string,
|
||||
func (ms *PulsarMsgStream) AsConsumer(channels []string,
|
||||
subName string) {
|
||||
for i := 0; i < len(channels); i++ {
|
||||
fn := func() error {
|
||||
|
|
@ -479,7 +482,12 @@ type PulsarTtMsgStream struct {
|
|||
lastTimeStamp Timestamp
|
||||
}
|
||||
|
||||
func NewPulsarTtMsgStream(ctx context.Context, receiveBufSize int64, pulsarBufSize int64, unmarshal msgstream.UnmarshalDispatcher) *PulsarTtMsgStream {
|
||||
func NewPulsarTtMsgStream(ctx context.Context,
|
||||
address string,
|
||||
receiveBufSize int64,
|
||||
pulsarBufSize int64,
|
||||
unmarshal msgstream.UnmarshalDispatcher) (*PulsarTtMsgStream, error) {
|
||||
|
||||
streamCtx, streamCancel := context.WithCancel(ctx)
|
||||
pulsarMsgStream := PulsarMsgStream{
|
||||
ctx: streamCtx,
|
||||
|
|
@ -487,10 +495,17 @@ func NewPulsarTtMsgStream(ctx context.Context, receiveBufSize int64, pulsarBufSi
|
|||
pulsarBufSize: pulsarBufSize,
|
||||
unmarshal: unmarshal,
|
||||
}
|
||||
|
||||
client, err := pulsar.NewClient(pulsar.ClientOptions{URL: address})
|
||||
if err != nil {
|
||||
log.Printf("Set pulsar client failed, error = %v", err)
|
||||
return nil, err
|
||||
}
|
||||
pulsarMsgStream.client = client
|
||||
pulsarMsgStream.receiveBuf = make(chan *MsgPack, receiveBufSize)
|
||||
return &PulsarTtMsgStream{
|
||||
PulsarMsgStream: pulsarMsgStream,
|
||||
}
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (ms *PulsarTtMsgStream) Start() {
|
||||
|
|
|
|||
|
|
@ -176,9 +176,8 @@ func initPulsarStream(pulsarAddress string,
|
|||
factory := msgstream.ProtoUDFactory{}
|
||||
|
||||
// set input stream
|
||||
inputStream := NewPulsarMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.SetPulsarClient(pulsarAddress)
|
||||
inputStream.CreatePulsarProducers(producerChannels)
|
||||
inputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.AsProducer(producerChannels)
|
||||
for _, opt := range opts {
|
||||
inputStream.SetRepackFunc(opt)
|
||||
}
|
||||
|
|
@ -186,9 +185,8 @@ func initPulsarStream(pulsarAddress string,
|
|||
var input msgstream.MsgStream = inputStream
|
||||
|
||||
// set output stream
|
||||
outputStream := NewPulsarMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
outputStream.SetPulsarClient(pulsarAddress)
|
||||
outputStream.CreatePulsarConsumers(consumerChannels, consumerSubName)
|
||||
outputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
outputStream.AsConsumer(consumerChannels, consumerSubName)
|
||||
outputStream.Start()
|
||||
var output msgstream.MsgStream = outputStream
|
||||
|
||||
|
|
@ -203,9 +201,8 @@ func initPulsarTtStream(pulsarAddress string,
|
|||
factory := msgstream.ProtoUDFactory{}
|
||||
|
||||
// set input stream
|
||||
inputStream := NewPulsarMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.SetPulsarClient(pulsarAddress)
|
||||
inputStream.CreatePulsarProducers(producerChannels)
|
||||
inputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.AsProducer(producerChannels)
|
||||
for _, opt := range opts {
|
||||
inputStream.SetRepackFunc(opt)
|
||||
}
|
||||
|
|
@ -213,9 +210,8 @@ func initPulsarTtStream(pulsarAddress string,
|
|||
var input msgstream.MsgStream = inputStream
|
||||
|
||||
// set output stream
|
||||
outputStream := NewPulsarTtMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
outputStream.SetPulsarClient(pulsarAddress)
|
||||
outputStream.CreatePulsarConsumers(consumerChannels, consumerSubName)
|
||||
outputStream, _ := NewPulsarTtMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
outputStream.AsConsumer(consumerChannels, consumerSubName)
|
||||
outputStream.Start()
|
||||
var output msgstream.MsgStream = outputStream
|
||||
|
||||
|
|
@ -417,14 +413,12 @@ func TestStream_PulsarMsgStream_InsertRepackFunc(t *testing.T) {
|
|||
msgPack.Msgs = append(msgPack.Msgs, insertMsg)
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
inputStream := NewPulsarMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.SetPulsarClient(pulsarAddress)
|
||||
inputStream.CreatePulsarProducers(producerChannels)
|
||||
inputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.AsProducer(producerChannels)
|
||||
inputStream.Start()
|
||||
|
||||
outputStream := NewPulsarMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
outputStream.SetPulsarClient(pulsarAddress)
|
||||
outputStream.CreatePulsarConsumers(consumerChannels, consumerSubName)
|
||||
outputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
outputStream.AsConsumer(consumerChannels, consumerSubName)
|
||||
outputStream.Start()
|
||||
var output msgstream.MsgStream = outputStream
|
||||
|
||||
|
|
@ -470,14 +464,12 @@ func TestStream_PulsarMsgStream_DeleteRepackFunc(t *testing.T) {
|
|||
msgPack.Msgs = append(msgPack.Msgs, deleteMsg)
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
inputStream := NewPulsarMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.SetPulsarClient(pulsarAddress)
|
||||
inputStream.CreatePulsarProducers(producerChannels)
|
||||
inputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.AsProducer(producerChannels)
|
||||
inputStream.Start()
|
||||
|
||||
outputStream := NewPulsarMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
outputStream.SetPulsarClient(pulsarAddress)
|
||||
outputStream.CreatePulsarConsumers(consumerChannels, consumerSubName)
|
||||
outputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
outputStream.AsConsumer(consumerChannels, consumerSubName)
|
||||
outputStream.Start()
|
||||
var output msgstream.MsgStream = outputStream
|
||||
|
||||
|
|
@ -503,14 +495,12 @@ func TestStream_PulsarMsgStream_DefaultRepackFunc(t *testing.T) {
|
|||
msgPack.Msgs = append(msgPack.Msgs, getTsMsg(commonpb.MsgType_kQueryNodeStats, 4, 4))
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
inputStream := NewPulsarMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.SetPulsarClient(pulsarAddress)
|
||||
inputStream.CreatePulsarProducers(producerChannels)
|
||||
inputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
inputStream.AsProducer(producerChannels)
|
||||
inputStream.Start()
|
||||
|
||||
outputStream := NewPulsarMsgStream(context.Background(), 100, 100, factory.NewUnmarshalDispatcher())
|
||||
outputStream.SetPulsarClient(pulsarAddress)
|
||||
outputStream.CreatePulsarConsumers(consumerChannels, consumerSubName)
|
||||
outputStream, _ := newPulsarMsgStream(context.Background(), pulsarAddress, 100, 100, factory.NewUnmarshalDispatcher())
|
||||
outputStream.AsConsumer(consumerChannels, consumerSubName)
|
||||
outputStream.Start()
|
||||
var output msgstream.MsgStream = outputStream
|
||||
|
||||
|
|
|
|||
|
|
@ -290,6 +290,27 @@ message PersistentSegmentInfoResponse {
|
|||
repeated PersistentSegmentInfo infos = 2;
|
||||
}
|
||||
|
||||
message QuerySegmentInfo {
|
||||
int64 segmentID = 1;
|
||||
int64 collectionID = 2;
|
||||
int64 partitionID = 3;
|
||||
int64 mem_size = 4;
|
||||
int64 num_rows = 5;
|
||||
string index_name = 6;
|
||||
int64 indexID = 7;
|
||||
}
|
||||
|
||||
message QuerySegmentInfoRequest {
|
||||
common.MsgBase base = 1;
|
||||
string dbName = 2;
|
||||
string collectionName = 3;
|
||||
}
|
||||
|
||||
message QuerySegmentInfoResponse {
|
||||
common.Status status = 1;
|
||||
repeated QuerySegmentInfo infos = 2;
|
||||
}
|
||||
|
||||
service MilvusService {
|
||||
rpc CreateCollection(CreateCollectionRequest) returns (common.Status) {}
|
||||
rpc DropCollection(DropCollectionRequest) returns (common.Status) {}
|
||||
|
|
@ -319,6 +340,7 @@ service MilvusService {
|
|||
rpc GetDdChannel(common.Empty) returns (StringResponse) {}
|
||||
|
||||
rpc GetPersistentSegmentInfo(PersistentSegmentInfoRequest) returns (PersistentSegmentInfoResponse) {}
|
||||
rpc GetQuerySegmentInfo(QuerySegmentInfoRequest) returns (QuerySegmentInfoResponse) {}
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2518,6 +2518,195 @@ func (m *PersistentSegmentInfoResponse) GetInfos() []*PersistentSegmentInfo {
|
|||
return nil
|
||||
}
|
||||
|
||||
type QuerySegmentInfo struct {
|
||||
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
|
||||
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
|
||||
PartitionID int64 `protobuf:"varint,3,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
|
||||
MemSize int64 `protobuf:"varint,4,opt,name=mem_size,json=memSize,proto3" json:"mem_size,omitempty"`
|
||||
NumRows int64 `protobuf:"varint,5,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"`
|
||||
IndexName string `protobuf:"bytes,6,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
|
||||
IndexID int64 `protobuf:"varint,7,opt,name=indexID,proto3" json:"indexID,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfo) Reset() { *m = QuerySegmentInfo{} }
|
||||
func (m *QuerySegmentInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*QuerySegmentInfo) ProtoMessage() {}
|
||||
func (*QuerySegmentInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{43}
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfo) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_QuerySegmentInfo.Unmarshal(m, b)
|
||||
}
|
||||
func (m *QuerySegmentInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_QuerySegmentInfo.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *QuerySegmentInfo) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_QuerySegmentInfo.Merge(m, src)
|
||||
}
|
||||
func (m *QuerySegmentInfo) XXX_Size() int {
|
||||
return xxx_messageInfo_QuerySegmentInfo.Size(m)
|
||||
}
|
||||
func (m *QuerySegmentInfo) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_QuerySegmentInfo.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_QuerySegmentInfo proto.InternalMessageInfo
|
||||
|
||||
func (m *QuerySegmentInfo) GetSegmentID() int64 {
|
||||
if m != nil {
|
||||
return m.SegmentID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfo) GetCollectionID() int64 {
|
||||
if m != nil {
|
||||
return m.CollectionID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfo) GetPartitionID() int64 {
|
||||
if m != nil {
|
||||
return m.PartitionID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfo) GetMemSize() int64 {
|
||||
if m != nil {
|
||||
return m.MemSize
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfo) GetNumRows() int64 {
|
||||
if m != nil {
|
||||
return m.NumRows
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfo) GetIndexName() string {
|
||||
if m != nil {
|
||||
return m.IndexName
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfo) GetIndexID() int64 {
|
||||
if m != nil {
|
||||
return m.IndexID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
type QuerySegmentInfoRequest struct {
|
||||
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
|
||||
DbName string `protobuf:"bytes,2,opt,name=dbName,proto3" json:"dbName,omitempty"`
|
||||
CollectionName string `protobuf:"bytes,3,opt,name=collectionName,proto3" json:"collectionName,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfoRequest) Reset() { *m = QuerySegmentInfoRequest{} }
|
||||
func (m *QuerySegmentInfoRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*QuerySegmentInfoRequest) ProtoMessage() {}
|
||||
func (*QuerySegmentInfoRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{44}
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfoRequest) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_QuerySegmentInfoRequest.Unmarshal(m, b)
|
||||
}
|
||||
func (m *QuerySegmentInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_QuerySegmentInfoRequest.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *QuerySegmentInfoRequest) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_QuerySegmentInfoRequest.Merge(m, src)
|
||||
}
|
||||
func (m *QuerySegmentInfoRequest) XXX_Size() int {
|
||||
return xxx_messageInfo_QuerySegmentInfoRequest.Size(m)
|
||||
}
|
||||
func (m *QuerySegmentInfoRequest) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_QuerySegmentInfoRequest.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_QuerySegmentInfoRequest proto.InternalMessageInfo
|
||||
|
||||
func (m *QuerySegmentInfoRequest) GetBase() *commonpb.MsgBase {
|
||||
if m != nil {
|
||||
return m.Base
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfoRequest) GetDbName() string {
|
||||
if m != nil {
|
||||
return m.DbName
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfoRequest) GetCollectionName() string {
|
||||
if m != nil {
|
||||
return m.CollectionName
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
type QuerySegmentInfoResponse struct {
|
||||
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
|
||||
Infos []*QuerySegmentInfo `protobuf:"bytes,2,rep,name=infos,proto3" json:"infos,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfoResponse) Reset() { *m = QuerySegmentInfoResponse{} }
|
||||
func (m *QuerySegmentInfoResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*QuerySegmentInfoResponse) ProtoMessage() {}
|
||||
func (*QuerySegmentInfoResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{45}
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfoResponse) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_QuerySegmentInfoResponse.Unmarshal(m, b)
|
||||
}
|
||||
func (m *QuerySegmentInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_QuerySegmentInfoResponse.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *QuerySegmentInfoResponse) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_QuerySegmentInfoResponse.Merge(m, src)
|
||||
}
|
||||
func (m *QuerySegmentInfoResponse) XXX_Size() int {
|
||||
return xxx_messageInfo_QuerySegmentInfoResponse.Size(m)
|
||||
}
|
||||
func (m *QuerySegmentInfoResponse) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_QuerySegmentInfoResponse.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_QuerySegmentInfoResponse proto.InternalMessageInfo
|
||||
|
||||
func (m *QuerySegmentInfoResponse) GetStatus() *commonpb.Status {
|
||||
if m != nil {
|
||||
return m.Status
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *QuerySegmentInfoResponse) GetInfos() []*QuerySegmentInfo {
|
||||
if m != nil {
|
||||
return m.Infos
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type RegisterLinkResponse struct {
|
||||
Address *commonpb.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
|
||||
Status *commonpb.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
|
||||
|
|
@ -2530,7 +2719,7 @@ func (m *RegisterLinkResponse) Reset() { *m = RegisterLinkResponse{} }
|
|||
func (m *RegisterLinkResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*RegisterLinkResponse) ProtoMessage() {}
|
||||
func (*RegisterLinkResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_02345ba45cc0e303, []int{43}
|
||||
return fileDescriptor_02345ba45cc0e303, []int{46}
|
||||
}
|
||||
|
||||
func (m *RegisterLinkResponse) XXX_Unmarshal(b []byte) error {
|
||||
|
|
@ -2610,131 +2799,139 @@ func init() {
|
|||
proto.RegisterType((*PersistentSegmentInfo)(nil), "milvus.proto.milvus.PersistentSegmentInfo")
|
||||
proto.RegisterType((*PersistentSegmentInfoRequest)(nil), "milvus.proto.milvus.PersistentSegmentInfoRequest")
|
||||
proto.RegisterType((*PersistentSegmentInfoResponse)(nil), "milvus.proto.milvus.PersistentSegmentInfoResponse")
|
||||
proto.RegisterType((*QuerySegmentInfo)(nil), "milvus.proto.milvus.QuerySegmentInfo")
|
||||
proto.RegisterType((*QuerySegmentInfoRequest)(nil), "milvus.proto.milvus.QuerySegmentInfoRequest")
|
||||
proto.RegisterType((*QuerySegmentInfoResponse)(nil), "milvus.proto.milvus.QuerySegmentInfoResponse")
|
||||
proto.RegisterType((*RegisterLinkResponse)(nil), "milvus.proto.milvus.RegisterLinkResponse")
|
||||
}
|
||||
|
||||
func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
|
||||
|
||||
var fileDescriptor_02345ba45cc0e303 = []byte{
|
||||
// 1879 bytes of a gzipped FileDescriptorProto
|
||||
// 1964 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xed, 0x6f, 0x1b, 0x49,
|
||||
0x19, 0xcf, 0xd8, 0x8e, 0x93, 0x3c, 0x59, 0x3b, 0xce, 0x34, 0x2f, 0xae, 0xaf, 0xe5, 0xd2, 0x85,
|
||||
0xbb, 0xa6, 0x2f, 0xd7, 0x40, 0x8e, 0xd7, 0x0f, 0x48, 0x6d, 0xea, 0x5e, 0x6a, 0xb5, 0xd7, 0x86,
|
||||
0x75, 0x38, 0x28, 0xa7, 0xca, 0xac, 0xbd, 0x53, 0x7b, 0xb9, 0x7d, 0x31, 0x3b, 0xe3, 0xa4, 0xe9,
|
||||
0x27, 0xc4, 0x21, 0x90, 0x00, 0x01, 0x9f, 0x90, 0xf8, 0x8a, 0xc4, 0x57, 0x04, 0x07, 0xe2, 0x3f,
|
||||
0x40, 0x42, 0xe2, 0x4f, 0x41, 0x7c, 0xe4, 0x23, 0x12, 0x9a, 0x99, 0xf5, 0x7a, 0x77, 0x33, 0x1b,
|
||||
0xbb, 0xf5, 0x1d, 0x71, 0xbf, 0x79, 0x9e, 0x79, 0x66, 0xe6, 0xf7, 0xbc, 0xce, 0xb3, 0xcf, 0x18,
|
||||
0x34, 0xd7, 0x76, 0x8e, 0x06, 0xf4, 0x56, 0x3f, 0xf0, 0x99, 0x8f, 0x2f, 0xc4, 0x47, 0xb7, 0xe4,
|
||||
0xa0, 0xa6, 0x75, 0x7c, 0xd7, 0xf5, 0x3d, 0x49, 0xac, 0x69, 0xb4, 0xd3, 0x23, 0xae, 0x29, 0x47,
|
||||
0xfa, 0x1f, 0x10, 0x6c, 0xde, 0x0d, 0x88, 0xc9, 0xc8, 0x5d, 0xdf, 0x71, 0x48, 0x87, 0xd9, 0xbe,
|
||||
0x67, 0x90, 0x1f, 0x0e, 0x08, 0x65, 0xf8, 0x8b, 0x50, 0x68, 0x9b, 0x94, 0x54, 0xd1, 0x16, 0xda,
|
||||
0x5e, 0xde, 0xbd, 0x74, 0x2b, 0xb1, 0x77, 0xb8, 0xe7, 0xfb, 0xb4, 0xbb, 0x67, 0x52, 0x62, 0x08,
|
||||
0x4e, 0xbc, 0x09, 0x0b, 0x56, 0xbb, 0xe5, 0x99, 0x2e, 0xa9, 0xe6, 0xb6, 0xd0, 0xf6, 0x92, 0x51,
|
||||
0xb4, 0xda, 0x8f, 0x4c, 0x97, 0xe0, 0xab, 0xb0, 0xd2, 0x89, 0xf6, 0x97, 0x0c, 0x79, 0xc1, 0x50,
|
||||
0x1e, 0x91, 0x05, 0xe3, 0x06, 0x14, 0x25, 0xbe, 0x6a, 0x61, 0x0b, 0x6d, 0x6b, 0x46, 0x38, 0xd2,
|
||||
0x7f, 0x81, 0x60, 0xbd, 0x1e, 0xf8, 0xfd, 0x99, 0x40, 0xa9, 0xff, 0x1c, 0xc1, 0xda, 0x7d, 0x93,
|
||||
0xce, 0x06, 0x98, 0x27, 0xa0, 0xed, 0xf9, 0xbe, 0x63, 0x10, 0xda, 0xf7, 0x3d, 0x4a, 0xf0, 0xbb,
|
||||
0x50, 0xa4, 0xcc, 0x64, 0x03, 0x1a, 0xa2, 0x78, 0x43, 0x89, 0xa2, 0x29, 0x58, 0x8c, 0x90, 0x15,
|
||||
0xaf, 0xc1, 0xfc, 0x91, 0xe9, 0x0c, 0x24, 0x88, 0x45, 0x43, 0x0e, 0xf4, 0x0f, 0xa1, 0xdc, 0x64,
|
||||
0x81, 0xed, 0x75, 0x3f, 0xc5, 0xcd, 0x97, 0x86, 0x9b, 0xff, 0x1a, 0xc1, 0xc5, 0x3a, 0xa1, 0x9d,
|
||||
0xc0, 0x6e, 0xcf, 0x86, 0xf3, 0xe9, 0x7f, 0x45, 0x50, 0x53, 0x21, 0x9a, 0x46, 0xf6, 0x6f, 0x46,
|
||||
0x0e, 0x9d, 0x13, 0x8b, 0xde, 0x4a, 0x2e, 0x0a, 0x83, 0x71, 0x74, 0x5a, 0x53, 0x10, 0x86, 0x7e,
|
||||
0x8f, 0x75, 0xd0, 0x46, 0x20, 0x1b, 0x75, 0x01, 0x3c, 0x6f, 0x24, 0x68, 0x22, 0x36, 0x1e, 0xfa,
|
||||
0xa6, 0x35, 0x1b, 0x4a, 0xfc, 0x15, 0x82, 0xaa, 0x41, 0x1c, 0x62, 0xd2, 0x19, 0xb1, 0xea, 0x2f,
|
||||
0x11, 0x6c, 0xc4, 0xf4, 0xcb, 0x4c, 0x46, 0xcf, 0x13, 0xce, 0xcf, 0x78, 0xc6, 0x4d, 0xc3, 0x99,
|
||||
0xc6, 0xc3, 0xbe, 0x06, 0xf3, 0xfc, 0x17, 0xad, 0xe6, 0xb6, 0xf2, 0xdb, 0xcb, 0xbb, 0x57, 0x94,
|
||||
0x6b, 0x1e, 0x90, 0x93, 0x0f, 0x78, 0xd4, 0x1d, 0x98, 0x76, 0x60, 0x48, 0x7e, 0xbd, 0x0d, 0xeb,
|
||||
0xcd, 0x9e, 0x7f, 0xfc, 0x59, 0x5a, 0x49, 0x7f, 0x0e, 0x1b, 0xe9, 0x33, 0xa6, 0x91, 0xf5, 0x1a,
|
||||
0x54, 0x52, 0x5a, 0x96, 0x62, 0x2f, 0x19, 0x2b, 0x49, 0x35, 0x53, 0xfd, 0x2f, 0xdc, 0xec, 0xe2,
|
||||
0x66, 0x3b, 0x30, 0x03, 0x66, 0x9f, 0xf7, 0xc5, 0xf6, 0x16, 0x94, 0xfb, 0x43, 0x1c, 0x92, 0xaf,
|
||||
0x20, 0xf8, 0x4a, 0x11, 0x55, 0xe8, 0xeb, 0xcf, 0x08, 0xd6, 0xf8, 0x3d, 0xf7, 0x3a, 0x61, 0xfe,
|
||||
0x13, 0x82, 0x0b, 0xf7, 0x4d, 0xfa, 0x3a, 0x41, 0xfe, 0x04, 0xc1, 0x05, 0x9e, 0x32, 0x25, 0xe6,
|
||||
0xf3, 0x85, 0x7c, 0x15, 0x56, 0x92, 0x90, 0x69, 0xb5, 0x20, 0x5c, 0xba, 0x9c, 0xc0, 0x4c, 0xf5,
|
||||
0xbf, 0x21, 0xd8, 0x0c, 0x33, 0xeb, 0x4c, 0xe8, 0x7a, 0x62, 0xe0, 0x9f, 0x20, 0x58, 0x8f, 0x10,
|
||||
0x9f, 0x77, 0x02, 0x9e, 0xd4, 0x45, 0x7e, 0x8a, 0x60, 0x23, 0x0d, 0xfa, 0x5c, 0xd2, 0xf4, 0x1f,
|
||||
0x11, 0xac, 0xf1, 0x1c, 0x3a, 0x13, 0x36, 0x4f, 0xd7, 0x23, 0x05, 0x45, 0x3d, 0xf2, 0x3b, 0x24,
|
||||
0x2f, 0x96, 0x18, 0xe0, 0x69, 0x14, 0xa7, 0x70, 0xb3, 0x9c, 0xca, 0xcd, 0x38, 0xb6, 0x88, 0xd2,
|
||||
0xa8, 0xd3, 0x6a, 0x7e, 0x2b, 0xcf, 0xb1, 0xc5, 0x69, 0xa2, 0x18, 0x18, 0x96, 0x78, 0x4d, 0xd2,
|
||||
0x75, 0x89, 0xc7, 0x5e, 0x5d, 0x9d, 0x69, 0x65, 0xe4, 0x4e, 0x2b, 0x03, 0x5f, 0x82, 0x25, 0x2a,
|
||||
0xcf, 0x89, 0xaa, 0xb7, 0x11, 0x41, 0xff, 0x31, 0x82, 0xcd, 0x53, 0x70, 0xa6, 0x51, 0x56, 0x15,
|
||||
0x16, 0x6c, 0xcf, 0x22, 0xcf, 0x23, 0x34, 0xc3, 0x21, 0x9f, 0x69, 0x0f, 0x6c, 0xc7, 0x8a, 0x60,
|
||||
0x0c, 0x87, 0x5c, 0x27, 0x98, 0xdb, 0xeb, 0xff, 0xa2, 0x8f, 0x2d, 0x58, 0x8e, 0x19, 0x24, 0x84,
|
||||
0x12, 0x27, 0xe9, 0x3f, 0x80, 0x0b, 0x09, 0x34, 0xd3, 0xa8, 0xe3, 0x73, 0x00, 0x91, 0xb2, 0xa5,
|
||||
0xdb, 0xe4, 0x8d, 0x18, 0x45, 0xff, 0x37, 0x02, 0x2c, 0x8b, 0x84, 0x06, 0x57, 0xd3, 0x79, 0x46,
|
||||
0xd6, 0x65, 0x80, 0x67, 0x36, 0x71, 0xac, 0x78, 0x4a, 0x5a, 0x12, 0x14, 0x31, 0x5d, 0x07, 0x8d,
|
||||
0x3c, 0x67, 0x81, 0xd9, 0xea, 0x9b, 0x81, 0xe9, 0xd2, 0xea, 0xfc, 0xa4, 0x59, 0x64, 0x59, 0x2c,
|
||||
0x3b, 0x10, 0xab, 0xf4, 0x7f, 0xf0, 0xf2, 0x22, 0xf4, 0xb7, 0x59, 0x97, 0xf8, 0x32, 0x80, 0xf0,
|
||||
0x5d, 0x39, 0x3d, 0x2f, 0xa7, 0x05, 0x45, 0xe4, 0x67, 0x07, 0x2a, 0x42, 0x02, 0x29, 0x4e, 0x9f,
|
||||
0xef, 0x9a, 0x5a, 0x82, 0x52, 0x4b, 0xf0, 0x37, 0xa0, 0x18, 0x6a, 0x6f, 0xe2, 0x1c, 0x1c, 0x2e,
|
||||
0xd0, 0x7f, 0x8f, 0x60, 0x3d, 0xa5, 0xb8, 0x69, 0xfc, 0xf2, 0x10, 0xb0, 0x04, 0x6a, 0x8d, 0xd0,
|
||||
0x0f, 0x51, 0xa5, 0xbe, 0x10, 0xc3, 0x41, 0x5a, 0x56, 0x63, 0xd5, 0x4e, 0x51, 0xa8, 0xfe, 0x77,
|
||||
0x04, 0xab, 0x82, 0x8f, 0x9f, 0x46, 0x5e, 0x5f, 0xd3, 0xfe, 0x08, 0x01, 0x8e, 0xcb, 0x31, 0x8d,
|
||||
0xa6, 0xbf, 0x22, 0xaf, 0x5d, 0x29, 0x49, 0x79, 0xf7, 0x4d, 0xe5, 0x9a, 0xd8, 0x61, 0x92, 0x5b,
|
||||
0xff, 0x2f, 0x82, 0x52, 0xc3, 0xa3, 0x24, 0x60, 0xb3, 0x5f, 0xaa, 0xe0, 0x2f, 0xc3, 0x62, 0xe0,
|
||||
0x1f, 0xb7, 0x2c, 0x93, 0x99, 0x61, 0x5e, 0xb8, 0xa8, 0x84, 0xb7, 0xe7, 0xf8, 0x6d, 0x63, 0x21,
|
||||
0xf0, 0x8f, 0xeb, 0x26, 0x33, 0xf1, 0x1b, 0xb0, 0xd4, 0x33, 0x69, 0xaf, 0xf5, 0x11, 0x39, 0xa1,
|
||||
0xd5, 0xe2, 0x56, 0x7e, 0xbb, 0x64, 0x2c, 0x72, 0xc2, 0x03, 0x72, 0x42, 0xf5, 0x8f, 0x11, 0x94,
|
||||
0x87, 0xf2, 0x4f, 0xa3, 0xfe, 0x37, 0x61, 0x39, 0xf0, 0x8f, 0x1b, 0xf5, 0x56, 0x9b, 0x74, 0x6d,
|
||||
0x2f, 0xbc, 0x11, 0x40, 0x90, 0xf6, 0x38, 0x85, 0xa3, 0x90, 0x0c, 0xc4, 0xb3, 0xc2, 0xdb, 0x60,
|
||||
0x51, 0x10, 0xee, 0x79, 0x96, 0x7e, 0x04, 0x95, 0x03, 0xc7, 0xec, 0x90, 0x9e, 0xef, 0x58, 0x24,
|
||||
0x10, 0x51, 0x89, 0x2b, 0x90, 0x67, 0x66, 0x37, 0x0c, 0x6e, 0xfe, 0x13, 0x7f, 0x1d, 0x0a, 0xec,
|
||||
0xa4, 0x3f, 0xb4, 0xf0, 0x17, 0x94, 0xe1, 0x13, 0xdb, 0xe6, 0xf0, 0xa4, 0x4f, 0x0c, 0xb1, 0x02,
|
||||
0x6f, 0x40, 0x51, 0xf4, 0xa2, 0x64, 0xad, 0xa0, 0x19, 0xe1, 0x48, 0x7f, 0x9a, 0x38, 0x77, 0x3f,
|
||||
0xf0, 0x07, 0x7d, 0xdc, 0x00, 0xad, 0x3f, 0xa2, 0x71, 0x25, 0x64, 0x07, 0x6b, 0x1a, 0xb4, 0x91,
|
||||
0x58, 0xaa, 0xff, 0x0b, 0x41, 0xa9, 0x49, 0xcc, 0xa0, 0xd3, 0x7b, 0x1d, 0xca, 0x77, 0xae, 0x71,
|
||||
0x8b, 0x3a, 0x61, 0x98, 0xf2, 0x9f, 0xf8, 0x06, 0xac, 0xc6, 0x04, 0x6a, 0x75, 0xb9, 0x82, 0xaa,
|
||||
0x45, 0xd1, 0xb0, 0xad, 0xf4, 0x53, 0x8a, 0xd3, 0x1f, 0x40, 0xe1, 0xbe, 0xcd, 0xc4, 0x36, 0xfc,
|
||||
0x12, 0x46, 0xe2, 0x12, 0xe6, 0x3f, 0xf1, 0xc5, 0x98, 0xdf, 0xe6, 0x84, 0x01, 0x22, 0xe7, 0x14,
|
||||
0x7d, 0x60, 0x3f, 0x08, 0x2d, 0x93, 0x33, 0xc2, 0x91, 0xfe, 0xdd, 0x91, 0xe6, 0xe8, 0xc0, 0x61,
|
||||
0xf4, 0xd5, 0xbc, 0x12, 0x43, 0xa1, 0x67, 0x87, 0xa5, 0xb8, 0x66, 0x88, 0xdf, 0xfa, 0x4f, 0x10,
|
||||
0x68, 0xef, 0x39, 0x03, 0xfa, 0x59, 0xd8, 0x44, 0xd5, 0xb6, 0xc8, 0xab, 0xdb, 0x16, 0xff, 0xcc,
|
||||
0xc1, 0xfa, 0x01, 0x09, 0xa8, 0x4d, 0x19, 0xf1, 0x58, 0x58, 0x04, 0x35, 0xbc, 0x67, 0x7e, 0xb2,
|
||||
0x92, 0x44, 0xa9, 0x4a, 0xf2, 0xd3, 0xa9, 0xbd, 0x78, 0x34, 0xfa, 0x7d, 0xe2, 0xb5, 0x98, 0x1d,
|
||||
0xe6, 0x9a, 0x82, 0xb1, 0xc8, 0x09, 0x87, 0xb6, 0x4b, 0x78, 0x2c, 0x53, 0x62, 0x3a, 0xc4, 0x92,
|
||||
0xd3, 0xf3, 0x62, 0x1a, 0x24, 0x49, 0x30, 0x5c, 0x01, 0xed, 0x19, 0xd7, 0xe0, 0x90, 0xa3, 0x28,
|
||||
0x38, 0x96, 0x43, 0x9a, 0x60, 0xb9, 0x08, 0x8b, 0xde, 0xc0, 0x6d, 0x05, 0xfe, 0x31, 0xad, 0x2e,
|
||||
0xc8, 0x32, 0xd4, 0x1b, 0xb8, 0x86, 0x7f, 0x2c, 0xbc, 0xc1, 0x25, 0x6e, 0x8b, 0xda, 0x2f, 0x48,
|
||||
0x75, 0x51, 0x4e, 0xb9, 0xc4, 0x6d, 0xda, 0x2f, 0xc8, 0xf0, 0xdb, 0x89, 0x54, 0x97, 0x44, 0x88,
|
||||
0xab, 0xef, 0xed, 0x50, 0x57, 0x89, 0x34, 0xfe, 0x1b, 0x04, 0x97, 0x94, 0xda, 0x7c, 0x75, 0x23,
|
||||
0x6f, 0x40, 0x68, 0xd5, 0x94, 0x8d, 0xdf, 0x86, 0x54, 0x80, 0x65, 0xf4, 0xff, 0x7e, 0x8b, 0xe0,
|
||||
0x72, 0x06, 0xa4, 0x69, 0x12, 0xed, 0x6d, 0x98, 0xb7, 0xbd, 0x67, 0xfe, 0xb0, 0x88, 0xb8, 0xae,
|
||||
0xce, 0x4b, 0xca, 0x73, 0xe5, 0x42, 0x9e, 0xf2, 0xd7, 0x0c, 0xd2, 0xe5, 0xf3, 0xc1, 0x43, 0xdb,
|
||||
0xfb, 0x28, 0xc2, 0xf3, 0x55, 0x58, 0x30, 0x2d, 0x2b, 0x20, 0x94, 0x9e, 0xa9, 0xa6, 0x3b, 0x92,
|
||||
0xc7, 0x18, 0x32, 0xc7, 0xe4, 0xc8, 0x4d, 0x2c, 0xc7, 0xf5, 0xdb, 0xb0, 0x92, 0xca, 0xd5, 0x78,
|
||||
0x11, 0x0a, 0x8f, 0x1e, 0x3f, 0xba, 0x57, 0x99, 0xc3, 0xab, 0x50, 0xfa, 0xe0, 0xde, 0xdd, 0xc3,
|
||||
0xc7, 0x46, 0x6b, 0xaf, 0xf1, 0xe8, 0x8e, 0xf1, 0xa4, 0x62, 0xe1, 0x0a, 0x68, 0x21, 0xe9, 0xbd,
|
||||
0x87, 0x8f, 0xef, 0x1c, 0x56, 0xc8, 0xee, 0x7f, 0x56, 0xa1, 0xf4, 0xbe, 0x38, 0xa8, 0x49, 0x82,
|
||||
0x23, 0xbb, 0x43, 0x70, 0x0b, 0x2a, 0xe9, 0x37, 0x2e, 0x7c, 0x53, 0xa9, 0xa0, 0x8c, 0xa7, 0xb0,
|
||||
0xda, 0x59, 0xd0, 0xf5, 0x39, 0xfc, 0x21, 0x94, 0x93, 0x8f, 0x53, 0x58, 0xad, 0x7f, 0xe5, 0x0b,
|
||||
0xd6, 0xb8, 0xcd, 0x5b, 0x50, 0x4a, 0xbc, 0x35, 0xe1, 0x6b, 0xca, 0xbd, 0x55, 0xef, 0x51, 0xb5,
|
||||
0x2b, 0x4a, 0xd6, 0xf8, 0x73, 0x91, 0x44, 0x9f, 0x7c, 0x3e, 0xc8, 0x40, 0xaf, 0x7c, 0x63, 0x18,
|
||||
0x87, 0xde, 0x84, 0xd5, 0x53, 0xaf, 0x01, 0xf8, 0x1d, 0xe5, 0xfe, 0x59, 0xaf, 0x06, 0xe3, 0x8e,
|
||||
0x38, 0x06, 0x7c, 0xfa, 0xd5, 0x06, 0xdf, 0x52, 0x5b, 0x20, 0xeb, 0xc1, 0xa9, 0xb6, 0x33, 0x31,
|
||||
0x7f, 0xa4, 0xb8, 0x23, 0xd8, 0xdc, 0x27, 0x2c, 0xd9, 0xcc, 0xb7, 0x29, 0xb3, 0x3b, 0x14, 0xdf,
|
||||
0x50, 0xbb, 0x97, 0xf2, 0x19, 0xa2, 0x76, 0x73, 0x32, 0xe6, 0xe8, 0x5c, 0x07, 0x56, 0x92, 0x4d,
|
||||
0x75, 0x9a, 0x61, 0x31, 0x65, 0x7b, 0xbf, 0x76, 0x63, 0x22, 0xde, 0xe8, 0xb4, 0xa7, 0xb0, 0x92,
|
||||
0xea, 0xa3, 0x67, 0x49, 0xa7, 0xec, 0xb6, 0x8f, 0xb3, 0xde, 0x13, 0x28, 0x25, 0x1a, 0xde, 0x19,
|
||||
0xee, 0xad, 0x6a, 0x8a, 0x8f, 0xdb, 0xfa, 0x29, 0x68, 0xf1, 0xbe, 0x34, 0xde, 0xce, 0x0a, 0x9c,
|
||||
0x53, 0x1b, 0x4f, 0x14, 0x37, 0x4f, 0x64, 0xdc, 0x44, 0x8b, 0x69, 0xc6, 0x01, 0x8a, 0x46, 0xf3,
|
||||
0x38, 0xe4, 0xdf, 0x8f, 0xa2, 0x26, 0xb6, 0xfb, 0xcd, 0xb3, 0xa2, 0xe6, 0x65, 0x75, 0x43, 0x61,
|
||||
0x63, 0x9f, 0xb0, 0x44, 0x83, 0x33, 0x74, 0xdd, 0x8c, 0xab, 0x43, 0xd5, 0xbf, 0xcd, 0x70, 0x25,
|
||||
0x75, 0xdb, 0x54, 0x9f, 0xc3, 0x36, 0x94, 0x13, 0x8d, 0x41, 0x9a, 0x61, 0x6c, 0x55, 0xbb, 0xb3,
|
||||
0x76, 0x7d, 0x12, 0xd6, 0xe8, 0xa8, 0x6f, 0xc3, 0x72, 0xac, 0xb1, 0x83, 0xaf, 0x9e, 0xe1, 0xb1,
|
||||
0xf1, 0x46, 0xc8, 0x38, 0xb5, 0xf5, 0xa0, 0x94, 0x68, 0x03, 0x64, 0x79, 0xab, 0xa2, 0xc7, 0x92,
|
||||
0x21, 0x80, 0xb2, 0xab, 0xa0, 0xcf, 0xe1, 0x36, 0x94, 0xf6, 0x09, 0x1b, 0x7d, 0x99, 0xe2, 0xb7,
|
||||
0xb3, 0xfb, 0x02, 0xf1, 0xef, 0xfd, 0xda, 0xd5, 0xb1, 0x7c, 0xd1, 0x19, 0x4d, 0x28, 0xca, 0x8f,
|
||||
0x3c, 0xac, 0x67, 0x2c, 0x8a, 0x7d, 0x01, 0xd7, 0x3e, 0x7f, 0x26, 0x4f, 0xb4, 0xa9, 0x01, 0x45,
|
||||
0x59, 0xa2, 0x67, 0x6c, 0x9a, 0xf8, 0xf2, 0xa9, 0x9d, 0xcd, 0x23, 0x6a, 0x7c, 0x7d, 0x0e, 0x37,
|
||||
0x60, 0x5e, 0xd4, 0xe6, 0x58, 0x1d, 0x98, 0xf1, 0xba, 0x7d, 0x9c, 0x05, 0xbf, 0x05, 0xda, 0x3e,
|
||||
0x61, 0x75, 0xeb, 0x6e, 0xcf, 0xf4, 0x3c, 0xe2, 0xe0, 0x9a, 0x92, 0xfd, 0x9e, 0xdb, 0x67, 0x27,
|
||||
0x19, 0x12, 0x27, 0xff, 0x12, 0xa1, 0xcf, 0xe1, 0x8f, 0x11, 0x54, 0x79, 0x30, 0x29, 0xcb, 0xf6,
|
||||
0x2f, 0xbd, 0x44, 0x25, 0x16, 0x4a, 0xb0, 0xfb, 0x32, 0x4b, 0x86, 0x28, 0x76, 0xbb, 0xa0, 0x1d,
|
||||
0x04, 0xfe, 0xf3, 0x93, 0x61, 0xd5, 0xf3, 0x1d, 0xd0, 0xe2, 0xe5, 0xdc, 0x99, 0x82, 0x5e, 0xcb,
|
||||
0x48, 0x2d, 0xa7, 0xab, 0x41, 0x7d, 0x6e, 0x6f, 0xef, 0x7b, 0xb7, 0xbb, 0x36, 0xeb, 0x0d, 0xda,
|
||||
0x7c, 0x8f, 0x9d, 0x17, 0xb6, 0xe3, 0xd8, 0x2f, 0x18, 0xe9, 0xf4, 0x76, 0xe4, 0xb2, 0x77, 0x2c,
|
||||
0x9b, 0xb2, 0xc0, 0x6e, 0x0f, 0x18, 0xb1, 0x76, 0x6c, 0x8f, 0x91, 0xc0, 0x33, 0x9d, 0x1d, 0xb1,
|
||||
0x71, 0xc8, 0xd1, 0x6f, 0xb7, 0x8b, 0x62, 0xfc, 0xee, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x92,
|
||||
0x88, 0x64, 0x88, 0xbf, 0x24, 0x00, 0x00,
|
||||
0x19, 0xcf, 0xd8, 0x8e, 0x93, 0x3c, 0xb1, 0x13, 0x67, 0xf2, 0xe6, 0xfa, 0x5a, 0x2e, 0x1d, 0xb8,
|
||||
0x6b, 0xfa, 0x1a, 0xc8, 0xf1, 0x2a, 0x84, 0xd4, 0xa6, 0xe9, 0xa5, 0x56, 0x7b, 0x6d, 0x6e, 0x1d,
|
||||
0x0e, 0xca, 0xa9, 0x32, 0x6b, 0xef, 0xd4, 0x5e, 0x6e, 0xbd, 0x6b, 0x76, 0xc6, 0x49, 0xd3, 0x4f,
|
||||
0x88, 0x22, 0x90, 0xb8, 0x13, 0xf0, 0x09, 0x89, 0xaf, 0x48, 0x7c, 0x45, 0x70, 0x20, 0xfe, 0x03,
|
||||
0x24, 0x24, 0xfe, 0x0e, 0x3e, 0x9d, 0xf8, 0x13, 0x90, 0xd0, 0xcc, 0xac, 0x37, 0xbb, 0xeb, 0xd9,
|
||||
0xd8, 0xad, 0xef, 0x1a, 0xf7, 0x9b, 0xe7, 0xd9, 0x67, 0x66, 0x7e, 0xcf, 0xdb, 0xcc, 0x33, 0xcf,
|
||||
0x63, 0x28, 0x74, 0x6c, 0xe7, 0xb0, 0xc7, 0x6e, 0x74, 0x7d, 0x8f, 0x7b, 0x78, 0x39, 0x3a, 0xba,
|
||||
0xa1, 0x06, 0x95, 0x42, 0xd3, 0xeb, 0x74, 0x3c, 0x57, 0x11, 0x2b, 0x05, 0xd6, 0x6c, 0xd3, 0x8e,
|
||||
0xa9, 0x46, 0xe4, 0x4f, 0x08, 0xd6, 0x6f, 0xfb, 0xd4, 0xe4, 0xf4, 0xb6, 0xe7, 0x38, 0xb4, 0xc9,
|
||||
0x6d, 0xcf, 0x35, 0xe8, 0x4f, 0x7b, 0x94, 0x71, 0xfc, 0x55, 0xc8, 0x35, 0x4c, 0x46, 0xcb, 0x68,
|
||||
0x03, 0x6d, 0xce, 0x6f, 0x9f, 0xbf, 0x11, 0x5b, 0x3b, 0x58, 0xf3, 0x3d, 0xd6, 0xda, 0x31, 0x19,
|
||||
0x35, 0x24, 0x27, 0x5e, 0x87, 0x19, 0xab, 0x51, 0x77, 0xcd, 0x0e, 0x2d, 0x67, 0x36, 0xd0, 0xe6,
|
||||
0x9c, 0x91, 0xb7, 0x1a, 0x0f, 0xcc, 0x0e, 0xc5, 0x97, 0x60, 0xb1, 0x19, 0xae, 0xaf, 0x18, 0xb2,
|
||||
0x92, 0x61, 0xe1, 0x84, 0x2c, 0x19, 0xd7, 0x20, 0xaf, 0xf0, 0x95, 0x73, 0x1b, 0x68, 0xb3, 0x60,
|
||||
0x04, 0x23, 0xf2, 0x31, 0x82, 0xd5, 0x5d, 0xdf, 0xeb, 0x4e, 0x04, 0x4a, 0xf2, 0x6b, 0x04, 0x2b,
|
||||
0x77, 0x4d, 0x36, 0x19, 0x60, 0x1e, 0x41, 0x61, 0xc7, 0xf3, 0x1c, 0x83, 0xb2, 0xae, 0xe7, 0x32,
|
||||
0x8a, 0xdf, 0x81, 0x3c, 0xe3, 0x26, 0xef, 0xb1, 0x00, 0xc5, 0x1b, 0x5a, 0x14, 0x35, 0xc9, 0x62,
|
||||
0x04, 0xac, 0x78, 0x05, 0xa6, 0x0f, 0x4d, 0xa7, 0xa7, 0x40, 0xcc, 0x1a, 0x6a, 0x40, 0x3e, 0x84,
|
||||
0x85, 0x1a, 0xf7, 0x6d, 0xb7, 0xf5, 0x39, 0x2e, 0x3e, 0xd7, 0x5f, 0xfc, 0xb7, 0x08, 0xce, 0xed,
|
||||
0x52, 0xd6, 0xf4, 0xed, 0xc6, 0x64, 0x38, 0x1f, 0xf9, 0x3b, 0x82, 0x8a, 0x0e, 0xd1, 0x38, 0xb2,
|
||||
0x7f, 0x2f, 0x74, 0xe8, 0x8c, 0x9c, 0xf4, 0x56, 0x7c, 0x52, 0x10, 0x8c, 0x27, 0xbb, 0xd5, 0x24,
|
||||
0xa1, 0xef, 0xf7, 0x98, 0x40, 0xe1, 0x04, 0x64, 0x75, 0x57, 0x02, 0xcf, 0x1a, 0x31, 0x9a, 0x8c,
|
||||
0x8d, 0xfb, 0x9e, 0x69, 0x4d, 0x86, 0x12, 0x7f, 0x83, 0xa0, 0x6c, 0x50, 0x87, 0x9a, 0x6c, 0x42,
|
||||
0xac, 0xfa, 0x09, 0x82, 0xb5, 0x88, 0x7e, 0xb9, 0xc9, 0xd9, 0x59, 0xc2, 0xf9, 0x95, 0x38, 0x71,
|
||||
0x93, 0x70, 0xc6, 0xf1, 0xb0, 0x6f, 0xc1, 0xb4, 0xf8, 0xc5, 0xca, 0x99, 0x8d, 0xec, 0xe6, 0xfc,
|
||||
0xf6, 0x45, 0xed, 0x9c, 0x7b, 0xf4, 0xf8, 0x03, 0x11, 0x75, 0xfb, 0xa6, 0xed, 0x1b, 0x8a, 0x9f,
|
||||
0x34, 0x60, 0xb5, 0xd6, 0xf6, 0x8e, 0xbe, 0x48, 0x2b, 0x91, 0xa7, 0xb0, 0x96, 0xdc, 0x63, 0x1c,
|
||||
0x59, 0x2f, 0x43, 0x29, 0xa1, 0x65, 0x25, 0xf6, 0x9c, 0xb1, 0x18, 0x57, 0x33, 0x23, 0x7f, 0x13,
|
||||
0x66, 0x97, 0x37, 0xdb, 0xbe, 0xe9, 0x73, 0xfb, 0xac, 0x2f, 0xb6, 0xb7, 0x60, 0xa1, 0xdb, 0xc7,
|
||||
0xa1, 0xf8, 0x72, 0x92, 0xaf, 0x18, 0x52, 0xa5, 0xbe, 0xfe, 0x8a, 0x60, 0x45, 0xdc, 0x73, 0xaf,
|
||||
0x13, 0xe6, 0xbf, 0x20, 0x58, 0xbe, 0x6b, 0xb2, 0xd7, 0x09, 0xf2, 0xa7, 0x08, 0x96, 0xc5, 0x91,
|
||||
0xa9, 0x30, 0x9f, 0x2d, 0xe4, 0x4b, 0xb0, 0x18, 0x87, 0xcc, 0xca, 0x39, 0xe9, 0xd2, 0x0b, 0x31,
|
||||
0xcc, 0x8c, 0xfc, 0x03, 0xc1, 0x7a, 0x70, 0xb2, 0x4e, 0x84, 0xae, 0x47, 0x06, 0xfe, 0x29, 0x82,
|
||||
0xd5, 0x10, 0xf1, 0x59, 0x1f, 0xc0, 0xa3, 0xba, 0xc8, 0x2f, 0x11, 0xac, 0x25, 0x41, 0x9f, 0xc9,
|
||||
0x31, 0xfd, 0x67, 0x04, 0x2b, 0xe2, 0x0c, 0x9d, 0x08, 0x9b, 0x27, 0xf3, 0x91, 0x9c, 0x26, 0x1f,
|
||||
0xf9, 0x03, 0x52, 0x17, 0x4b, 0x04, 0xf0, 0x38, 0x8a, 0xd3, 0xb8, 0x59, 0x46, 0xe7, 0x66, 0x02,
|
||||
0x5b, 0x48, 0xa9, 0xee, 0xb2, 0x72, 0x76, 0x23, 0x2b, 0xb0, 0x45, 0x69, 0x32, 0x19, 0xe8, 0xa7,
|
||||
0x78, 0x35, 0xda, 0xea, 0x50, 0x97, 0xbf, 0xbc, 0x3a, 0x93, 0xca, 0xc8, 0x0c, 0x2a, 0x03, 0x9f,
|
||||
0x87, 0x39, 0xa6, 0xf6, 0x09, 0xb3, 0xb7, 0x13, 0x02, 0xf9, 0x39, 0x82, 0xf5, 0x01, 0x38, 0xe3,
|
||||
0x28, 0xab, 0x0c, 0x33, 0xb6, 0x6b, 0xd1, 0xa7, 0x21, 0x9a, 0xfe, 0x50, 0x7c, 0x69, 0xf4, 0x6c,
|
||||
0xc7, 0x0a, 0x61, 0xf4, 0x87, 0x42, 0x27, 0x58, 0xd8, 0xeb, 0x95, 0xe8, 0x63, 0x03, 0xe6, 0x23,
|
||||
0x06, 0x09, 0xa0, 0x44, 0x49, 0xe4, 0x27, 0xb0, 0x1c, 0x43, 0x33, 0x8e, 0x3a, 0xbe, 0x04, 0x10,
|
||||
0x2a, 0x5b, 0xb9, 0x4d, 0xd6, 0x88, 0x50, 0xc8, 0x7f, 0x11, 0x60, 0x95, 0x24, 0x54, 0x85, 0x9a,
|
||||
0xce, 0x32, 0xb2, 0x2e, 0x00, 0x3c, 0xb1, 0xa9, 0x63, 0x45, 0x8f, 0xa4, 0x39, 0x49, 0x91, 0x9f,
|
||||
0x77, 0xa1, 0x40, 0x9f, 0x72, 0xdf, 0xac, 0x77, 0x4d, 0xdf, 0xec, 0xb0, 0xf2, 0xf4, 0xa8, 0xa7,
|
||||
0xc8, 0xbc, 0x9c, 0xb6, 0x2f, 0x67, 0x91, 0x7f, 0x89, 0xf4, 0x22, 0xf0, 0xb7, 0x49, 0x97, 0xf8,
|
||||
0x02, 0x80, 0xf4, 0x5d, 0xf5, 0x79, 0x5a, 0x7d, 0x96, 0x14, 0x79, 0x3e, 0x3b, 0x50, 0x92, 0x12,
|
||||
0x28, 0x71, 0xba, 0x62, 0xd5, 0xc4, 0x14, 0x94, 0x98, 0x82, 0xbf, 0x03, 0xf9, 0x40, 0x7b, 0x23,
|
||||
0x9f, 0xc1, 0xc1, 0x04, 0xf2, 0x47, 0x04, 0xab, 0x09, 0xc5, 0x8d, 0xe3, 0x97, 0x07, 0x80, 0x15,
|
||||
0x50, 0xeb, 0x04, 0x7d, 0x1f, 0x55, 0xe2, 0x85, 0x18, 0x0c, 0x92, 0xb2, 0x1a, 0x4b, 0x76, 0x82,
|
||||
0xc2, 0xc8, 0x3f, 0x11, 0x2c, 0x49, 0x3e, 0xb1, 0x1b, 0x7d, 0x7d, 0x4d, 0xfb, 0x33, 0x04, 0x38,
|
||||
0x2a, 0xc7, 0x38, 0x9a, 0xfe, 0x86, 0xba, 0x76, 0x95, 0x24, 0x0b, 0xdb, 0x6f, 0x6a, 0xe7, 0x44,
|
||||
0x36, 0x53, 0xdc, 0xe4, 0x7f, 0x08, 0x8a, 0x55, 0x97, 0x51, 0x9f, 0x4f, 0x7e, 0xaa, 0x82, 0xbf,
|
||||
0x0e, 0xb3, 0xbe, 0x77, 0x54, 0xb7, 0x4c, 0x6e, 0x06, 0xe7, 0xc2, 0x39, 0x2d, 0xbc, 0x1d, 0xc7,
|
||||
0x6b, 0x18, 0x33, 0xbe, 0x77, 0xb4, 0x6b, 0x72, 0x13, 0xbf, 0x01, 0x73, 0x6d, 0x93, 0xb5, 0xeb,
|
||||
0x1f, 0xd1, 0x63, 0x56, 0xce, 0x6f, 0x64, 0x37, 0x8b, 0xc6, 0xac, 0x20, 0xdc, 0xa3, 0xc7, 0x8c,
|
||||
0x3c, 0x47, 0xb0, 0xd0, 0x97, 0x7f, 0x1c, 0xf5, 0xbf, 0x09, 0xf3, 0xbe, 0x77, 0x54, 0xdd, 0xad,
|
||||
0x37, 0x68, 0xcb, 0x76, 0x83, 0x1b, 0x01, 0x24, 0x69, 0x47, 0x50, 0x04, 0x0a, 0xc5, 0x40, 0x5d,
|
||||
0x2b, 0xb8, 0x0d, 0x66, 0x25, 0xe1, 0x8e, 0x6b, 0x91, 0x43, 0x28, 0xed, 0x3b, 0x66, 0x93, 0xb6,
|
||||
0x3d, 0xc7, 0xa2, 0xbe, 0x8c, 0x4a, 0x5c, 0x82, 0x2c, 0x37, 0x5b, 0x41, 0x70, 0x8b, 0x9f, 0xf8,
|
||||
0xdb, 0x90, 0xe3, 0xc7, 0xdd, 0xbe, 0x85, 0xbf, 0xa2, 0x0d, 0x9f, 0xc8, 0x32, 0x07, 0xc7, 0x5d,
|
||||
0x6a, 0xc8, 0x19, 0x78, 0x0d, 0xf2, 0xb2, 0x16, 0xa5, 0x72, 0x85, 0x82, 0x11, 0x8c, 0xc8, 0xe3,
|
||||
0xd8, 0xbe, 0x7b, 0xbe, 0xd7, 0xeb, 0xe2, 0x2a, 0x14, 0xba, 0x27, 0x34, 0xa1, 0x84, 0xf4, 0x60,
|
||||
0x4d, 0x82, 0x36, 0x62, 0x53, 0xc9, 0x67, 0x08, 0x8a, 0x35, 0x6a, 0xfa, 0xcd, 0xf6, 0xeb, 0x90,
|
||||
0xbe, 0x0b, 0x8d, 0x5b, 0xcc, 0x09, 0xc2, 0x54, 0xfc, 0xc4, 0x57, 0x61, 0x29, 0x22, 0x50, 0xbd,
|
||||
0x25, 0x14, 0x54, 0xce, 0xcb, 0x82, 0x6d, 0xa9, 0x9b, 0x50, 0x1c, 0xb9, 0x07, 0xb9, 0xbb, 0x36,
|
||||
0x97, 0xcb, 0x88, 0x4b, 0x18, 0xc9, 0x4b, 0x58, 0xfc, 0xc4, 0xe7, 0x22, 0x7e, 0x9b, 0x91, 0x06,
|
||||
0x08, 0x9d, 0x53, 0xd6, 0x81, 0x3d, 0x3f, 0xb0, 0x4c, 0xc6, 0x08, 0x46, 0xe4, 0x87, 0x27, 0x9a,
|
||||
0x63, 0x3d, 0x87, 0xb3, 0x97, 0xf3, 0x4a, 0x0c, 0xb9, 0xb6, 0x1d, 0xa4, 0xe2, 0x05, 0x43, 0xfe,
|
||||
0x26, 0xbf, 0x40, 0x50, 0x78, 0xd7, 0xe9, 0xb1, 0x2f, 0xc2, 0x26, 0xba, 0xb2, 0x45, 0x56, 0x5f,
|
||||
0xb6, 0xf8, 0x77, 0x06, 0x56, 0xf7, 0xa9, 0xcf, 0x6c, 0xc6, 0xa9, 0xcb, 0x83, 0x24, 0xa8, 0xea,
|
||||
0x3e, 0xf1, 0xe2, 0x99, 0x24, 0x4a, 0x64, 0x92, 0x9f, 0x4f, 0xee, 0x25, 0xa2, 0xd1, 0xeb, 0x52,
|
||||
0xb7, 0xce, 0xed, 0xe0, 0xac, 0xc9, 0x19, 0xb3, 0x82, 0x70, 0x60, 0x77, 0xa8, 0x88, 0x65, 0x46,
|
||||
0x4d, 0x87, 0x5a, 0xea, 0xf3, 0xb4, 0xfc, 0x0c, 0x8a, 0x24, 0x19, 0x2e, 0x42, 0xe1, 0x89, 0xd0,
|
||||
0x60, 0x9f, 0x23, 0x2f, 0x39, 0xe6, 0x03, 0x9a, 0x64, 0x39, 0x07, 0xb3, 0x6e, 0xaf, 0x53, 0xf7,
|
||||
0xbd, 0x23, 0x56, 0x9e, 0x51, 0x69, 0xa8, 0xdb, 0xeb, 0x18, 0xde, 0x91, 0xf4, 0x86, 0x0e, 0xed,
|
||||
0xd4, 0x99, 0xfd, 0x8c, 0x96, 0x67, 0xd5, 0xa7, 0x0e, 0xed, 0xd4, 0xec, 0x67, 0xb4, 0xff, 0x76,
|
||||
0xa2, 0xe5, 0x39, 0x19, 0xe2, 0xfa, 0x7b, 0x3b, 0xd0, 0x55, 0xec, 0x18, 0xff, 0x1d, 0x82, 0xf3,
|
||||
0x5a, 0x6d, 0xbe, 0xbc, 0x91, 0xd7, 0x20, 0xb0, 0x6a, 0xc2, 0xc6, 0x6f, 0x43, 0x22, 0xc0, 0x52,
|
||||
0xea, 0x7f, 0xbf, 0x47, 0x70, 0x21, 0x05, 0xd2, 0x38, 0x07, 0xed, 0x4d, 0x98, 0xb6, 0xdd, 0x27,
|
||||
0x5e, 0x3f, 0x89, 0xb8, 0xa2, 0x3f, 0x97, 0xb4, 0xfb, 0xaa, 0x89, 0xe4, 0x3f, 0x08, 0x4a, 0xef,
|
||||
0xf7, 0xa8, 0x7f, 0xfc, 0xaa, 0x9d, 0x2e, 0x6a, 0xf8, 0x5c, 0xdc, 0xf0, 0x51, 0x77, 0x99, 0x8e,
|
||||
0xbb, 0x4b, 0x3c, 0x87, 0xc8, 0x27, 0x73, 0xbd, 0xc8, 0x43, 0x68, 0x26, 0xf6, 0x10, 0x22, 0x1f,
|
||||
0x23, 0x58, 0x4f, 0xca, 0x79, 0x76, 0xee, 0xf0, 0x09, 0x82, 0xf2, 0x20, 0x9a, 0x71, 0x3c, 0xe1,
|
||||
0xbb, 0x71, 0x4f, 0xd0, 0xdf, 0x50, 0x03, 0x5b, 0x06, 0x4e, 0xf0, 0x1c, 0xc1, 0x8a, 0x41, 0x5b,
|
||||
0xc2, 0x49, 0xfc, 0xfb, 0xb6, 0xfb, 0x51, 0x08, 0xe5, 0x9b, 0x30, 0x63, 0x5a, 0x96, 0x4f, 0x19,
|
||||
0x3b, 0x55, 0x39, 0xb7, 0x14, 0x8f, 0xd1, 0x67, 0x8e, 0x88, 0x90, 0x19, 0x59, 0x84, 0x2b, 0x37,
|
||||
0x61, 0x31, 0x71, 0x61, 0xe3, 0x59, 0xc8, 0x3d, 0x78, 0xf8, 0xe0, 0x4e, 0x69, 0x0a, 0x2f, 0x41,
|
||||
0xf1, 0x83, 0x3b, 0xb7, 0x0f, 0x1e, 0x1a, 0xf5, 0x9d, 0xea, 0x83, 0x5b, 0xc6, 0xa3, 0x92, 0x85,
|
||||
0x4b, 0x50, 0x08, 0x48, 0xef, 0xde, 0x7f, 0x78, 0xeb, 0xa0, 0x44, 0xb7, 0x3f, 0xc3, 0x50, 0x7c,
|
||||
0x4f, 0x6e, 0x54, 0xa3, 0xfe, 0xa1, 0xdd, 0xa4, 0xb8, 0x0e, 0xa5, 0x64, 0xa3, 0x13, 0x5f, 0xd3,
|
||||
0xea, 0x26, 0xa5, 0x1f, 0x5a, 0x39, 0x0d, 0x3a, 0x99, 0xc2, 0x1f, 0xc2, 0x42, 0xbc, 0x43, 0x89,
|
||||
0xf5, 0x41, 0xa8, 0x6d, 0x63, 0x0e, 0x5b, 0xbc, 0x0e, 0xc5, 0x58, 0xc3, 0x11, 0x5f, 0xd6, 0xae,
|
||||
0xad, 0x6b, 0x4a, 0x56, 0x2e, 0x6a, 0x59, 0xa3, 0x3d, 0x43, 0x85, 0x3e, 0xde, 0x43, 0x4a, 0x41,
|
||||
0xaf, 0x6d, 0x34, 0x0d, 0x43, 0x6f, 0xc2, 0xd2, 0x40, 0x4b, 0x08, 0x5f, 0xd7, 0xae, 0x9f, 0xd6,
|
||||
0x3a, 0x1a, 0xb6, 0xc5, 0x11, 0xe0, 0xc1, 0xd6, 0x1d, 0xbe, 0xa1, 0xb7, 0x40, 0x5a, 0xd7, 0xb1,
|
||||
0xb2, 0x35, 0x32, 0x7f, 0xa8, 0xb8, 0x43, 0x58, 0xdf, 0xa3, 0x3c, 0xde, 0xd1, 0xb1, 0x19, 0xb7,
|
||||
0x9b, 0x0c, 0x5f, 0xd5, 0xbb, 0x97, 0xb6, 0x17, 0x55, 0xb9, 0x36, 0x1a, 0x73, 0xb8, 0xaf, 0x03,
|
||||
0x8b, 0xf1, 0xce, 0x0a, 0x4b, 0xb1, 0x98, 0xb6, 0xc7, 0x53, 0xb9, 0x3a, 0x12, 0x6f, 0xb8, 0xdb,
|
||||
0x63, 0x58, 0x4c, 0x34, 0x53, 0xd2, 0xa4, 0xd3, 0xb6, 0x5c, 0x86, 0x59, 0xef, 0x11, 0x14, 0x63,
|
||||
0x5d, 0x8f, 0x14, 0xf7, 0xd6, 0x75, 0x46, 0x86, 0x2d, 0xfd, 0x18, 0x0a, 0xd1, 0xe6, 0x04, 0xde,
|
||||
0x4c, 0x0b, 0x9c, 0x81, 0x85, 0x47, 0x8a, 0x9b, 0x47, 0x2a, 0x6e, 0xc2, 0xc9, 0x2c, 0x65, 0x03,
|
||||
0x4d, 0xb7, 0x61, 0x18, 0xf2, 0x1f, 0x87, 0x51, 0x13, 0x59, 0xfd, 0xda, 0x69, 0x51, 0xf3, 0xa2,
|
||||
0xba, 0x61, 0xb0, 0xb6, 0x47, 0x79, 0xac, 0xca, 0x1d, 0xb8, 0x6e, 0x4a, 0xfe, 0xa0, 0x2b, 0xe2,
|
||||
0xa7, 0xb8, 0x92, 0xbe, 0x76, 0x4e, 0xa6, 0xb0, 0x0d, 0x0b, 0xb1, 0xea, 0x30, 0x4b, 0x31, 0xb6,
|
||||
0xae, 0xe6, 0x5d, 0xb9, 0x32, 0x0a, 0x6b, 0xb8, 0xd5, 0xf7, 0x61, 0x3e, 0x52, 0xdd, 0xc3, 0x97,
|
||||
0x4e, 0xf1, 0xd8, 0x68, 0x35, 0x6c, 0x98, 0xda, 0xda, 0x50, 0x8c, 0xd5, 0x82, 0xd2, 0xbc, 0x55,
|
||||
0x53, 0x68, 0x4b, 0x11, 0x40, 0x5b, 0x5a, 0x22, 0x53, 0xb8, 0x01, 0xc5, 0x3d, 0xca, 0x4f, 0xca,
|
||||
0x13, 0xf8, 0xed, 0xf4, 0xe2, 0x50, 0xb4, 0xe8, 0x53, 0xb9, 0x34, 0x94, 0x2f, 0xdc, 0xa3, 0x06,
|
||||
0x79, 0xf5, 0xd2, 0xc7, 0x24, 0x65, 0x52, 0xa4, 0x0c, 0x52, 0xf9, 0xf2, 0xa9, 0x3c, 0xe1, 0xa2,
|
||||
0x06, 0xe4, 0xd5, 0x3b, 0x2d, 0x65, 0xd1, 0xd8, 0xf3, 0xb7, 0x72, 0x3a, 0x8f, 0x7c, 0xe8, 0x91,
|
||||
0x29, 0x5c, 0x85, 0x69, 0xf9, 0x40, 0xc3, 0xfa, 0xc0, 0x8c, 0x3e, 0xde, 0x86, 0x59, 0xf0, 0x7d,
|
||||
0x28, 0xec, 0x51, 0xbe, 0x6b, 0xdd, 0x6e, 0x9b, 0xae, 0x4b, 0x1d, 0x5c, 0xd1, 0xb2, 0xdf, 0xe9,
|
||||
0x74, 0xf9, 0x71, 0x8a, 0xc4, 0xf1, 0xff, 0xc5, 0x90, 0x29, 0xfc, 0x1c, 0x41, 0x59, 0x04, 0x93,
|
||||
0xf6, 0xed, 0xf6, 0xb5, 0x17, 0x48, 0xc7, 0x03, 0x09, 0xb6, 0x5f, 0x64, 0x4a, 0x88, 0x82, 0xc3,
|
||||
0xf2, 0x1e, 0xe5, 0x03, 0x69, 0xfc, 0xb5, 0xd1, 0x92, 0xc0, 0x60, 0xeb, 0xeb, 0x23, 0x72, 0xf7,
|
||||
0x77, 0xdd, 0x6e, 0x41, 0x61, 0xdf, 0xf7, 0x9e, 0x1e, 0xf7, 0x73, 0xad, 0x1f, 0x40, 0x21, 0x9a,
|
||||
0x44, 0x9e, 0xaa, 0xde, 0xcb, 0x29, 0x07, 0xda, 0x60, 0x0e, 0x4a, 0xa6, 0x76, 0x76, 0x7e, 0x74,
|
||||
0xb3, 0x65, 0xf3, 0x76, 0xaf, 0x21, 0xd6, 0xd8, 0x7a, 0x66, 0x3b, 0x8e, 0xfd, 0x8c, 0xd3, 0x66,
|
||||
0x7b, 0x4b, 0x4d, 0xbb, 0x6e, 0xd9, 0x8c, 0xfb, 0x76, 0xa3, 0xc7, 0xa9, 0xb5, 0x65, 0xbb, 0x9c,
|
||||
0xfa, 0xae, 0xe9, 0x6c, 0xc9, 0x85, 0x03, 0x8e, 0x6e, 0xa3, 0x91, 0x97, 0xe3, 0x77, 0xfe, 0x1f,
|
||||
0x00, 0x00, 0xff, 0xff, 0x0d, 0xe8, 0xd6, 0x03, 0x3a, 0x27, 0x00, 0x00,
|
||||
}
|
||||
|
||||
// Reference imports to suppress errors if they are not otherwise used.
|
||||
|
|
@ -2772,6 +2969,7 @@ type MilvusServiceClient interface {
|
|||
Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
|
||||
GetDdChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*StringResponse, error)
|
||||
GetPersistentSegmentInfo(ctx context.Context, in *PersistentSegmentInfoRequest, opts ...grpc.CallOption) (*PersistentSegmentInfoResponse, error)
|
||||
GetQuerySegmentInfo(ctx context.Context, in *QuerySegmentInfoRequest, opts ...grpc.CallOption) (*QuerySegmentInfoResponse, error)
|
||||
}
|
||||
|
||||
type milvusServiceClient struct {
|
||||
|
|
@ -2989,6 +3187,15 @@ func (c *milvusServiceClient) GetPersistentSegmentInfo(ctx context.Context, in *
|
|||
return out, nil
|
||||
}
|
||||
|
||||
func (c *milvusServiceClient) GetQuerySegmentInfo(ctx context.Context, in *QuerySegmentInfoRequest, opts ...grpc.CallOption) (*QuerySegmentInfoResponse, error) {
|
||||
out := new(QuerySegmentInfoResponse)
|
||||
err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/GetQuerySegmentInfo", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// MilvusServiceServer is the server API for MilvusService service.
|
||||
type MilvusServiceServer interface {
|
||||
CreateCollection(context.Context, *CreateCollectionRequest) (*commonpb.Status, error)
|
||||
|
|
@ -3014,6 +3221,7 @@ type MilvusServiceServer interface {
|
|||
Flush(context.Context, *FlushRequest) (*commonpb.Status, error)
|
||||
GetDdChannel(context.Context, *commonpb.Empty) (*StringResponse, error)
|
||||
GetPersistentSegmentInfo(context.Context, *PersistentSegmentInfoRequest) (*PersistentSegmentInfoResponse, error)
|
||||
GetQuerySegmentInfo(context.Context, *QuerySegmentInfoRequest) (*QuerySegmentInfoResponse, error)
|
||||
}
|
||||
|
||||
// UnimplementedMilvusServiceServer can be embedded to have forward compatible implementations.
|
||||
|
|
@ -3089,6 +3297,9 @@ func (*UnimplementedMilvusServiceServer) GetDdChannel(ctx context.Context, req *
|
|||
func (*UnimplementedMilvusServiceServer) GetPersistentSegmentInfo(ctx context.Context, req *PersistentSegmentInfoRequest) (*PersistentSegmentInfoResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GetPersistentSegmentInfo not implemented")
|
||||
}
|
||||
func (*UnimplementedMilvusServiceServer) GetQuerySegmentInfo(ctx context.Context, req *QuerySegmentInfoRequest) (*QuerySegmentInfoResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method GetQuerySegmentInfo not implemented")
|
||||
}
|
||||
|
||||
func RegisterMilvusServiceServer(s *grpc.Server, srv MilvusServiceServer) {
|
||||
s.RegisterService(&_MilvusService_serviceDesc, srv)
|
||||
|
|
@ -3508,6 +3719,24 @@ func _MilvusService_GetPersistentSegmentInfo_Handler(srv interface{}, ctx contex
|
|||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _MilvusService_GetQuerySegmentInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(QuerySegmentInfoRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(MilvusServiceServer).GetQuerySegmentInfo(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/milvus.proto.milvus.MilvusService/GetQuerySegmentInfo",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(MilvusServiceServer).GetQuerySegmentInfo(ctx, req.(*QuerySegmentInfoRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
var _MilvusService_serviceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "milvus.proto.milvus.MilvusService",
|
||||
HandlerType: (*MilvusServiceServer)(nil),
|
||||
|
|
@ -3604,6 +3833,10 @@ var _MilvusService_serviceDesc = grpc.ServiceDesc{
|
|||
MethodName: "GetPersistentSegmentInfo",
|
||||
Handler: _MilvusService_GetPersistentSegmentInfo_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GetQuerySegmentInfo",
|
||||
Handler: _MilvusService_GetQuerySegmentInfo_Handler,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{},
|
||||
Metadata: "milvus.proto",
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@ import (
|
|||
"strconv"
|
||||
"time"
|
||||
|
||||
"github.com/zilliztech/milvus-distributed/internal/proto/querypb"
|
||||
|
||||
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
|
||||
|
||||
"github.com/zilliztech/milvus-distributed/internal/msgstream"
|
||||
|
|
@ -442,8 +444,10 @@ func (node *NodeImpl) GetIndexState(request *milvuspb.IndexStateRequest) (*milvu
|
|||
ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
|
||||
defer cancel()
|
||||
dipt := &GetIndexStateTask{
|
||||
Condition: NewTaskCondition(ctx),
|
||||
IndexStateRequest: request,
|
||||
Condition: NewTaskCondition(ctx),
|
||||
IndexStateRequest: request,
|
||||
indexServiceClient: node.indexServiceClient,
|
||||
masterClientInterface: node.masterClient,
|
||||
}
|
||||
|
||||
err := node.sched.DdQueue.Enqueue(dipt)
|
||||
|
|
@ -641,6 +645,51 @@ func (node *NodeImpl) GetPersistentSegmentInfo(req *milvuspb.PersistentSegmentIn
|
|||
return resp, nil
|
||||
}
|
||||
|
||||
func (node *NodeImpl) GetQuerySegmentInfo(req *milvuspb.QuerySegmentInfoRequest) (*milvuspb.QuerySegmentInfoResponse, error) {
|
||||
resp := &milvuspb.QuerySegmentInfoResponse{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
|
||||
},
|
||||
}
|
||||
segments, err := node.getSegmentsOfCollection(req.DbName, req.CollectionName)
|
||||
if err != nil {
|
||||
resp.Status.Reason = err.Error()
|
||||
return resp, nil
|
||||
}
|
||||
infoResp, err := node.queryServiceClient.GetSegmentInfo(&querypb.SegmentInfoRequest{
|
||||
Base: &commonpb.MsgBase{
|
||||
MsgType: commonpb.MsgType_kSegmentInfo,
|
||||
MsgID: 0,
|
||||
Timestamp: 0,
|
||||
SourceID: Params.ProxyID,
|
||||
},
|
||||
SegmentIDs: segments,
|
||||
})
|
||||
if err != nil {
|
||||
resp.Status.Reason = err.Error()
|
||||
return resp, nil
|
||||
}
|
||||
if infoResp.Status.ErrorCode != commonpb.ErrorCode_SUCCESS {
|
||||
resp.Status.Reason = infoResp.Status.Reason
|
||||
return resp, nil
|
||||
}
|
||||
queryInfos := make([]*milvuspb.QuerySegmentInfo, len(infoResp.Infos))
|
||||
for i, info := range infoResp.Infos {
|
||||
queryInfos[i] = &milvuspb.QuerySegmentInfo{
|
||||
SegmentID: info.SegmentID,
|
||||
CollectionID: info.CollectionID,
|
||||
PartitionID: info.PartitionID,
|
||||
NumRows: info.NumRows,
|
||||
MemSize: info.MemSize,
|
||||
IndexName: info.IndexName,
|
||||
IndexID: info.IndexID,
|
||||
}
|
||||
}
|
||||
resp.Status.ErrorCode = commonpb.ErrorCode_SUCCESS
|
||||
resp.Infos = queryInfos
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (node *NodeImpl) getSegmentsOfCollection(dbName string, collectionName string) ([]UniqueID, error) {
|
||||
describeCollectionResponse, err := node.masterClient.DescribeCollection(&milvuspb.DescribeCollectionRequest{
|
||||
Base: &commonpb.MsgBase{
|
||||
|
|
|
|||
|
|
@ -83,7 +83,6 @@ type InsertChannelsMap struct {
|
|||
func (m *InsertChannelsMap) createInsertMsgStream(collID UniqueID, channels []string) error {
|
||||
m.mtx.Lock()
|
||||
defer m.mtx.Unlock()
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
|
||||
_, ok := m.collectionID2InsertChannels[collID]
|
||||
if ok {
|
||||
|
|
@ -101,9 +100,10 @@ func (m *InsertChannelsMap) createInsertMsgStream(collID UniqueID, channels []st
|
|||
}
|
||||
m.insertChannels = append(m.insertChannels, channels)
|
||||
m.collectionID2InsertChannels[collID] = len(m.insertChannels) - 1
|
||||
stream := pulsarms.NewPulsarMsgStream(context.Background(), Params.MsgStreamInsertBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
stream.SetPulsarClient(Params.PulsarAddress)
|
||||
stream.CreatePulsarProducers(channels)
|
||||
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, Params.MsgStreamInsertBufSize, 1024)
|
||||
stream, _ := factory.NewMsgStream(context.Background())
|
||||
stream.AsProducer(channels)
|
||||
repack := func(tsMsgs []msgstream.TsMsg, hashKeys [][]int32) (map[int32]*msgstream.MsgPack, error) {
|
||||
return insertRepackFunc(tsMsgs, hashKeys, m.nodeInstance.segAssigner, true)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ type MasterClient interface {
|
|||
CreateIndex(in *milvuspb.CreateIndexRequest) (*commonpb.Status, error)
|
||||
DescribeIndex(in *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error)
|
||||
ShowSegments(in *milvuspb.ShowSegmentRequest) (*milvuspb.ShowSegmentResponse, error)
|
||||
DescribeSegment(in *milvuspb.DescribeSegmentRequest) (*milvuspb.DescribeSegmentResponse, error)
|
||||
}
|
||||
|
||||
type IndexServiceClient interface {
|
||||
|
|
@ -43,6 +44,7 @@ type QueryServiceClient interface {
|
|||
//GetSearchChannelNames() ([]string, error)
|
||||
//GetSearchResultChannels() ([]string, error)
|
||||
GetComponentStates() (*internalpb2.ComponentStates, error)
|
||||
GetSegmentInfo(req *querypb.SegmentInfoRequest) (*querypb.SegmentInfoResponse, error)
|
||||
}
|
||||
|
||||
type DataServiceClient interface {
|
||||
|
|
@ -94,4 +96,7 @@ type ProxyNode interface {
|
|||
Flush(request *milvuspb.FlushRequest) (*commonpb.Status, error)
|
||||
|
||||
GetDdChannel(request *commonpb.Empty) (*milvuspb.StringResponse, error)
|
||||
|
||||
GetQuerySegmentInfo(req *milvuspb.QuerySegmentInfoRequest) (*milvuspb.QuerySegmentInfoResponse, error)
|
||||
GetPersistentSegmentInfo(req *milvuspb.PersistentSegmentInfoRequest) (*milvuspb.PersistentSegmentInfoResponse, error)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -54,8 +54,8 @@ type NodeImpl struct {
|
|||
tsoAllocator *allocator.TimestampAllocator
|
||||
segAssigner *SegIDAssigner
|
||||
|
||||
manipulationMsgStream *pulsarms.PulsarMsgStream
|
||||
queryMsgStream *pulsarms.PulsarMsgStream
|
||||
manipulationMsgStream msgstream.MsgStream
|
||||
queryMsgStream msgstream.MsgStream
|
||||
|
||||
tracer opentracing.Tracer
|
||||
closer io.Closer
|
||||
|
|
@ -106,7 +106,7 @@ func (node *NodeImpl) waitForServiceReady(service Component, serviceName string)
|
|||
}
|
||||
|
||||
func (node *NodeImpl) Init() error {
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, Params.MsgStreamSearchBufSize, 1024)
|
||||
|
||||
// todo wait for proxyservice state changed to Healthy
|
||||
|
||||
|
|
@ -195,11 +195,8 @@ func (node *NodeImpl) Init() error {
|
|||
}
|
||||
opentracing.SetGlobalTracer(node.tracer)
|
||||
|
||||
pulsarAddress := Params.PulsarAddress
|
||||
|
||||
node.queryMsgStream = pulsarms.NewPulsarMsgStream(node.ctx, Params.MsgStreamSearchBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
node.queryMsgStream.SetPulsarClient(pulsarAddress)
|
||||
node.queryMsgStream.CreatePulsarProducers(Params.SearchChannelNames)
|
||||
node.queryMsgStream, _ = factory.NewMsgStream(node.ctx)
|
||||
node.queryMsgStream.AsProducer(Params.SearchChannelNames)
|
||||
log.Println("create query message stream ...")
|
||||
|
||||
masterAddr := Params.MasterAddress
|
||||
|
|
@ -225,9 +222,8 @@ func (node *NodeImpl) Init() error {
|
|||
node.segAssigner = segAssigner
|
||||
node.segAssigner.PeerID = Params.ProxyID
|
||||
|
||||
node.manipulationMsgStream = pulsarms.NewPulsarMsgStream(node.ctx, Params.MsgStreamInsertBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
node.manipulationMsgStream.SetPulsarClient(pulsarAddress)
|
||||
node.manipulationMsgStream.CreatePulsarProducers(Params.InsertChannelNames)
|
||||
node.manipulationMsgStream, _ = factory.NewMsgStream(node.ctx)
|
||||
node.manipulationMsgStream.AsProducer(Params.InsertChannelNames)
|
||||
repackFuncImpl := func(tsMsgs []msgstream.TsMsg, hashKeys [][]int32) (map[int32]*msgstream.MsgPack, error) {
|
||||
return insertRepackFunc(tsMsgs, hashKeys, node.segAssigner, true)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,12 +6,13 @@ import (
|
|||
"math"
|
||||
"strconv"
|
||||
|
||||
"github.com/zilliztech/milvus-distributed/internal/proto/indexpb"
|
||||
|
||||
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
|
||||
|
||||
"github.com/golang/protobuf/proto"
|
||||
"github.com/zilliztech/milvus-distributed/internal/allocator"
|
||||
"github.com/zilliztech/milvus-distributed/internal/msgstream"
|
||||
"github.com/zilliztech/milvus-distributed/internal/msgstream/pulsarms"
|
||||
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
|
||||
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
|
||||
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
|
||||
|
|
@ -410,7 +411,7 @@ func (dct *DropCollectionTask) PostExecute() error {
|
|||
type SearchTask struct {
|
||||
Condition
|
||||
internalpb2.SearchRequest
|
||||
queryMsgStream *pulsarms.PulsarMsgStream
|
||||
queryMsgStream msgstream.MsgStream
|
||||
resultBuf chan []*internalpb2.SearchResults
|
||||
result *milvuspb.SearchResults
|
||||
query *milvuspb.SearchRequest
|
||||
|
|
@ -1285,8 +1286,9 @@ func (dit *DescribeIndexTask) PostExecute() error {
|
|||
type GetIndexStateTask struct {
|
||||
Condition
|
||||
*milvuspb.IndexStateRequest
|
||||
indexServiceClient IndexServiceClient
|
||||
result *milvuspb.IndexStateResponse
|
||||
indexServiceClient IndexServiceClient
|
||||
masterClientInterface MasterClient
|
||||
result *milvuspb.IndexStateResponse
|
||||
}
|
||||
|
||||
func (dipt *GetIndexStateTask) OnEnqueue() error {
|
||||
|
|
@ -1336,17 +1338,98 @@ func (dipt *GetIndexStateTask) PreExecute() error {
|
|||
}
|
||||
|
||||
func (dipt *GetIndexStateTask) Execute() error {
|
||||
// TODO: use index service client
|
||||
//var err error
|
||||
//dipt.result, err = dipt.masterClient.GetIndexState(dipt.IndexStateRequest)
|
||||
//return err
|
||||
collectionName := dipt.CollectionName
|
||||
collectionID, err := globalMetaCache.GetCollectionID(collectionName)
|
||||
if err != nil { // err is not nil if collection not exists
|
||||
return err
|
||||
}
|
||||
|
||||
showPartitionRequest := &milvuspb.ShowPartitionRequest{
|
||||
Base: &commonpb.MsgBase{
|
||||
MsgType: commonpb.MsgType_kShowPartitions,
|
||||
MsgID: dipt.Base.MsgID,
|
||||
Timestamp: dipt.Base.Timestamp,
|
||||
SourceID: Params.ProxyID,
|
||||
},
|
||||
DbName: dipt.DbName,
|
||||
CollectionName: collectionName,
|
||||
CollectionID: collectionID,
|
||||
}
|
||||
partitions, err := dipt.masterClientInterface.ShowPartitions(showPartitionRequest)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, partitionID := range partitions.PartitionIDs {
|
||||
showSegmentsRequest := &milvuspb.ShowSegmentRequest{
|
||||
Base: &commonpb.MsgBase{
|
||||
MsgType: commonpb.MsgType_kShowSegment,
|
||||
MsgID: dipt.Base.MsgID,
|
||||
Timestamp: dipt.Base.Timestamp,
|
||||
SourceID: Params.ProxyID,
|
||||
},
|
||||
CollectionID: collectionID,
|
||||
PartitionID: partitionID,
|
||||
}
|
||||
segments, err := dipt.masterClientInterface.ShowSegments(showSegmentsRequest)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
getIndexStatesRequest := &indexpb.IndexStatesRequest{
|
||||
IndexBuildIDs: make([]UniqueID, 0),
|
||||
}
|
||||
for _, segmentID := range segments.SegmentIDs {
|
||||
describeSegmentRequest := &milvuspb.DescribeSegmentRequest{
|
||||
Base: &commonpb.MsgBase{
|
||||
MsgType: commonpb.MsgType_kDescribeSegment,
|
||||
MsgID: dipt.Base.MsgID,
|
||||
Timestamp: dipt.Base.Timestamp,
|
||||
SourceID: Params.ProxyID,
|
||||
},
|
||||
CollectionID: collectionID,
|
||||
SegmentID: segmentID,
|
||||
}
|
||||
segmentDesc, err := dipt.masterClientInterface.DescribeSegment(describeSegmentRequest)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
getIndexStatesRequest.IndexBuildIDs = append(getIndexStatesRequest.IndexBuildIDs, segmentDesc.BuildID)
|
||||
}
|
||||
|
||||
states, err := dipt.indexServiceClient.GetIndexStates(getIndexStatesRequest)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if states.Status.ErrorCode != commonpb.ErrorCode_SUCCESS {
|
||||
dipt.result = &milvuspb.IndexStateResponse{
|
||||
Status: states.Status,
|
||||
State: commonpb.IndexState_FAILED,
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
for _, state := range states.States {
|
||||
if state.State != commonpb.IndexState_FINISHED {
|
||||
dipt.result = &milvuspb.IndexStateResponse{
|
||||
Status: states.Status,
|
||||
State: state.State,
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dipt.result = &milvuspb.IndexStateResponse{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: 0,
|
||||
ErrorCode: commonpb.ErrorCode_SUCCESS,
|
||||
Reason: "",
|
||||
},
|
||||
State: commonpb.IndexState_FINISHED,
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -371,11 +371,10 @@ func (sched *TaskScheduler) queryLoop() {
|
|||
|
||||
func (sched *TaskScheduler) queryResultLoop() {
|
||||
defer sched.wg.Done()
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, Params.MsgStreamSearchResultBufSize, 1024)
|
||||
|
||||
queryResultMsgStream := pulsarms.NewPulsarMsgStream(sched.ctx, Params.MsgStreamSearchResultBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
queryResultMsgStream.SetPulsarClient(Params.PulsarAddress)
|
||||
queryResultMsgStream.CreatePulsarConsumers(Params.SearchResultChannelNames,
|
||||
queryResultMsgStream, _ := factory.NewMsgStream(sched.ctx)
|
||||
queryResultMsgStream.AsConsumer(Params.SearchResultChannelNames,
|
||||
Params.ProxySubName)
|
||||
queryNodeNum := Params.QueryNodeNum
|
||||
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ type timeTick struct {
|
|||
pulsarProducer pulsar.Producer
|
||||
|
||||
tsoAllocator *allocator.TimestampAllocator
|
||||
tickMsgStream *pulsarms.PulsarMsgStream
|
||||
tickMsgStream msgstream.MsgStream
|
||||
|
||||
peerID UniqueID
|
||||
wg sync.WaitGroup
|
||||
|
|
@ -51,12 +51,9 @@ func newTimeTick(ctx context.Context,
|
|||
checkFunc: checkFunc,
|
||||
}
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
t.tickMsgStream = pulsarms.NewPulsarMsgStream(t.ctx, Params.MsgStreamTimeTickBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
pulsarAddress := Params.PulsarAddress
|
||||
|
||||
t.tickMsgStream.SetPulsarClient(pulsarAddress)
|
||||
t.tickMsgStream.CreatePulsarProducers(Params.ProxyTimeTickChannelNames)
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, Params.MsgStreamTimeTickBufSize, 1024)
|
||||
t.tickMsgStream, _ = factory.NewMsgStream(t.ctx)
|
||||
t.tickMsgStream.AsProducer(Params.ProxyTimeTickChannelNames)
|
||||
return t
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@ import (
|
|||
"strconv"
|
||||
"time"
|
||||
|
||||
"github.com/zilliztech/milvus-distributed/internal/msgstream"
|
||||
"github.com/zilliztech/milvus-distributed/internal/msgstream/pulsarms"
|
||||
|
||||
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
|
||||
|
|
@ -96,7 +95,7 @@ func (s *ServiceImpl) fillNodeInitParams() error {
|
|||
}
|
||||
|
||||
func (s *ServiceImpl) Init() error {
|
||||
dispatcherFactory := msgstream.ProtoUDFactory{}
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, 1024, 1024)
|
||||
|
||||
err := s.fillNodeInitParams()
|
||||
if err != nil {
|
||||
|
|
@ -104,9 +103,8 @@ func (s *ServiceImpl) Init() error {
|
|||
}
|
||||
log.Println("fill node init params ...")
|
||||
|
||||
serviceTimeTickMsgStream := pulsarms.NewPulsarTtMsgStream(s.ctx, 1024, 1024, dispatcherFactory.NewUnmarshalDispatcher())
|
||||
serviceTimeTickMsgStream.SetPulsarClient(Params.PulsarAddress)
|
||||
serviceTimeTickMsgStream.CreatePulsarProducers([]string{Params.ServiceTimeTickChannel})
|
||||
serviceTimeTickMsgStream, _ := factory.NewTtMsgStream(s.ctx)
|
||||
serviceTimeTickMsgStream.AsProducer([]string{Params.ServiceTimeTickChannel})
|
||||
log.Println("create service time tick producer channel: ", []string{Params.ServiceTimeTickChannel})
|
||||
|
||||
channels := make([]string, Params.InsertChannelNum)
|
||||
|
|
@ -114,14 +112,12 @@ func (s *ServiceImpl) Init() error {
|
|||
for ; i < Params.InsertChannelNum; i++ {
|
||||
channels[i] = Params.InsertChannelPrefixName + strconv.FormatInt(i, 10)
|
||||
}
|
||||
insertTickMsgStream := pulsarms.NewPulsarMsgStream(s.ctx, 1024, 1024, dispatcherFactory.NewUnmarshalDispatcher())
|
||||
insertTickMsgStream.SetPulsarClient(Params.PulsarAddress)
|
||||
insertTickMsgStream.CreatePulsarProducers(channels)
|
||||
insertTickMsgStream, _ := factory.NewMsgStream(s.ctx)
|
||||
insertTickMsgStream.AsProducer(channels)
|
||||
log.Println("create service time tick producer channel: ", channels)
|
||||
|
||||
nodeTimeTickMsgStream := pulsarms.NewPulsarMsgStream(s.ctx, 1024, 1024, dispatcherFactory.NewUnmarshalDispatcher())
|
||||
nodeTimeTickMsgStream.SetPulsarClient(Params.PulsarAddress)
|
||||
nodeTimeTickMsgStream.CreatePulsarConsumers(Params.NodeTimeTickChannel,
|
||||
nodeTimeTickMsgStream, _ := factory.NewMsgStream(s.ctx)
|
||||
nodeTimeTickMsgStream.AsConsumer(Params.NodeTimeTickChannel,
|
||||
"proxyservicesub") // TODO: add config
|
||||
log.Println("create node time tick consumer channel: ", Params.NodeTimeTickChannel)
|
||||
|
||||
|
|
|
|||
|
|
@ -109,14 +109,12 @@ func TestDataSyncService_Start(t *testing.T) {
|
|||
ddChannels := Params.DDChannelNames
|
||||
pulsarURL := Params.PulsarAddress
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
insertStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
insertStream.SetPulsarClient(pulsarURL)
|
||||
insertStream.CreatePulsarProducers(insertChannels)
|
||||
factory := pulsarms.NewFactory(pulsarURL, receiveBufSize, 1024)
|
||||
insertStream, _ := factory.NewMsgStream(node.queryNodeLoopCtx)
|
||||
insertStream.AsProducer(insertChannels)
|
||||
|
||||
ddStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
ddStream.SetPulsarClient(pulsarURL)
|
||||
ddStream.CreatePulsarProducers(ddChannels)
|
||||
ddStream, _ := factory.NewMsgStream(node.queryNodeLoopCtx)
|
||||
ddStream.AsProducer(ddChannels)
|
||||
|
||||
var insertMsgStream msgstream.MsgStream = insertStream
|
||||
insertMsgStream.Start()
|
||||
|
|
|
|||
|
|
@ -9,18 +9,13 @@ import (
|
|||
)
|
||||
|
||||
func (dsService *dataSyncService) newDmInputNode(ctx context.Context) *flowgraph.InputNode {
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
receiveBufSize := Params.InsertReceiveBufSize
|
||||
pulsarBufSize := Params.InsertPulsarBufSize
|
||||
|
||||
msgStreamURL := Params.PulsarAddress
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, Params.InsertReceiveBufSize, Params.InsertPulsarBufSize)
|
||||
|
||||
consumeChannels := Params.InsertChannelNames
|
||||
consumeSubName := Params.MsgChannelSubName
|
||||
|
||||
insertStream := pulsarms.NewPulsarTtMsgStream(ctx, receiveBufSize, pulsarBufSize, factory.NewUnmarshalDispatcher())
|
||||
insertStream.SetPulsarClient(msgStreamURL)
|
||||
insertStream.CreatePulsarConsumers(consumeChannels, consumeSubName)
|
||||
insertStream, _ := factory.NewTtMsgStream(ctx)
|
||||
insertStream.AsConsumer(consumeChannels, consumeSubName)
|
||||
|
||||
var stream msgstream.MsgStream = insertStream
|
||||
dsService.dmStream = stream
|
||||
|
|
@ -33,18 +28,13 @@ func (dsService *dataSyncService) newDmInputNode(ctx context.Context) *flowgraph
|
|||
}
|
||||
|
||||
func (dsService *dataSyncService) newDDInputNode(ctx context.Context) *flowgraph.InputNode {
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
receiveBufSize := Params.DDReceiveBufSize
|
||||
pulsarBufSize := Params.DDPulsarBufSize
|
||||
|
||||
msgStreamURL := Params.PulsarAddress
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, Params.DDReceiveBufSize, Params.DDPulsarBufSize)
|
||||
|
||||
consumeChannels := Params.DDChannelNames
|
||||
consumeSubName := Params.MsgChannelSubName
|
||||
|
||||
ddStream := pulsarms.NewPulsarTtMsgStream(ctx, receiveBufSize, pulsarBufSize, factory.NewUnmarshalDispatcher())
|
||||
ddStream.SetPulsarClient(msgStreamURL)
|
||||
ddStream.CreatePulsarConsumers(consumeChannels, consumeSubName)
|
||||
ddStream, _ := factory.NewTtMsgStream(ctx)
|
||||
ddStream.AsConsumer(consumeChannels, consumeSubName)
|
||||
|
||||
var stream msgstream.MsgStream = ddStream
|
||||
dsService.ddStream = stream
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ import (
|
|||
type serviceTimeNode struct {
|
||||
baseNode
|
||||
replica collectionReplica
|
||||
timeTickMsgStream *pulsarms.PulsarMsgStream
|
||||
timeTickMsgStream msgstream.MsgStream
|
||||
}
|
||||
|
||||
func (stNode *serviceTimeNode) Name() string {
|
||||
|
|
@ -78,10 +78,9 @@ func newServiceTimeNode(ctx context.Context, replica collectionReplica) *service
|
|||
baseNode.SetMaxQueueLength(maxQueueLength)
|
||||
baseNode.SetMaxParallelism(maxParallelism)
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
timeTimeMsgStream := pulsarms.NewPulsarMsgStream(ctx, Params.SearchReceiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
timeTimeMsgStream.SetPulsarClient(Params.PulsarAddress)
|
||||
timeTimeMsgStream.CreatePulsarProducers([]string{Params.QueryTimeTickChannelName})
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, Params.SearchReceiveBufSize, 1024)
|
||||
timeTimeMsgStream, _ := factory.NewMsgStream(ctx)
|
||||
timeTimeMsgStream.AsProducer([]string{Params.QueryTimeTickChannelName})
|
||||
|
||||
return &serviceTimeNode{
|
||||
baseNode: baseNode,
|
||||
|
|
|
|||
|
|
@ -130,10 +130,10 @@ import (
|
|||
//
|
||||
// insertStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize)
|
||||
// insertStream.SetPulsarClient(Params.PulsarAddress)
|
||||
// insertStream.CreatePulsarProducers(insertChannels)
|
||||
// insertStream.AsProducer(insertChannels)
|
||||
// ddStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize)
|
||||
// ddStream.SetPulsarClient(Params.PulsarAddress)
|
||||
// ddStream.CreatePulsarProducers(ddChannels)
|
||||
// ddStream.AsProducer(ddChannels)
|
||||
//
|
||||
// var insertMsgStream msgstream.MsgStream = insertStream
|
||||
// insertMsgStream.Start()
|
||||
|
|
@ -206,7 +206,7 @@ import (
|
|||
// }
|
||||
// searchStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize)
|
||||
// searchStream.SetPulsarClient(Params.PulsarAddress)
|
||||
// searchStream.CreatePulsarProducers(newSearchChannelNames)
|
||||
// searchStream.AsProducer(newSearchChannelNames)
|
||||
// searchStream.Start()
|
||||
// err = searchStream.Produce(fn(1))
|
||||
// assert.NoError(t, err)
|
||||
|
|
@ -215,7 +215,7 @@ import (
|
|||
// searchResultStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize)
|
||||
// searchResultStream.SetPulsarClient(Params.PulsarAddress)
|
||||
// unmarshalDispatcher := util.NewUnmarshalDispatcher()
|
||||
// searchResultStream.CreatePulsarConsumers(newSearchResultChannelNames, "loadIndexTestSubSearchResult", unmarshalDispatcher, receiveBufSize)
|
||||
// searchResultStream.AsConsumer(newSearchResultChannelNames, "loadIndexTestSubSearchResult", unmarshalDispatcher, receiveBufSize)
|
||||
// searchResultStream.Start()
|
||||
// searchResult := searchResultStream.Consume()
|
||||
// assert.NotNil(t, searchResult)
|
||||
|
|
@ -295,7 +295,7 @@ import (
|
|||
// // init message stream consumer and do checks
|
||||
// statsMs := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, Params.StatsReceiveBufSize)
|
||||
// statsMs.SetPulsarClient(Params.PulsarAddress)
|
||||
// statsMs.CreatePulsarConsumers([]string{Params.StatsChannelName}, Params.MsgChannelSubName, util.NewUnmarshalDispatcher(), Params.StatsReceiveBufSize)
|
||||
// statsMs.AsConsumer([]string{Params.StatsChannelName}, Params.MsgChannelSubName, util.NewUnmarshalDispatcher(), Params.StatsReceiveBufSize)
|
||||
// statsMs.Start()
|
||||
//
|
||||
// findFiledStats := false
|
||||
|
|
@ -464,10 +464,10 @@ import (
|
|||
//
|
||||
// insertStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize)
|
||||
// insertStream.SetPulsarClient(Params.PulsarAddress)
|
||||
// insertStream.CreatePulsarProducers(insertChannels)
|
||||
// insertStream.AsProducer(insertChannels)
|
||||
// ddStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize)
|
||||
// ddStream.SetPulsarClient(Params.PulsarAddress)
|
||||
// ddStream.CreatePulsarProducers(ddChannels)
|
||||
// ddStream.AsProducer(ddChannels)
|
||||
//
|
||||
// var insertMsgStream msgstream.MsgStream = insertStream
|
||||
// insertMsgStream.Start()
|
||||
|
|
@ -529,7 +529,7 @@ import (
|
|||
// }
|
||||
// searchStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize)
|
||||
// searchStream.SetPulsarClient(Params.PulsarAddress)
|
||||
// searchStream.CreatePulsarProducers(newSearchChannelNames)
|
||||
// searchStream.AsProducer(newSearchChannelNames)
|
||||
// searchStream.Start()
|
||||
// err = searchStream.Produce(fn(1))
|
||||
// assert.NoError(t, err)
|
||||
|
|
@ -538,7 +538,7 @@ import (
|
|||
// searchResultStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize)
|
||||
// searchResultStream.SetPulsarClient(Params.PulsarAddress)
|
||||
// unmarshalDispatcher := util.NewUnmarshalDispatcher()
|
||||
// searchResultStream.CreatePulsarConsumers(newSearchResultChannelNames, "loadIndexTestSubSearchResult2", unmarshalDispatcher, receiveBufSize)
|
||||
// searchResultStream.AsConsumer(newSearchResultChannelNames, "loadIndexTestSubSearchResult2", unmarshalDispatcher, receiveBufSize)
|
||||
// searchResultStream.Start()
|
||||
// searchResult := searchResultStream.Consume()
|
||||
// assert.NotNil(t, searchResult)
|
||||
|
|
@ -612,7 +612,7 @@ import (
|
|||
// // init message stream consumer and do checks
|
||||
// statsMs := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, Params.StatsReceiveBufSize)
|
||||
// statsMs.SetPulsarClient(Params.PulsarAddress)
|
||||
// statsMs.CreatePulsarConsumers([]string{Params.StatsChannelName}, Params.MsgChannelSubName, util.NewUnmarshalDispatcher(), Params.StatsReceiveBufSize)
|
||||
// statsMs.AsConsumer([]string{Params.StatsChannelName}, Params.MsgChannelSubName, util.NewUnmarshalDispatcher(), Params.StatsReceiveBufSize)
|
||||
// statsMs.Start()
|
||||
//
|
||||
// findFiledStats := false
|
||||
|
|
@ -1016,15 +1016,13 @@ func doInsert(ctx context.Context, collectionID UniqueID, partitionID UniqueID,
|
|||
ddChannels := Params.DDChannelNames
|
||||
pulsarURL := Params.PulsarAddress
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
insertStream := pulsarms.NewPulsarMsgStream(ctx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
insertStream.SetPulsarClient(pulsarURL)
|
||||
insertStream.CreatePulsarProducers(insertChannels)
|
||||
insertStream.CreatePulsarConsumers(insertChannels, Params.MsgChannelSubName)
|
||||
factory := pulsarms.NewFactory(pulsarURL, receiveBufSize, 1024)
|
||||
insertStream, _ := factory.NewMsgStream(ctx)
|
||||
insertStream.AsProducer(insertChannels)
|
||||
insertStream.AsConsumer(insertChannels, Params.MsgChannelSubName)
|
||||
|
||||
ddStream := pulsarms.NewPulsarMsgStream(ctx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
ddStream.SetPulsarClient(pulsarURL)
|
||||
ddStream.CreatePulsarProducers(ddChannels)
|
||||
ddStream, _ := factory.NewMsgStream(ctx)
|
||||
ddStream.AsProducer(ddChannels)
|
||||
|
||||
var insertMsgStream msgstream.MsgStream = insertStream
|
||||
insertMsgStream.Start()
|
||||
|
|
@ -1076,15 +1074,13 @@ func sentTimeTick(ctx context.Context) error {
|
|||
ddChannels := Params.DDChannelNames
|
||||
pulsarURL := Params.PulsarAddress
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
insertStream := pulsarms.NewPulsarMsgStream(ctx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
insertStream.SetPulsarClient(pulsarURL)
|
||||
insertStream.CreatePulsarProducers(insertChannels)
|
||||
insertStream.CreatePulsarConsumers(insertChannels, Params.MsgChannelSubName)
|
||||
factory := pulsarms.NewFactory(pulsarURL, receiveBufSize, 1024)
|
||||
insertStream, _ := factory.NewMsgStream(ctx)
|
||||
insertStream.AsProducer(insertChannels)
|
||||
insertStream.AsConsumer(insertChannels, Params.MsgChannelSubName)
|
||||
|
||||
ddStream := pulsarms.NewPulsarMsgStream(ctx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
ddStream.SetPulsarClient(pulsarURL)
|
||||
ddStream.CreatePulsarProducers(ddChannels)
|
||||
ddStream, _ := factory.NewMsgStream(ctx)
|
||||
ddStream.AsProducer(ddChannels)
|
||||
|
||||
var insertMsgStream msgstream.MsgStream = insertStream
|
||||
insertMsgStream.Start()
|
||||
|
|
|
|||
|
|
@ -333,11 +333,11 @@ func (node *QueryNode) AddQueryChannel(in *queryPb.AddQueryChannelsRequest) (*co
|
|||
// add request channel
|
||||
consumeChannels := []string{in.RequestChannelID}
|
||||
consumeSubName := Params.MsgChannelSubName
|
||||
searchStream.CreatePulsarConsumers(consumeChannels, consumeSubName)
|
||||
searchStream.AsConsumer(consumeChannels, consumeSubName)
|
||||
|
||||
// add result channel
|
||||
producerChannels := []string{in.ResultChannelID}
|
||||
resultStream.CreatePulsarProducers(producerChannels)
|
||||
resultStream.AsProducer(producerChannels)
|
||||
|
||||
status := &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_SUCCESS,
|
||||
|
|
@ -382,12 +382,12 @@ func (node *QueryNode) RemoveQueryChannel(in *queryPb.RemoveQueryChannelsRequest
|
|||
consumeChannels := []string{in.RequestChannelID}
|
||||
consumeSubName := Params.MsgChannelSubName
|
||||
// TODO: searchStream.RemovePulsarConsumers(producerChannels)
|
||||
searchStream.CreatePulsarConsumers(consumeChannels, consumeSubName)
|
||||
searchStream.AsConsumer(consumeChannels, consumeSubName)
|
||||
|
||||
// remove result channel
|
||||
producerChannels := []string{in.ResultChannelID}
|
||||
// TODO: resultStream.RemovePulsarProducer(producerChannels)
|
||||
resultStream.CreatePulsarProducers(producerChannels)
|
||||
resultStream.AsProducer(producerChannels)
|
||||
|
||||
status := &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_SUCCESS,
|
||||
|
|
@ -420,7 +420,7 @@ func (node *QueryNode) WatchDmChannels(in *queryPb.WatchDmChannelsRequest) (*com
|
|||
// add request channel
|
||||
consumeChannels := in.ChannelIDs
|
||||
consumeSubName := Params.MsgChannelSubName
|
||||
fgDMMsgStream.CreatePulsarConsumers(consumeChannels, consumeSubName)
|
||||
fgDMMsgStream.AsConsumer(consumeChannels, consumeSubName)
|
||||
|
||||
status := &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_SUCCESS,
|
||||
|
|
|
|||
|
|
@ -47,19 +47,17 @@ func newSearchService(ctx context.Context, replica collectionReplica) *searchSer
|
|||
|
||||
msgStreamURL := Params.PulsarAddress
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
factory := pulsarms.NewFactory(msgStreamURL, receiveBufSize, pulsarBufSize)
|
||||
|
||||
consumeChannels := Params.SearchChannelNames
|
||||
consumeSubName := Params.MsgChannelSubName
|
||||
searchStream := pulsarms.NewPulsarMsgStream(ctx, receiveBufSize, pulsarBufSize, factory.NewUnmarshalDispatcher())
|
||||
searchStream.SetPulsarClient(msgStreamURL)
|
||||
searchStream.CreatePulsarConsumers(consumeChannels, consumeSubName)
|
||||
searchStream, _ := factory.NewMsgStream(ctx)
|
||||
searchStream.AsConsumer(consumeChannels, consumeSubName)
|
||||
var inputStream msgstream.MsgStream = searchStream
|
||||
|
||||
producerChannels := Params.SearchResultChannelNames
|
||||
searchResultStream := pulsarms.NewPulsarMsgStream(ctx, receiveBufSize, pulsarBufSize, factory.NewUnmarshalDispatcher())
|
||||
searchResultStream.SetPulsarClient(msgStreamURL)
|
||||
searchResultStream.CreatePulsarProducers(producerChannels)
|
||||
searchResultStream, _ := factory.NewMsgStream(ctx)
|
||||
searchResultStream.AsProducer(producerChannels)
|
||||
var outputStream msgstream.MsgStream = searchResultStream
|
||||
|
||||
searchServiceCtx, searchServiceCancel := context.WithCancel(ctx)
|
||||
|
|
|
|||
|
|
@ -93,10 +93,9 @@ func TestSearch_Search(t *testing.T) {
|
|||
msgPackSearch := msgstream.MsgPack{}
|
||||
msgPackSearch.Msgs = append(msgPackSearch.Msgs, searchMsg)
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
searchStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
searchStream.SetPulsarClient(pulsarURL)
|
||||
searchStream.CreatePulsarProducers(searchProducerChannels)
|
||||
factory := pulsarms.NewFactory(pulsarURL, receiveBufSize, 1024)
|
||||
searchStream, _ := factory.NewMsgStream(node.queryNodeLoopCtx)
|
||||
searchStream.AsProducer(searchProducerChannels)
|
||||
searchStream.Start()
|
||||
err = searchStream.Produce(&msgPackSearch)
|
||||
assert.NoError(t, err)
|
||||
|
|
@ -180,13 +179,11 @@ func TestSearch_Search(t *testing.T) {
|
|||
insertChannels := Params.InsertChannelNames
|
||||
ddChannels := Params.DDChannelNames
|
||||
|
||||
insertStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
insertStream.SetPulsarClient(pulsarURL)
|
||||
insertStream.CreatePulsarProducers(insertChannels)
|
||||
insertStream, _ := factory.NewMsgStream(node.queryNodeLoopCtx)
|
||||
insertStream.AsProducer(insertChannels)
|
||||
|
||||
ddStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
ddStream.SetPulsarClient(pulsarURL)
|
||||
ddStream.CreatePulsarProducers(ddChannels)
|
||||
ddStream, _ := factory.NewMsgStream(node.queryNodeLoopCtx)
|
||||
ddStream.AsProducer(ddChannels)
|
||||
|
||||
var insertMsgStream msgstream.MsgStream = insertStream
|
||||
insertMsgStream.Start()
|
||||
|
|
@ -286,10 +283,9 @@ func TestSearch_SearchMultiSegments(t *testing.T) {
|
|||
msgPackSearch := msgstream.MsgPack{}
|
||||
msgPackSearch.Msgs = append(msgPackSearch.Msgs, searchMsg)
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
searchStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
searchStream.SetPulsarClient(pulsarURL)
|
||||
searchStream.CreatePulsarProducers(searchProducerChannels)
|
||||
factory := pulsarms.NewFactory(pulsarURL, receiveBufSize, 1024)
|
||||
searchStream, _ := factory.NewMsgStream(node.queryNodeLoopCtx)
|
||||
searchStream.AsProducer(searchProducerChannels)
|
||||
searchStream.Start()
|
||||
err = searchStream.Produce(&msgPackSearch)
|
||||
assert.NoError(t, err)
|
||||
|
|
@ -377,13 +373,11 @@ func TestSearch_SearchMultiSegments(t *testing.T) {
|
|||
insertChannels := Params.InsertChannelNames
|
||||
ddChannels := Params.DDChannelNames
|
||||
|
||||
insertStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
insertStream.SetPulsarClient(pulsarURL)
|
||||
insertStream.CreatePulsarProducers(insertChannels)
|
||||
insertStream, _ := factory.NewMsgStream(node.queryNodeLoopCtx)
|
||||
insertStream.AsProducer(insertChannels)
|
||||
|
||||
ddStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
ddStream.SetPulsarClient(pulsarURL)
|
||||
ddStream.CreatePulsarProducers(ddChannels)
|
||||
ddStream, _ := factory.NewMsgStream(node.queryNodeLoopCtx)
|
||||
ddStream.AsProducer(ddChannels)
|
||||
|
||||
var insertMsgStream msgstream.MsgStream = insertStream
|
||||
insertMsgStream.Start()
|
||||
|
|
|
|||
|
|
@ -36,16 +36,13 @@ func newStatsService(ctx context.Context, replica collectionReplica, fieldStatsC
|
|||
|
||||
func (sService *statsService) start() {
|
||||
sleepTimeInterval := Params.StatsPublishInterval
|
||||
receiveBufSize := Params.StatsReceiveBufSize
|
||||
|
||||
// start pulsar
|
||||
msgStreamURL := Params.PulsarAddress
|
||||
producerChannels := []string{Params.StatsChannelName}
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
statsStream := pulsarms.NewPulsarMsgStream(sService.ctx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
statsStream.SetPulsarClient(msgStreamURL)
|
||||
statsStream.CreatePulsarProducers(producerChannels)
|
||||
factory := pulsarms.NewFactory(Params.PulsarAddress, Params.StatsReceiveBufSize, 1024)
|
||||
statsStream, _ := factory.NewMsgStream(sService.ctx)
|
||||
statsStream.AsProducer(producerChannels)
|
||||
|
||||
var statsMsgStream msgstream.MsgStream = statsStream
|
||||
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ package querynode
|
|||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/zilliztech/milvus-distributed/internal/msgstream"
|
||||
"github.com/zilliztech/milvus-distributed/internal/msgstream/pulsarms"
|
||||
)
|
||||
|
|
@ -26,11 +27,10 @@ func TestSegmentManagement_sendSegmentStatistic(t *testing.T) {
|
|||
producerChannels := []string{Params.StatsChannelName}
|
||||
|
||||
pulsarURL := Params.PulsarAddress
|
||||
|
||||
factory := msgstream.ProtoUDFactory{}
|
||||
statsStream := pulsarms.NewPulsarMsgStream(node.queryNodeLoopCtx, receiveBufSize, 1024, factory.NewUnmarshalDispatcher())
|
||||
statsStream.SetPulsarClient(pulsarURL)
|
||||
statsStream.CreatePulsarProducers(producerChannels)
|
||||
factory := pulsarms.NewFactory(pulsarURL, receiveBufSize, 1024)
|
||||
statsStream, err := factory.NewMsgStream(node.queryNodeLoopCtx)
|
||||
assert.Nil(t, err)
|
||||
statsStream.AsProducer(producerChannels)
|
||||
|
||||
var statsMsgStream msgstream.MsgStream = statsStream
|
||||
|
||||
|
|
|
|||
|
|
@ -228,10 +228,10 @@ func TestLoadCollection(t *testing.T) {
|
|||
//
|
||||
//insertStream := pulsarms.NewPulsarMsgStream(context.Background(), receiveBufSize)
|
||||
//insertStream.SetPulsarClient(pulsarAddress)
|
||||
//insertStream.CreatePulsarProducers(insertChannels)
|
||||
//insertStream.AsProducer(insertChannels)
|
||||
//ddStream := pulsarms.NewPulsarMsgStream(context.Background(), receiveBufSize)
|
||||
//ddStream.SetPulsarClient(pulsarAddress)
|
||||
//ddStream.CreatePulsarProducers(ddChannels)
|
||||
//ddStream.AsProducer(ddChannels)
|
||||
//
|
||||
//var insertMsgStream msgstream.MsgStream = insertStream
|
||||
//insertMsgStream.Start()
|
||||
|
|
@ -246,7 +246,7 @@ func TestLoadCollection(t *testing.T) {
|
|||
//consumeStream := pulsarms.NewPulsarTtMsgStream(context.Background(), receiveBufSize)
|
||||
//consumeStream.SetPulsarClient(pulsarAddress)
|
||||
//unmarshalDispatcher := util.NewUnmarshalDispatcher()
|
||||
//consumeStream.CreatePulsarConsumers(insertChannels, "test", unmarshalDispatcher, pulsarBufSize)
|
||||
//consumeStream.AsConsumer(insertChannels, "test", unmarshalDispatcher, pulsarBufSize)
|
||||
//consumeStream.Start()
|
||||
//
|
||||
//for i := 0; i < 10; i++ {
|
||||
|
|
|
|||
Loading…
Reference in New Issue