test/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2024-12-02 03:48:37 +08:00
Code Issues Actions 12 Packages Projects Releases Wiki Activity

Update masterservice unittest

Browse Source 
Signed-off-by: neza2017 <yefu.chen@zilliz.com>
This commit is contained in:
neza2017 2021-03-05 20:41:34 +08:00 committed by yefu.chen
parent e5d595564a
commit 2835bcdc4e
21 changed files with 366 additions and 375 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
internal/core/src/pb/common.pb.cc
View File

@ -232,7 +232,7 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
"\010msg_type\030\001 \001(\0162\034.milvus.proto.common.Ms"
"gType\022\r\n\005msgID\030\002 \001(\003\022\021\n\ttimestamp\030\003 \001(\004\022"
"\020\n\010sourceID\030\004 \001(\003\"7\n\tMsgHeader\022*\n\004base\030\001"
" \001(\0132\034.milvus.proto.common.MsgBase*\270\004\n\tE"
" \001(\0132\034.milvus.proto.common.MsgBase*\315\004\n\tE"
"rrorCode\022\013\n\007SUCCESS\020\000\022\024\n\020UNEXPECTED_ERRO"
"R\020\001\022\022\n\016CONNECT_FAILED\020\002\022\025\n\021PERMISSION_DE"
"NIED\020\003\022\031\n\025COLLECTION_NOT_EXISTS\020\004\022\024\n\020ILL"
@ -246,34 +246,35 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
"_FILE\020\022\022\030\n\024CANNOT_DELETE_FOLDER\020\023\022\026\n\022CAN"
"NOT_DELETE_FILE\020\024\022\025\n\021BUILD_INDEX_ERROR\020\025"
"\022\021\n\rILLEGAL_NLIST\020\026\022\027\n\023ILLEGAL_METRIC_TY"
"PE\020\027\022\021\n\rOUT_OF_MEMORY\020\030\022\024\n\017DD_REQUEST_RA"
"CE\020\350\007*[\n\nIndexState\022\010\n\004NONE\020\000\022\014\n\010UNISSUE"
"D\020\001\022\016\n\nINPROGRESS\020\002\022\014\n\010FINISHED\020\003\022\n\n\006FAI"
"LED\020\004\022\013\n\007DELETED\020\005*o\n\014SegmentState\022\017\n\013Se"
"gmentNone\020\000\022\023\n\017SegmentNotExist\020\001\022\022\n\016Segm"
"entGrowing\020\002\022\021\n\rSegmentSealed\020\003\022\022\n\016Segme"
"ntFlushed\020\004*\225\006\n\007MsgType\022\t\n\005kNone\020\000\022\025\n\021kC"
"reateCollection\020d\022\023\n\017kDropCollection\020e\022\022"
"\n\016kHasCollection\020f\022\027\n\023kDescribeCollectio"
"n\020g\022\024\n\020kShowCollections\020h\022\022\n\016kGetSysConf"
"igs\020i\022\023\n\017kLoadCollection\020j\022\026\n\022kReleaseCo"
"llection\020k\022\025\n\020kCreatePartition\020\310\001\022\023\n\016kDr"
"opPartition\020\311\001\022\022\n\rkHasPartition\020\312\001\022\027\n\022kD"
"escribePartition\020\313\001\022\024\n\017kShowPartitions\020\314"
"\001\022\023\n\016kLoadPartition\020\315\001\022\026\n\021kReleasePartit"
"ion\020\316\001\022\021\n\014kShowSegment\020\372\001\022\025\n\020kDescribeSe"
"gment\020\373\001\022\021\n\014kCreateIndex\020\254\002\022\023\n\016kDescribe"
"Index\020\255\002\022\017\n\nkDropIndex\020\256\002\022\014\n\007kInsert\020\220\003\022"
"\014\n\007kDelete\020\221\003\022\013\n\006kFlush\020\222\003\022\014\n\007kSearch\020\364\003"
"\022\022\n\rkSearchResult\020\365\003\022\023\n\016kGetIndexState\020\366"
"\003\022\035\n\030kGetCollectionStatistics\020\367\003\022\034\n\027kGet"
"PartitionStatistics\020\370\003\022\021\n\014kSegmentInfo\020\330"
"\004\022\016\n\tkTimeTick\020\260\t\022\024\n\017kQueryNodeStats\020\261\t\022"
"\017\n\nkLoadIndex\020\262\t\022\017\n\nkRequestID\020\263\t\022\020\n\013kRe"
"questTSO\020\264\t\022\025\n\020kAllocateSegment\020\265\t\022\027\n\022kS"
"egmentStatistics\020\266\t\022\026\n\021kSegmentFlushDone"
"\020\267\tBBZ@github.com/zilliztech/milvus-dist"
"ributed/internal/proto/commonpbb\006proto3"
"PE\020\027\022\021\n\rOUT_OF_MEMORY\020\030\022\023\n\017INDEX_NOT_EXI"
"ST\020\031\022\024\n\017DD_REQUEST_RACE\020\350\007*[\n\nIndexState"
"\022\010\n\004NONE\020\000\022\014\n\010UNISSUED\020\001\022\016\n\nINPROGRESS\020\002"
"\022\014\n\010FINISHED\020\003\022\n\n\006FAILED\020\004\022\013\n\007DELETED\020\005*"
"o\n\014SegmentState\022\017\n\013SegmentNone\020\000\022\023\n\017Segm"
"entNotExist\020\001\022\022\n\016SegmentGrowing\020\002\022\021\n\rSeg"
"mentSealed\020\003\022\022\n\016SegmentFlushed\020\004*\225\006\n\007Msg"
"Type\022\t\n\005kNone\020\000\022\025\n\021kCreateCollection\020d\022\023"
"\n\017kDropCollection\020e\022\022\n\016kHasCollection\020f\022"
"\027\n\023kDescribeCollection\020g\022\024\n\020kShowCollect"
"ions\020h\022\022\n\016kGetSysConfigs\020i\022\023\n\017kLoadColle"
"ction\020j\022\026\n\022kReleaseCollection\020k\022\025\n\020kCrea"
"tePartition\020\310\001\022\023\n\016kDropPartition\020\311\001\022\022\n\rk"
"HasPartition\020\312\001\022\027\n\022kDescribePartition\020\313\001"
"\022\024\n\017kShowPartitions\020\314\001\022\023\n\016kLoadPartition"
"\020\315\001\022\026\n\021kReleasePartition\020\316\001\022\021\n\014kShowSegm"
"ent\020\372\001\022\025\n\020kDescribeSegment\020\373\001\022\021\n\014kCreate"
"Index\020\254\002\022\023\n\016kDescribeIndex\020\255\002\022\017\n\nkDropIn"
"dex\020\256\002\022\014\n\007kInsert\020\220\003\022\014\n\007kDelete\020\221\003\022\013\n\006kF"
"lush\020\222\003\022\014\n\007kSearch\020\364\003\022\022\n\rkSearchResult\020\365"
"\003\022\023\n\016kGetIndexState\020\366\003\022\035\n\030kGetCollection"
"Statistics\020\367\003\022\034\n\027kGetPartitionStatistics"
"\020\370\003\022\021\n\014kSegmentInfo\020\330\004\022\016\n\tkTimeTick\020\260\t\022\024"
"\n\017kQueryNodeStats\020\261\t\022\017\n\nkLoadIndex\020\262\t\022\017\n"
"\nkRequestID\020\263\t\022\020\n\013kRequestTSO\020\264\t\022\025\n\020kAll"
"ocateSegment\020\265\t\022\027\n\022kSegmentStatistics\020\266\t"
"\022\026\n\021kSegmentFlushDone\020\267\tBBZ@github.com/z"
"illiztech/milvus-distributed/internal/pr"
"oto/commonpbb\006proto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_common_2eproto_deps[1] = {
};
@ -289,7 +290,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_com
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_common_2eproto_once;
static bool descriptor_table_common_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto = {
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 2039,
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 2060,
&descriptor_table_common_2eproto_once, descriptor_table_common_2eproto_sccs, descriptor_table_common_2eproto_deps, 7, 0,
schemas, file_default_instances, TableStruct_common_2eproto::offsets,
file_level_metadata_common_2eproto, 7, file_level_enum_descriptors_common_2eproto, file_level_service_descriptors_common_2eproto,
@ -330,6 +331,7 @@ bool ErrorCode_IsValid(int value) {
case 22:
case 23:
case 24:
case 25:
case 1000:
return true;
default:

1
internal/core/src/pb/common.pb.h
View File

@ -120,6 +120,7 @@ enum ErrorCode : int {
ILLEGAL_NLIST = 22,
ILLEGAL_METRIC_TYPE = 23,
OUT_OF_MEMORY = 24,
INDEX_NOT_EXIST = 25,
DD_REQUEST_RACE = 1000,
ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()

13
internal/datanode/allocator.go
View File

@ -3,21 +3,20 @@ package datanode
import (
"context"
"github.com/zilliztech/milvus-distributed/internal/types"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/masterpb"
)
type (
allocatorInterface interface {
type allocatorInterface interface {
allocID() (UniqueID, error)
}
allocator struct {
masterService MasterServiceInterface
type allocator struct {
masterService types.MasterService
}
)
func newAllocator(s MasterServiceInterface) *allocator {
func newAllocator(s types.MasterService) *allocator {
return &allocator{
masterService: s,
}

40
internal/datanode/data_node.go
View File

@ -13,43 +13,20 @@ import (
"github.com/zilliztech/milvus-distributed/internal/log"
"github.com/zilliztech/milvus-distributed/internal/msgstream"
"github.com/zilliztech/milvus-distributed/internal/types"
"github.com/zilliztech/milvus-distributed/internal/util/typeutil"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/masterpb"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
"github.com/zilliztech/milvus-distributed/internal/util/typeutil"
)
const (
RPCConnectionTimeout = 30 * time.Second
)
type (
Interface interface {
typeutil.Service
typeutil.Component
WatchDmChannels(ctx context.Context, in *datapb.WatchDmChannelRequest) (*commonpb.Status, error)
FlushSegments(ctx context.Context, in *datapb.FlushSegRequest) error
SetMasterServiceInterface(ctx context.Context, ms MasterServiceInterface) error
SetDataServiceInterface(ctx context.Context, ds DataServiceInterface) error
}
DataServiceInterface interface {
GetComponentStates(ctx context.Context) (*internalpb2.ComponentStates, error)
RegisterNode(ctx context.Context, req *datapb.RegisterNodeRequest) (*datapb.RegisterNodeResponse, error)
}
MasterServiceInterface interface {
GetComponentStates(ctx context.Context) (*internalpb2.ComponentStates, error)
AllocID(ctx context.Context, in *masterpb.IDRequest) (*masterpb.IDResponse, error)
ShowCollections(ctx context.Context, in *milvuspb.ShowCollectionRequest) (*milvuspb.ShowCollectionResponse, error)
DescribeCollection(ctx context.Context, in *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)
}
DataNode struct {
type DataNode struct {
ctx context.Context
cancel context.CancelFunc
NodeID UniqueID
@ -60,8 +37,8 @@ type (
dataSyncService *dataSyncService
metaService *metaService
masterService MasterServiceInterface
dataService DataServiceInterface
masterService types.MasterService
dataService types.DataService
flushChan chan *flushMsg
replica Replica
@ -70,7 +47,6 @@ type (
msFactory msgstream.Factory
}
)
func NewDataNode(ctx context.Context, factory msgstream.Factory) *DataNode {
@ -92,7 +68,7 @@ func NewDataNode(ctx context.Context, factory msgstream.Factory) *DataNode {
return node
}
func (node *DataNode) SetMasterServiceInterface(ctx context.Context, ms MasterServiceInterface) error {
func (node *DataNode) SetMasterServiceInterface(ms types.MasterService) error {
switch {
case ms == nil, node.masterService != nil:
return errors.New("Nil parameter or repeatly set")
@ -102,7 +78,7 @@ func (node *DataNode) SetMasterServiceInterface(ctx context.Context, ms MasterSe
}
}
func (node *DataNode) SetDataServiceInterface(ctx context.Context, ds DataServiceInterface) error {
func (node *DataNode) SetDataServiceInterface(ds types.DataService) error {
switch {
case ds == nil, node.dataService != nil:
return errors.New("Nil parameter or repeatly set")

16
internal/datanode/data_node_test.go
View File

@ -14,9 +14,10 @@ import (
"go.uber.org/zap"
etcdkv "github.com/zilliztech/milvus-distributed/internal/kv/etcd"
"github.com/zilliztech/milvus-distributed/internal/log"
"github.com/zilliztech/milvus-distributed/internal/msgstream"
"github.com/zilliztech/milvus-distributed/internal/types"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/etcdpb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
@ -91,27 +92,26 @@ func clearEtcd(rootPath string) error {
}
type (
Factory interface {
type Factory interface {
}
MetaFactory struct {
type MetaFactory struct {
}
DataFactory struct {
type DataFactory struct {
rawData []byte
}
AllocatorFactory struct {
type AllocatorFactory struct {
ID UniqueID
}
MasterServiceFactory struct {
type MasterServiceFactory struct {
types.MasterService
ID UniqueID
collectionName string
collectionID UniqueID
}
)
func (mf *MetaFactory) CollectionMetaFactory(collectionID UniqueID, collectionName string) *etcdpb.CollectionMeta {
sch := schemapb.CollectionSchema{

6
internal/datanode/meta_service.go
View File

@ -8,6 +8,8 @@ import (
"go.uber.org/zap"
"github.com/zilliztech/milvus-distributed/internal/log"
"github.com/zilliztech/milvus-distributed/internal/types"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/etcdpb"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
@ -16,10 +18,10 @@ import (
type metaService struct {
ctx context.Context
replica Replica
masterClient MasterServiceInterface
masterClient types.MasterService
}
func newMetaService(ctx context.Context, replica Replica, m MasterServiceInterface) *metaService {
func newMetaService(ctx context.Context, replica Replica, m types.MasterService) *metaService {
return &metaService{
ctx: ctx,
replica: replica,

4
internal/datanode/type_def.go
View File

@ -7,9 +7,9 @@ type (
Timestamp = typeutil.Timestamp
IntPrimaryKey = typeutil.IntPrimaryKey
DSL = string
)
TimeRange struct {
type TimeRange struct {
timestampMin Timestamp
timestampMax Timestamp
}
)

6
internal/dataservice/allocator.go
View File

@ -3,6 +3,8 @@ package dataservice
import (
"context"
"github.com/zilliztech/milvus-distributed/internal/types"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/masterpb"
)
@ -13,10 +15,10 @@ type allocatorInterface interface {
}
type allocator struct {
masterClient MasterClient
masterClient types.MasterService
}
func newAllocator(masterClient MasterClient) *allocator {
func newAllocator(masterClient types.MasterService) *allocator {
return &allocator{
masterClient: masterClient,
}

14
internal/dataservice/cluster.go
View File

@ -8,29 +8,27 @@ import (
"go.uber.org/zap"
"github.com/zilliztech/milvus-distributed/internal/log"
"github.com/zilliztech/milvus-distributed/internal/types"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
)
type (
dataNode struct {
type dataNode struct {
id int64
address struct {
ip string
port int64
}
client DataNodeClient
client types.DataNode
channelNum int
}
dataNodeCluster struct {
type dataNodeCluster struct {
mu sync.RWMutex
finishCh chan struct{}
nodes []*dataNode
}
)
func (node *dataNode) String() string {
return fmt.Sprintf("id: %d, address: %s:%d", node.id, node.address.ip, node.address.port)
@ -114,7 +112,7 @@ func (c *dataNodeCluster) GetDataNodeStates(ctx context.Context) ([]*internalpb2
defer c.mu.RUnlock()
ret := make([]*internalpb2.ComponentInfo, 0)
for _, node := range c.nodes {
states, err := node.client.GetComponentStates(ctx, &commonpb.Empty{})
states, err := node.client.GetComponentStates(ctx)
if err != nil {
log.Error("get component states error", zap.Stringer("dataNode", node), zap.Error(err))
continue

22
internal/dataservice/meta.go
View File

@ -5,36 +5,32 @@ import (
"strconv"
"sync"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/schemapb"
"github.com/golang/protobuf/proto"
"github.com/zilliztech/milvus-distributed/internal/kv"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/schemapb"
)
type (
errSegmentNotFound struct {
type errSegmentNotFound struct {
segmentID UniqueID
}
errCollectionNotFound struct {
type errCollectionNotFound struct {
collectionID UniqueID
}
collectionInfo struct {
type collectionInfo struct {
ID UniqueID
Schema *schemapb.CollectionSchema
Partitions []UniqueID
}
meta struct {
type meta struct {
client kv.TxnBase // client of a reliable kv service, i.e. etcd client
collID2Info map[UniqueID]*collectionInfo // collection id to collection info
segID2Info map[UniqueID]*datapb.SegmentInfo // segment id to segment info
ddLock sync.RWMutex
}
)
func newErrSegmentNotFound(segmentID UniqueID) errSegmentNotFound {
return errSegmentNotFound{segmentID: segmentID}

30
internal/dataservice/mock.go
View File

@ -5,14 +5,14 @@ import (
"sync/atomic"
"time"
memkv "github.com/zilliztech/milvus-distributed/internal/kv/mem"
"github.com/zilliztech/milvus-distributed/internal/util/tsoutil"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
"github.com/zilliztech/milvus-distributed/internal/proto/schemapb"
memkv "github.com/zilliztech/milvus-distributed/internal/kv/mem"
"github.com/zilliztech/milvus-distributed/internal/util/tsoutil"
)
func newMemoryMeta(allocator allocatorInterface) (*meta, error) {
@ -55,6 +55,23 @@ func newTestSchema() *schemapb.CollectionSchema {
type mockDataNodeClient struct {
}
func (c *mockDataNodeClient) Init() error {
return nil
}
func (c *mockDataNodeClient) Start() error {
return nil
}
func (c *mockDataNodeClient) GetComponentStates(ctx context.Context) (*internalpb2.ComponentStates, error) {
//TODO
return nil, nil
}
func (c *mockDataNodeClient) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
return nil, nil
}
func newMockDataNodeClient() *mockDataNodeClient {
return &mockDataNodeClient{}
}
@ -63,11 +80,6 @@ func (c *mockDataNodeClient) WatchDmChannels(ctx context.Context, in *datapb.Wat
return &commonpb.Status{ErrorCode: commonpb.ErrorCode_SUCCESS}, nil
}
func (c *mockDataNodeClient) GetComponentStates(ctx context.Context, empty *commonpb.Empty) (*internalpb2.ComponentStates, error) {
// todo
return nil, nil
}
func (c *mockDataNodeClient) FlushSegments(ctx context.Context, in *datapb.FlushSegRequest) (*commonpb.Status, error) {
return &commonpb.Status{ErrorCode: commonpb.ErrorCode_SUCCESS}, nil
}

54
internal/dataservice/server.go
View File

@ -18,59 +18,26 @@ import (
etcdkv "github.com/zilliztech/milvus-distributed/internal/kv/etcd"
"github.com/zilliztech/milvus-distributed/internal/log"
"github.com/zilliztech/milvus-distributed/internal/msgstream"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/masterpb"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
"github.com/zilliztech/milvus-distributed/internal/timesync"
"github.com/zilliztech/milvus-distributed/internal/types"
"github.com/zilliztech/milvus-distributed/internal/util/retry"
"github.com/zilliztech/milvus-distributed/internal/util/typeutil"
"go.etcd.io/etcd/clientv3"
"go.uber.org/zap"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
)
const role = "dataservice"
type DataService interface {
typeutil.Component
RegisterNode(ctx context.Context, req *datapb.RegisterNodeRequest) (*datapb.RegisterNodeResponse, error)
Flush(ctx context.Context, req *datapb.FlushRequest) (*commonpb.Status, error)
AssignSegmentID(ctx context.Context, req *datapb.AssignSegIDRequest) (*datapb.AssignSegIDResponse, error)
ShowSegments(ctx context.Context, req *datapb.ShowSegmentRequest) (*datapb.ShowSegmentResponse, error)
GetSegmentStates(ctx context.Context, req *datapb.SegmentStatesRequest) (*datapb.SegmentStatesResponse, error)
GetInsertBinlogPaths(ctx context.Context, req *datapb.InsertBinlogPathRequest) (*datapb.InsertBinlogPathsResponse, error)
GetSegmentInfoChannel(ctx context.Context) (*milvuspb.StringResponse, error)
GetInsertChannels(ctx context.Context, req *datapb.InsertChannelRequest) (*internalpb2.StringList, error)
GetCollectionStatistics(ctx context.Context, req *datapb.CollectionStatsRequest) (*datapb.CollectionStatsResponse, error)
GetPartitionStatistics(ctx context.Context, req *datapb.PartitionStatsRequest) (*datapb.PartitionStatsResponse, error)
GetCount(ctx context.Context, req *datapb.CollectionCountRequest) (*datapb.CollectionCountResponse, error)
GetSegmentInfo(ctx context.Context, req *datapb.SegmentInfoRequest) (*datapb.SegmentInfoResponse, error)
}
type MasterClient interface {
ShowCollections(ctx context.Context, in *milvuspb.ShowCollectionRequest) (*milvuspb.ShowCollectionResponse, error)
DescribeCollection(ctx context.Context, in *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)
ShowPartitions(ctx context.Context, in *milvuspb.ShowPartitionRequest) (*milvuspb.ShowPartitionResponse, error)
GetDdChannel(ctx context.Context) (*milvuspb.StringResponse, error)
AllocTimestamp(ctx context.Context, in *masterpb.TsoRequest) (*masterpb.TsoResponse, error)
AllocID(ctx context.Context, in *masterpb.IDRequest) (*masterpb.IDResponse, error)
GetComponentStates(ctx context.Context) (*internalpb2.ComponentStates, error)
}
type DataNodeClient interface {
WatchDmChannels(ctx context.Context, in *datapb.WatchDmChannelRequest) (*commonpb.Status, error)
GetComponentStates(ctx context.Context, empty *commonpb.Empty) (*internalpb2.ComponentStates, error)
FlushSegments(ctx context.Context, in *datapb.FlushSegRequest) (*commonpb.Status, error)
Stop() error
}
type (
UniqueID = typeutil.UniqueID
Timestamp = typeutil.Timestamp
Server struct {
)
type Server struct {
ctx context.Context
serverLoopCtx context.Context
serverLoopCancel context.CancelFunc
@ -85,7 +52,7 @@ type (
cluster *dataNodeCluster
msgProducer *timesync.MsgProducer
registerFinishCh chan struct{}
masterClient MasterClient
masterClient types.MasterService
ttMsgStream msgstream.MsgStream
k2sMsgStream msgstream.MsgStream
ddChannelName string
@ -94,7 +61,6 @@ type (
msFactory msgstream.Factory
ttBarrier timesync.TimeTickBarrier
}
)
func CreateServer(ctx context.Context, factory msgstream.Factory) (*Server, error) {
ch := make(chan struct{})
@ -118,7 +84,7 @@ func (s *Server) getInsertChannels() []string {
return channels
}
func (s *Server) SetMasterClient(masterClient MasterClient) {
func (s *Server) SetMasterClient(masterClient types.MasterService) {
s.masterClient = masterClient
}

6
internal/dataservice/watcher.go
View File

@ -11,18 +11,16 @@ import (
"github.com/zilliztech/milvus-distributed/internal/msgstream"
)
type (
proxyTimeTickWatcher struct {
type proxyTimeTickWatcher struct {
allocator segmentAllocatorInterface
msgQueue chan *msgstream.TimeTickMsg
}
dataNodeTimeTickWatcher struct {
type dataNodeTimeTickWatcher struct {
meta *meta
cluster *dataNodeCluster
allocator segmentAllocatorInterface
msgQueue chan *msgstream.TimeTickMsg
}
)
func newProxyTimeTickWatcher(allocator segmentAllocatorInterface) *proxyTimeTickWatcher {
return &proxyTimeTickWatcher{

13
internal/distributed/datanode/client/client.go
View File

@ -7,10 +7,12 @@ import (
otgrpc "github.com/opentracing-contrib/go-grpc"
"github.com/opentracing/opentracing-go"
"github.com/zilliztech/milvus-distributed/internal/log"
"github.com/zilliztech/milvus-distributed/internal/util/retry"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/util/retry"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
"go.uber.org/zap"
"google.golang.org/grpc"
@ -62,8 +64,13 @@ func (c *Client) Stop() error {
return c.conn.Close()
}
func (c *Client) GetComponentStates(ctx context.Context, empty *commonpb.Empty) (*internalpb2.ComponentStates, error) {
return c.grpc.GetComponentStates(ctx, empty)
func (c *Client) GetComponentStates(ctx context.Context) (*internalpb2.ComponentStates, error) {
return c.grpc.GetComponentStates(ctx, &commonpb.Empty{})
}
func (c *Client) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
//TODO: implement grpc GetStatisticsChannel interface
panic("implement me")
}
func (c *Client) WatchDmChannels(ctx context.Context, in *datapb.WatchDmChannelRequest) (*commonpb.Status, error) {

41
internal/distributed/datanode/service.go
View File

@ -25,11 +25,12 @@ import (
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/types"
"github.com/zilliztech/milvus-distributed/internal/util/funcutil"
)
type Server struct {
impl *dn.DataNode
datanode *dn.DataNode
wg sync.WaitGroup
grpcErrChan chan error
grpcServer *grpc.Server
@ -38,8 +39,8 @@ type Server struct {
msFactory msgstream.Factory
masterService *msc.GrpcClient
dataService *dsc.Client
masterService types.MasterService
dataService types.DataService
closer io.Closer
}
@ -53,7 +54,7 @@ func New(ctx context.Context, factory msgstream.Factory) (*Server, error) {
grpcErrChan: make(chan error),
}
s.impl = dn.NewDataNode(s.ctx, s.msFactory)
s.datanode = dn.NewDataNode(s.ctx, s.msFactory)
return s, nil
}
@ -89,12 +90,12 @@ func (s *Server) startGrpcLoop(grpcPort int) {
}
func (s *Server) SetMasterServiceInterface(ctx context.Context, ms dn.MasterServiceInterface) error {
return s.impl.SetMasterServiceInterface(ctx, ms)
func (s *Server) SetMasterServiceInterface(ms types.MasterService) error {
return s.datanode.SetMasterServiceInterface(ms)
}
func (s *Server) SetDataServiceInterface(ctx context.Context, ds dn.DataServiceInterface) error {
return s.impl.SetDataServiceInterface(ctx, ds)
func (s *Server) SetDataServiceInterface(ds types.DataService) error {
return s.datanode.SetDataServiceInterface(ds)
}
func (s *Server) Run() error {
@ -120,7 +121,7 @@ func (s *Server) Stop() error {
s.grpcServer.GracefulStop()
}
err := s.impl.Stop()
err := s.datanode.Stop()
if err != nil {
return err
}
@ -182,7 +183,7 @@ func (s *Server) init() error {
panic(err)
}
if err := s.SetMasterServiceInterface(ctx, masterClient); err != nil {
if err := s.SetMasterServiceInterface(masterClient); err != nil {
panic(err)
}
@ -200,7 +201,7 @@ func (s *Server) init() error {
if err != nil {
panic(err)
}
if err := s.SetDataServiceInterface(ctx, dataService); err != nil {
if err := s.SetDataServiceInterface(dataService); err != nil {
panic(err)
}
@ -208,30 +209,30 @@ func (s *Server) init() error {
dn.Params.Port = Params.Port
dn.Params.IP = Params.IP
s.impl.NodeID = dn.Params.NodeID
s.impl.UpdateStateCode(internalpb2.StateCode_INITIALIZING)
s.datanode.NodeID = dn.Params.NodeID
s.datanode.UpdateStateCode(internalpb2.StateCode_INITIALIZING)
if err := s.impl.Init(); err != nil {
log.Warn("impl init error: ", zap.Error(err))
if err := s.datanode.Init(); err != nil {
log.Warn("datanode init error: ", zap.Error(err))
return err
}
return nil
}
func (s *Server) start() error {
return s.impl.Start()
return s.datanode.Start()
}
func (s *Server) GetComponentStates(ctx context.Context, empty *commonpb.Empty) (*internalpb2.ComponentStates, error) {
return s.impl.GetComponentStates(ctx)
return s.datanode.GetComponentStates(ctx)
}
func (s *Server) WatchDmChannels(ctx context.Context, in *datapb.WatchDmChannelRequest) (*commonpb.Status, error) {
return s.impl.WatchDmChannels(ctx, in)
return s.datanode.WatchDmChannels(ctx, in)
}
func (s *Server) FlushSegments(ctx context.Context, in *datapb.FlushSegRequest) (*commonpb.Status, error) {
if s.impl.State.Load().(internalpb2.StateCode) != internalpb2.StateCode_HEALTHY {
if s.datanode.State.Load().(internalpb2.StateCode) != internalpb2.StateCode_HEALTHY {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
Reason: "DataNode isn't healthy.",
@ -239,5 +240,5 @@ func (s *Server) FlushSegments(ctx context.Context, in *datapb.FlushSegRequest)
}
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
}, s.impl.FlushSegments(ctx, in)
}, s.datanode.FlushSegments(ctx, in)
}

57
internal/distributed/dataservice/service.go
View File

@ -16,18 +16,19 @@ import (
"google.golang.org/grpc"
otgrpc "github.com/opentracing-contrib/go-grpc"
msc "github.com/zilliztech/milvus-distributed/internal/distributed/masterservice/client"
"github.com/zilliztech/milvus-distributed/internal/log"
"github.com/opentracing/opentracing-go"
"github.com/uber/jaeger-client-go/config"
"github.com/zilliztech/milvus-distributed/internal/dataservice"
msc "github.com/zilliztech/milvus-distributed/internal/distributed/masterservice/client"
"github.com/zilliztech/milvus-distributed/internal/log"
"github.com/zilliztech/milvus-distributed/internal/msgstream"
"github.com/zilliztech/milvus-distributed/internal/types"
"github.com/zilliztech/milvus-distributed/internal/util/funcutil"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
"github.com/zilliztech/milvus-distributed/internal/util/funcutil"
)
type Server struct {
@ -37,9 +38,9 @@ type Server struct {
grpcErrChan chan error
wg sync.WaitGroup
impl *dataservice.Server
dataService *dataservice.Server
grpcServer *grpc.Server
masterClient *msc.GrpcClient
masterService types.MasterService
closer io.Closer
}
@ -69,7 +70,7 @@ func NewServer(ctx context.Context, factory msgstream.Factory) (*Server, error)
opentracing.SetGlobalTracer(tracer)
s.closer = closer
s.impl, err = dataservice.CreateServer(s.ctx, factory)
s.dataService, err = dataservice.CreateServer(s.ctx, factory)
if err != nil {
return nil, err
}
@ -99,7 +100,7 @@ func (s *Server) init() error {
if err = client.Start(); err != nil {
panic(err)
}
s.impl.UpdateStateCode(internalpb2.StateCode_INITIALIZING)
s.dataService.UpdateStateCode(internalpb2.StateCode_INITIALIZING)
ctx := context.Background()
err = funcutil.WaitForComponentInitOrHealthy(ctx, client, "MasterService", 100, time.Millisecond*200)
@ -107,11 +108,11 @@ func (s *Server) init() error {
if err != nil {
panic(err)
}
s.impl.SetMasterClient(client)
s.dataService.SetMasterClient(client)
dataservice.Params.Init()
if err := s.impl.Init(); err != nil {
log.Error("impl init error", zap.Error(err))
if err := s.dataService.Init(); err != nil {
log.Error("dataService init error", zap.Error(err))
return err
}
return nil
@ -146,7 +147,7 @@ func (s *Server) startGrpcLoop(grpcPort int) {
}
func (s *Server) start() error {
return s.impl.Start()
return s.dataService.Start()
}
func (s *Server) Stop() error {
@ -160,7 +161,7 @@ func (s *Server) Stop() error {
s.grpcServer.GracefulStop()
}
err = s.impl.Stop()
err = s.dataService.Stop()
if err != nil {
return err
}
@ -184,61 +185,61 @@ func (s *Server) Run() error {
}
func (s *Server) GetSegmentInfo(ctx context.Context, request *datapb.SegmentInfoRequest) (*datapb.SegmentInfoResponse, error) {
return s.impl.GetSegmentInfo(ctx, request)
return s.dataService.GetSegmentInfo(ctx, request)
}
func (s *Server) RegisterNode(ctx context.Context, request *datapb.RegisterNodeRequest) (*datapb.RegisterNodeResponse, error) {
return s.impl.RegisterNode(ctx, request)
return s.dataService.RegisterNode(ctx, request)
}
func (s *Server) Flush(ctx context.Context, request *datapb.FlushRequest) (*commonpb.Status, error) {
return s.impl.Flush(ctx, request)
return s.dataService.Flush(ctx, request)
}
func (s *Server) AssignSegmentID(ctx context.Context, request *datapb.AssignSegIDRequest) (*datapb.AssignSegIDResponse, error) {
return s.impl.AssignSegmentID(ctx, request)
return s.dataService.AssignSegmentID(ctx, request)
}
func (s *Server) ShowSegments(ctx context.Context, request *datapb.ShowSegmentRequest) (*datapb.ShowSegmentResponse, error) {
return s.impl.ShowSegments(ctx, request)
return s.dataService.ShowSegments(ctx, request)
}
func (s *Server) GetSegmentStates(ctx context.Context, request *datapb.SegmentStatesRequest) (*datapb.SegmentStatesResponse, error) {
return s.impl.GetSegmentStates(ctx, request)
return s.dataService.GetSegmentStates(ctx, request)
}
func (s *Server) GetInsertBinlogPaths(ctx context.Context, request *datapb.InsertBinlogPathRequest) (*datapb.InsertBinlogPathsResponse, error) {
return s.impl.GetInsertBinlogPaths(ctx, request)
return s.dataService.GetInsertBinlogPaths(ctx, request)
}
func (s *Server) GetInsertChannels(ctx context.Context, request *datapb.InsertChannelRequest) (*internalpb2.StringList, error) {
return s.impl.GetInsertChannels(ctx, request)
return s.dataService.GetInsertChannels(ctx, request)
}
func (s *Server) GetCollectionStatistics(ctx context.Context, request *datapb.CollectionStatsRequest) (*datapb.CollectionStatsResponse, error) {
return s.impl.GetCollectionStatistics(ctx, request)
return s.dataService.GetCollectionStatistics(ctx, request)
}
func (s *Server) GetPartitionStatistics(ctx context.Context, request *datapb.PartitionStatsRequest) (*datapb.PartitionStatsResponse, error) {
return s.impl.GetPartitionStatistics(ctx, request)
return s.dataService.GetPartitionStatistics(ctx, request)
}
func (s *Server) GetComponentStates(ctx context.Context, empty *commonpb.Empty) (*internalpb2.ComponentStates, error) {
return s.impl.GetComponentStates(ctx)
return s.dataService.GetComponentStates(ctx)
}
func (s *Server) GetTimeTickChannel(ctx context.Context, empty *commonpb.Empty) (*milvuspb.StringResponse, error) {
return s.impl.GetTimeTickChannel(ctx)
return s.dataService.GetTimeTickChannel(ctx)
}
func (s *Server) GetStatisticsChannel(ctx context.Context, empty *commonpb.Empty) (*milvuspb.StringResponse, error) {
return s.impl.GetStatisticsChannel(ctx)
return s.dataService.GetStatisticsChannel(ctx)
}
func (s *Server) GetSegmentInfoChannel(ctx context.Context, empty *commonpb.Empty) (*milvuspb.StringResponse, error) {
return s.impl.GetSegmentInfoChannel(ctx)
return s.dataService.GetSegmentInfoChannel(ctx)
}
func (s *Server) GetCount(ctx context.Context, request *datapb.CollectionCountRequest) (*datapb.CollectionCountResponse, error) {
return s.impl.GetCount(ctx, request)
return s.dataService.GetCount(ctx, request)
}

7
internal/masterservice/master_service.go
View File

@ -1293,10 +1293,17 @@ func (c *Core) DescribeIndex(ctx context.Context, in *milvuspb.DescribeIndexRequ
idxNames = append(idxNames, i.IndexName)
}
log.Debug("DescribeIndex Success", zap.String("collection name", in.CollectionName), zap.String("field name", in.FieldName), zap.Strings("index names", idxNames))
if len(t.Rsp.IndexDescriptions) == 0 {
t.Rsp.Status = &commonpb.Status{
ErrorCode: commonpb.ErrorCode_INDEX_NOT_EXIST,
Reason: "index not exist",
}
} else {
t.Rsp.Status = &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
Reason: "",
}
}
return t.Rsp, nil
}

19
internal/masterservice/master_service_test.go
View File

@ -668,6 +668,25 @@ func TestMasterService(t *testing.T) {
assert.Equal(t, rsp.IndexDescriptions[0].IndexName, Params.DefaultIndexName)
})
t.Run("describe index not exist", func(t *testing.T) {
req := &milvuspb.DescribeIndexRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_kDescribeIndex,
MsgID: 200,
Timestamp: 200,
SourceID: 200,
},
DbName: "",
CollectionName: "testColl",
FieldName: "vector",
IndexName: "not-exist-index",
}
rsp, err := core.DescribeIndex(ctx, req)
assert.Nil(t, err)
assert.Equal(t, rsp.Status.ErrorCode, commonpb.ErrorCode_INDEX_NOT_EXIST)
assert.Equal(t, len(rsp.IndexDescriptions), 0)
})
t.Run("flush segment", func(t *testing.T) {
coll, err := core.MetaTable.GetCollectionByName("testColl")
assert.Nil(t, err)

1
internal/proto/common.proto
View File

@ -28,6 +28,7 @@ enum ErrorCode {
ILLEGAL_NLIST = 22;
ILLEGAL_METRIC_TYPE = 23;
OUT_OF_MEMORY = 24;
INDEX_NOT_EXIST = 25;
// internal error code.
DD_REQUEST_RACE = 1000;

157
internal/proto/commonpb/common.pb.go
View File

@ -47,6 +47,7 @@ const (
ErrorCode_ILLEGAL_NLIST ErrorCode = 22
ErrorCode_ILLEGAL_METRIC_TYPE ErrorCode = 23
ErrorCode_OUT_OF_MEMORY ErrorCode = 24
ErrorCode_INDEX_NOT_EXIST ErrorCode = 25
// internal error code.
ErrorCode_DD_REQUEST_RACE ErrorCode = 1000
)
@ -76,6 +77,7 @@ var ErrorCode_name = map[int32]string{
22: "ILLEGAL_NLIST",
23: "ILLEGAL_METRIC_TYPE",
24: "OUT_OF_MEMORY",
25: "INDEX_NOT_EXIST",
1000: "DD_REQUEST_RACE",
}
@ -104,6 +106,7 @@ var ErrorCode_value = map[string]int32{
"ILLEGAL_NLIST": 22,
"ILLEGAL_METRIC_TYPE": 23,
"OUT_OF_MEMORY": 24,
"INDEX_NOT_EXIST": 25,
"DD_REQUEST_RACE": 1000,
}
@ -658,82 +661,82 @@ func init() {
func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) }
var fileDescriptor_555bd8c177793206 = []byte{
// 1222 bytes of a gzipped FileDescriptorProto
// 1231 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x55, 0xdb, 0x6e, 0xdb, 0xc6,
0x16, 0x8d, 0x2e, 0xb6, 0xcc, 0x2d, 0x45, 0x1e, 0x8f, 0x6f, 0x3a, 0xe7, 0xf8, 0x14, 0x81, 0x9f,
0x02, 0x03, 0xb1, 0x8b, 0x16, 0x68, 0x9f, 0x02, 0x54, 0x26, 0x47, 0x36, 0x11, 0x8a, 0x54, 0x86,
0x54, 0x9a, 0xb4, 0x0f, 0x04, 0x25, 0x4d, 0x64, 0x56, 0x94, 0xa8, 0x72, 0x46, 0x49, 0x94, 0xaf,
0x68, 0x03, 0xf4, 0x2f, 0xda, 0xa2, 0xf7, 0xf6, 0x13, 0x7a, 0x7f, 0xee, 0x27, 0xf4, 0x03, 0x7a,
0x43, 0xfb, 0x52, 0xcc, 0x90, 0x94, 0x88, 0x22, 0x7d, 0xe3, 0x5e, 0x7b, 0xf6, 0x9a, 0xbd, 0xd6,
0xec, 0xe1, 0x40, 0x63, 0x18, 0x4f, 0xa7, 0xf1, 0xec, 0x74, 0x9e, 0xc4, 0x22, 0xc6, 0xbb, 0xd3,
0x30, 0x7a, 0xb4, 0xe0, 0x69, 0x74, 0x9a, 0xa6, 0x8e, 0x6b, 0xb0, 0x41, 0xa6, 0x73, 0xb1, 0x3c,
0xf6, 0x61, 0xd3, 0x15, 0x81, 0x58, 0x70, 0x7c, 0x1b, 0x80, 0x25, 0x49, 0x9c, 0xf8, 0xc3, 0x78,
0xc4, 0x5a, 0xa5, 0x1b, 0xa5, 0x9b, 0xcd, 0x97, 0x5e, 0x38, 0x7d, 0x4e, 0xf1, 0x29, 0x91, 0xcb,
0xf4, 0x78, 0xc4, 0xa8, 0xc6, 0xf2, 0x4f, 0x7c, 0x00, 0x9b, 0x09, 0x0b, 0x78, 0x3c, 0x6b, 0x95,
0x6f, 0x94, 0x6e, 0x6a, 0x34, 0x8b, 0x8e, 0x5f, 0x81, 0xc6, 0x1d, 0xb6, 0xbc, 0x17, 0x44, 0x0b,
0xd6, 0x0b, 0xc2, 0x04, 0x23, 0xa8, 0x4c, 0xd8, 0x52, 0xf1, 0x6b, 0x54, 0x7e, 0xe2, 0x3d, 0xd8,
0x78, 0x24, 0xd3, 0x59, 0x61, 0x1a, 0x1c, 0x1f, 0x41, 0xf5, 0x3c, 0x8a, 0x07, 0xeb, 0xac, 0xac,
0x68, 0xe4, 0xd9, 0x5b, 0x50, 0x6b, 0x8f, 0x46, 0x09, 0xe3, 0x1c, 0x37, 0xa1, 0x1c, 0xce, 0x33,
0xbe, 0x72, 0x38, 0xc7, 0x18, 0xaa, 0xf3, 0x38, 0x11, 0x8a, 0xad, 0x42, 0xd5, 0xf7, 0xf1, 0xb3,
0x12, 0xd4, 0xba, 0x7c, 0x7c, 0x1e, 0x70, 0x86, 0x5f, 0x85, 0xad, 0x29, 0x1f, 0xfb, 0x62, 0x39,
0xcf, 0x55, 0x1e, 0x3d, 0x57, 0x65, 0x97, 0x8f, 0xbd, 0xe5, 0x9c, 0xd1, 0xda, 0x34, 0xfd, 0x90,
0x9d, 0x4c, 0xf9, 0xd8, 0x34, 0x32, 0xe6, 0x34, 0xc0, 0x47, 0xa0, 0x89, 0x70, 0xca, 0xb8, 0x08,
0xa6, 0xf3, 0x56, 0xe5, 0x46, 0xe9, 0x66, 0x95, 0xae, 0x01, 0xfc, 0x5f, 0xd8, 0xe2, 0xf1, 0x22,
0x19, 0x32, 0xd3, 0x68, 0x55, 0x55, 0xd9, 0x2a, 0x3e, 0xbe, 0x0d, 0x5a, 0x97, 0x8f, 0x2f, 0x59,
0x30, 0x62, 0x09, 0x7e, 0x11, 0xaa, 0x83, 0x80, 0xa7, 0x1d, 0xd5, 0xff, 0xbd, 0x23, 0xa9, 0x80,
0xaa, 0x95, 0x27, 0x5f, 0x55, 0x41, 0x5b, 0x9d, 0x04, 0xae, 0x43, 0xcd, 0xed, 0xeb, 0x3a, 0x71,
0x5d, 0x74, 0x0d, 0xef, 0x01, 0xea, 0xdb, 0xe4, 0x7e, 0x8f, 0xe8, 0x1e, 0x31, 0x7c, 0x42, 0xa9,
0x43, 0x51, 0x09, 0x63, 0x68, 0xea, 0x8e, 0x6d, 0x13, 0xdd, 0xf3, 0x3b, 0x6d, 0xd3, 0x22, 0x06,
0x2a, 0xe3, 0x7d, 0xd8, 0xe9, 0x11, 0xda, 0x35, 0x5d, 0xd7, 0x74, 0x6c, 0xdf, 0x20, 0xb6, 0x49,
0x0c, 0x54, 0xc1, 0xff, 0x81, 0x7d, 0xdd, 0xb1, 0x2c, 0xa2, 0x7b, 0x12, 0xb6, 0x1d, 0xcf, 0x27,
0xf7, 0x4d, 0xd7, 0x73, 0x51, 0x55, 0x72, 0x9b, 0x96, 0x45, 0x2e, 0xda, 0x96, 0xdf, 0xa6, 0x17,
0xfd, 0x2e, 0xb1, 0x3d, 0xb4, 0x21, 0x79, 0x72, 0xd4, 0x30, 0xbb, 0xc4, 0x96, 0x74, 0xa8, 0x86,
0x0f, 0x00, 0xe7, 0xb0, 0x69, 0x1b, 0xe4, 0xbe, 0xef, 0x3d, 0xe8, 0x11, 0xb4, 0x85, 0xff, 0x07,
0x87, 0x39, 0x5e, 0xdc, 0xa7, 0xdd, 0x25, 0x48, 0xc3, 0x08, 0x1a, 0x79, 0xd2, 0x73, 0x7a, 0x77,
0x10, 0x14, 0xd9, 0xa9, 0xf3, 0x3a, 0x25, 0xba, 0x43, 0x0d, 0x54, 0x2f, 0xc2, 0xf7, 0x88, 0xee,
0x39, 0xd4, 0x37, 0x0d, 0xd4, 0x90, 0xcd, 0xe7, 0xb0, 0x4b, 0xda, 0x54, 0xbf, 0xf4, 0x29, 0x71,
0xfb, 0x96, 0x87, 0xae, 0x4b, 0x0b, 0x3a, 0xa6, 0x45, 0x94, 0xa2, 0x8e, 0xd3, 0xb7, 0x0d, 0xd4,
0xc4, 0xdb, 0x50, 0xef, 0x12, 0xaf, 0x9d, 0x7b, 0xb2, 0x2d, 0xf7, 0xd7, 0xdb, 0xfa, 0x25, 0xc9,
0x11, 0x84, 0x5b, 0xb0, 0xa7, 0xb7, 0x6d, 0x59, 0xa4, 0x53, 0xd2, 0xf6, 0x88, 0xdf, 0x71, 0x2c,
0x83, 0x50, 0xb4, 0x23, 0x05, 0xfe, 0x23, 0x63, 0x5a, 0x04, 0xe1, 0x42, 0x85, 0x41, 0x2c, 0xb2,
0xae, 0xd8, 0x2d, 0x54, 0xe4, 0x19, 0x59, 0xb1, 0x27, 0xc5, 0x9c, 0xf7, 0x4d, 0xcb, 0xc8, 0x8c,
0x4a, 0x0f, 0x6d, 0x1f, 0xef, 0xc0, 0xf5, 0x5c, 0x8c, 0x6d, 0x99, 0xae, 0x87, 0x0e, 0xf0, 0x21,
0xec, 0xe6, 0x50, 0x97, 0x78, 0xd4, 0xd4, 0x53, 0x57, 0x0f, 0xe5, 0x5a, 0xa7, 0xef, 0xf9, 0x4e,
0xc7, 0xef, 0x92, 0xae, 0x43, 0x1f, 0xa0, 0x16, 0xde, 0x83, 0x6d, 0xc3, 0xf0, 0x29, 0xb9, 0xdb,
0x27, 0xae, 0xe7, 0xd3, 0xb6, 0x4e, 0xd0, 0xcf, 0xb5, 0x93, 0x37, 0x01, 0xcc, 0xd9, 0x88, 0x3d,
0x91, 0x37, 0x9f, 0xe1, 0x2d, 0xa8, 0xda, 0x8e, 0x4d, 0xd0, 0x35, 0xdc, 0x80, 0xad, 0xbe, 0x6d,
0xba, 0x6e, 0x9f, 0x18, 0xa8, 0x84, 0x9b, 0x00, 0xa6, 0xdd, 0xa3, 0xce, 0x05, 0x95, 0x53, 0x55,
0x96, 0xd9, 0x8e, 0x69, 0x9b, 0xee, 0xa5, 0x1a, 0x11, 0x80, 0xcd, 0xcc, 0x9f, 0xaa, 0x1c, 0xbe,
0x54, 0x8c, 0x81, 0x36, 0x4e, 0x62, 0x68, 0xb8, 0x6c, 0x3c, 0x65, 0x33, 0x91, 0xd2, 0x6f, 0x43,
0x3d, 0x8b, 0xed, 0x78, 0xc6, 0xd0, 0x35, 0xbc, 0x0b, 0xdb, 0x2b, 0x40, 0x90, 0x27, 0x21, 0x17,
0xe9, 0x70, 0x66, 0xe0, 0x45, 0x12, 0x3f, 0x0e, 0x67, 0x63, 0x54, 0x96, 0x7a, 0x72, 0x26, 0x16,
0x44, 0x6c, 0x84, 0x2a, 0x85, 0x65, 0x9d, 0x68, 0xc1, 0xaf, 0xd8, 0x08, 0x55, 0x4f, 0xde, 0xdb,
0x54, 0x97, 0x5b, 0xdd, 0x51, 0x0d, 0x36, 0x26, 0xd9, 0x36, 0xfb, 0xb0, 0x33, 0xd1, 0x13, 0x16,
0x08, 0xa6, 0xc7, 0x51, 0xc4, 0x86, 0x22, 0x8c, 0x67, 0x68, 0x24, 0x77, 0x9f, 0x18, 0x49, 0x3c,
0x2f, 0x80, 0x4c, 0xd2, 0x4e, 0x2e, 0x03, 0x5e, 0xc0, 0x1e, 0x4a, 0x9b, 0x27, 0x06, 0xe3, 0xc3,
0x24, 0x1c, 0x14, 0x19, 0xc6, 0xf2, 0x06, 0x4c, 0xdc, 0xab, 0xf8, 0xf1, 0x1a, 0xe4, 0xe8, 0x4a,
0x51, 0x5c, 0x30, 0xe1, 0x2e, 0xb9, 0x1e, 0xcf, 0x1e, 0x86, 0x63, 0x8e, 0x42, 0xb5, 0x97, 0x15,
0x07, 0xa3, 0x42, 0xf9, 0x5b, 0x72, 0x00, 0x26, 0x94, 0x45, 0x2c, 0xe0, 0x45, 0xda, 0x09, 0xde,
0x07, 0x94, 0xf5, 0xdb, 0x0b, 0x12, 0x11, 0x2a, 0xf4, 0xeb, 0x12, 0xde, 0x85, 0xa6, 0xea, 0x77,
0x0d, 0x7e, 0x23, 0xdd, 0xba, 0x2e, 0xfb, 0x5d, 0x63, 0xdf, 0x96, 0xf0, 0x21, 0xe0, 0x55, 0xbf,
0xeb, 0xc4, 0x77, 0x25, 0x39, 0x03, 0xaa, 0xdf, 0x15, 0xc8, 0xd1, 0xf7, 0x29, 0xaf, 0xec, 0x6d,
0xbd, 0xf4, 0x87, 0x12, 0x3e, 0x80, 0x9d, 0xbc, 0xb7, 0x35, 0xfe, 0x63, 0x09, 0xef, 0x40, 0x43,
0x51, 0x64, 0xde, 0xa3, 0x3f, 0x4b, 0xaa, 0xdd, 0x7c, 0xbb, 0x1c, 0xfe, 0x2b, 0x5d, 0x99, 0xaa,
0x50, 0x13, 0x86, 0xde, 0x2f, 0xa7, 0x0a, 0xb2, 0x95, 0x29, 0xf8, 0x41, 0x19, 0x6f, 0x03, 0x28,
0x59, 0x29, 0xf0, 0xa1, 0x9c, 0xae, 0xda, 0xc4, 0x9c, 0x71, 0x96, 0x08, 0xf4, 0x4e, 0x45, 0x45,
0x06, 0x8b, 0x98, 0x60, 0xe8, 0xdd, 0x0a, 0xae, 0xc3, 0xe6, 0x44, 0x9d, 0x37, 0x7a, 0x96, 0xa6,
0x5c, 0x16, 0x24, 0xc3, 0x2b, 0xf4, 0x4b, 0x45, 0x39, 0x91, 0x46, 0x94, 0xf1, 0x45, 0x24, 0xd0,
0xaf, 0x15, 0xb5, 0xe1, 0x05, 0x13, 0xeb, 0x11, 0x47, 0xbf, 0x55, 0xf0, 0xff, 0xa1, 0x25, 0xc1,
0xb5, 0xe5, 0x32, 0x13, 0x72, 0x11, 0x0e, 0x39, 0xfa, 0xbd, 0x82, 0x8f, 0xe0, 0x50, 0xa6, 0x57,
0xaa, 0x0b, 0xd9, 0x3f, 0x2a, 0xa9, 0xfe, 0x54, 0xa4, 0x39, 0x7b, 0x18, 0xa3, 0x9f, 0xaa, 0xb8,
0x09, 0xda, 0xc4, 0x0b, 0xa7, 0xcc, 0x0b, 0x87, 0x13, 0xf4, 0x91, 0xa6, 0x5c, 0xbe, 0xbb, 0x60,
0xc9, 0xd2, 0x8e, 0x47, 0x4c, 0x56, 0x73, 0xf4, 0xb1, 0xa6, 0x64, 0x4a, 0x97, 0x53, 0x99, 0x9f,
0xa4, 0x00, 0x65, 0x6f, 0x2f, 0x18, 0x17, 0xa6, 0x81, 0x3e, 0x95, 0x7f, 0xbb, 0x7a, 0x0e, 0x78,
0xae, 0x83, 0x3e, 0xd3, 0x94, 0xb3, 0xed, 0x28, 0x8a, 0x87, 0x81, 0x58, 0x39, 0xfb, 0xb9, 0xa6,
0xce, 0xb7, 0x70, 0xb1, 0xb2, 0xe6, 0xbe, 0xd0, 0xd4, 0xa1, 0x15, 0x2f, 0x85, 0x21, 0xe7, 0xff,
0x4b, 0xed, 0xfc, 0xfc, 0x8d, 0xd7, 0xc6, 0xa1, 0xb8, 0x5a, 0x0c, 0xe4, 0xfb, 0x71, 0xf6, 0x34,
0x8c, 0xa2, 0xf0, 0xa9, 0x60, 0xc3, 0xab, 0xb3, 0xf4, 0x6d, 0xb9, 0x35, 0x0a, 0xb9, 0x48, 0xc2,
0xc1, 0x42, 0xb0, 0xd1, 0x59, 0x38, 0x13, 0x2c, 0x99, 0x05, 0xd1, 0x99, 0x7a, 0x70, 0xce, 0xd2,
0x07, 0x67, 0x3e, 0x18, 0x6c, 0xaa, 0xf8, 0xe5, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xb5, 0x3d,
0x8c, 0x4b, 0x53, 0x08, 0x00, 0x00,
0x16, 0x8d, 0x2e, 0xb6, 0xcc, 0x2d, 0x45, 0x1e, 0x8f, 0x6f, 0xca, 0x39, 0x3e, 0x07, 0x81, 0x9f,
0x02, 0x03, 0xb1, 0x0f, 0x4e, 0x81, 0xf6, 0x29, 0x40, 0x65, 0x72, 0x64, 0x13, 0xa1, 0x48, 0x65,
0x48, 0xa5, 0x49, 0xfb, 0x40, 0x50, 0xd2, 0x44, 0x66, 0x45, 0x89, 0x2a, 0x67, 0x94, 0x44, 0xf9,
0x8a, 0x36, 0x40, 0xff, 0xa2, 0x2d, 0x7a, 0xef, 0x2f, 0xf4, 0x96, 0x3e, 0xf7, 0x13, 0xfa, 0x01,
0xbd, 0xa1, 0x7d, 0x29, 0x66, 0x48, 0x4a, 0x44, 0x91, 0xbe, 0x71, 0xaf, 0x3d, 0x7b, 0xcd, 0x5e,
0x6b, 0xf6, 0x70, 0xa0, 0x31, 0x8c, 0xa7, 0xd3, 0x78, 0x76, 0x3a, 0x4f, 0x62, 0x11, 0xe3, 0xdd,
0x69, 0x18, 0x3d, 0x5e, 0xf0, 0x34, 0x3a, 0x4d, 0x53, 0xc7, 0x35, 0xd8, 0x20, 0xd3, 0xb9, 0x58,
0x1e, 0xfb, 0xb0, 0xe9, 0x8a, 0x40, 0x2c, 0x38, 0xbe, 0x03, 0xc0, 0x92, 0x24, 0x4e, 0xfc, 0x61,
0x3c, 0x62, 0xad, 0xd2, 0xcd, 0xd2, 0xad, 0xe6, 0xff, 0xff, 0x7b, 0xfa, 0x92, 0xe2, 0x53, 0x22,
0x97, 0xe9, 0xf1, 0x88, 0x51, 0x8d, 0xe5, 0x9f, 0xf8, 0x00, 0x36, 0x13, 0x16, 0xf0, 0x78, 0xd6,
0x2a, 0xdf, 0x2c, 0xdd, 0xd2, 0x68, 0x16, 0x1d, 0xbf, 0x0a, 0x8d, 0xbb, 0x6c, 0x79, 0x3f, 0x88,
0x16, 0xac, 0x17, 0x84, 0x09, 0x46, 0x50, 0x99, 0xb0, 0xa5, 0xe2, 0xd7, 0xa8, 0xfc, 0xc4, 0x7b,
0xb0, 0xf1, 0x58, 0xa6, 0xb3, 0xc2, 0x34, 0x38, 0x3e, 0x82, 0xea, 0x79, 0x14, 0x0f, 0xd6, 0x59,
0x59, 0xd1, 0xc8, 0xb3, 0xb7, 0xa1, 0xd6, 0x1e, 0x8d, 0x12, 0xc6, 0x39, 0x6e, 0x42, 0x39, 0x9c,
0x67, 0x7c, 0xe5, 0x70, 0x8e, 0x31, 0x54, 0xe7, 0x71, 0x22, 0x14, 0x5b, 0x85, 0xaa, 0xef, 0xe3,
0xe7, 0x25, 0xa8, 0x75, 0xf9, 0xf8, 0x3c, 0xe0, 0x0c, 0xbf, 0x06, 0x5b, 0x53, 0x3e, 0xf6, 0xc5,
0x72, 0x9e, 0xab, 0x3c, 0x7a, 0xa9, 0xca, 0x2e, 0x1f, 0x7b, 0xcb, 0x39, 0xa3, 0xb5, 0x69, 0xfa,
0x21, 0x3b, 0x99, 0xf2, 0xb1, 0x69, 0x64, 0xcc, 0x69, 0x80, 0x8f, 0x40, 0x13, 0xe1, 0x94, 0x71,
0x11, 0x4c, 0xe7, 0xad, 0xca, 0xcd, 0xd2, 0xad, 0x2a, 0x5d, 0x03, 0xf8, 0x5f, 0xb0, 0xc5, 0xe3,
0x45, 0x32, 0x64, 0xa6, 0xd1, 0xaa, 0xaa, 0xb2, 0x55, 0x7c, 0x7c, 0x07, 0xb4, 0x2e, 0x1f, 0x5f,
0xb2, 0x60, 0xc4, 0x12, 0xfc, 0x3f, 0xa8, 0x0e, 0x02, 0x9e, 0x76, 0x54, 0xff, 0xe7, 0x8e, 0xa4,
0x02, 0xaa, 0x56, 0x9e, 0xbc, 0xa8, 0x82, 0xb6, 0x3a, 0x09, 0x5c, 0x87, 0x9a, 0xdb, 0xd7, 0x75,
0xe2, 0xba, 0xe8, 0x1a, 0xde, 0x03, 0xd4, 0xb7, 0xc9, 0x83, 0x1e, 0xd1, 0x3d, 0x62, 0xf8, 0x84,
0x52, 0x87, 0xa2, 0x12, 0xc6, 0xd0, 0xd4, 0x1d, 0xdb, 0x26, 0xba, 0xe7, 0x77, 0xda, 0xa6, 0x45,
0x0c, 0x54, 0xc6, 0xfb, 0xb0, 0xd3, 0x23, 0xb4, 0x6b, 0xba, 0xae, 0xe9, 0xd8, 0xbe, 0x41, 0x6c,
0x93, 0x18, 0xa8, 0x82, 0x6f, 0xc0, 0xbe, 0xee, 0x58, 0x16, 0xd1, 0x3d, 0x09, 0xdb, 0x8e, 0xe7,
0x93, 0x07, 0xa6, 0xeb, 0xb9, 0xa8, 0x2a, 0xb9, 0x4d, 0xcb, 0x22, 0x17, 0x6d, 0xcb, 0x6f, 0xd3,
0x8b, 0x7e, 0x97, 0xd8, 0x1e, 0xda, 0x90, 0x3c, 0x39, 0x6a, 0x98, 0x5d, 0x62, 0x4b, 0x3a, 0x54,
0xc3, 0x07, 0x80, 0x73, 0xd8, 0xb4, 0x0d, 0xf2, 0xc0, 0xf7, 0x1e, 0xf6, 0x08, 0xda, 0xc2, 0xff,
0x86, 0xc3, 0x1c, 0x2f, 0xee, 0xd3, 0xee, 0x12, 0xa4, 0x61, 0x04, 0x8d, 0x3c, 0xe9, 0x39, 0xbd,
0xbb, 0x08, 0x8a, 0xec, 0xd4, 0x79, 0x83, 0x12, 0xdd, 0xa1, 0x06, 0xaa, 0x17, 0xe1, 0xfb, 0x44,
0xf7, 0x1c, 0xea, 0x9b, 0x06, 0x6a, 0xc8, 0xe6, 0x73, 0xd8, 0x25, 0x6d, 0xaa, 0x5f, 0xfa, 0x94,
0xb8, 0x7d, 0xcb, 0x43, 0xd7, 0xa5, 0x05, 0x1d, 0xd3, 0x22, 0x4a, 0x51, 0xc7, 0xe9, 0xdb, 0x06,
0x6a, 0xe2, 0x6d, 0xa8, 0x77, 0x89, 0xd7, 0xce, 0x3d, 0xd9, 0x96, 0xfb, 0xeb, 0x6d, 0xfd, 0x92,
0xe4, 0x08, 0xc2, 0x2d, 0xd8, 0xd3, 0xdb, 0xb6, 0x2c, 0xd2, 0x29, 0x69, 0x7b, 0xc4, 0xef, 0x38,
0x96, 0x41, 0x28, 0xda, 0x91, 0x02, 0xff, 0x96, 0x31, 0x2d, 0x82, 0x70, 0xa1, 0xc2, 0x20, 0x16,
0x59, 0x57, 0xec, 0x16, 0x2a, 0xf2, 0x8c, 0xac, 0xd8, 0x93, 0x62, 0xce, 0xfb, 0xa6, 0x65, 0x64,
0x46, 0xa5, 0x87, 0xb6, 0x8f, 0x77, 0xe0, 0x7a, 0x2e, 0xc6, 0xb6, 0x4c, 0xd7, 0x43, 0x07, 0xf8,
0x10, 0x76, 0x73, 0xa8, 0x4b, 0x3c, 0x6a, 0xea, 0xa9, 0xab, 0x87, 0x72, 0xad, 0xd3, 0xf7, 0x7c,
0xa7, 0xe3, 0x77, 0x49, 0xd7, 0xa1, 0x0f, 0x51, 0x0b, 0xef, 0xc2, 0x76, 0xca, 0xb7, 0x3a, 0x43,
0x74, 0x03, 0xef, 0xc1, 0xb6, 0x61, 0xf8, 0x94, 0xdc, 0xeb, 0x13, 0xd7, 0xf3, 0x69, 0x5b, 0x27,
0xe8, 0xa7, 0xda, 0xc9, 0x5b, 0x00, 0xe6, 0x6c, 0xc4, 0x9e, 0xca, 0xdf, 0x01, 0xc3, 0x5b, 0x50,
0xb5, 0x1d, 0x9b, 0xa0, 0x6b, 0xb8, 0x01, 0x5b, 0x7d, 0xdb, 0x74, 0xdd, 0x3e, 0x31, 0x50, 0x09,
0x37, 0x01, 0x4c, 0xbb, 0x47, 0x9d, 0x0b, 0x2a, 0x47, 0xad, 0x2c, 0xb3, 0x1d, 0xd3, 0x36, 0xdd,
0x4b, 0x35, 0x37, 0x00, 0x9b, 0x99, 0x69, 0x55, 0x39, 0x91, 0xa9, 0x42, 0x03, 0x6d, 0x9c, 0xc4,
0xd0, 0x70, 0xd9, 0x78, 0xca, 0x66, 0x22, 0xa5, 0xdf, 0x86, 0x7a, 0x16, 0xdb, 0xf1, 0x8c, 0xa1,
0x6b, 0xb2, 0xd1, 0x15, 0x20, 0xc8, 0xd3, 0x90, 0x8b, 0x74, 0x62, 0x33, 0xf0, 0x22, 0x89, 0x9f,
0x84, 0xb3, 0x31, 0x2a, 0x4b, 0x91, 0x39, 0x13, 0x0b, 0x22, 0x36, 0x42, 0x95, 0xc2, 0xb2, 0x4e,
0xb4, 0xe0, 0x57, 0x6c, 0x84, 0xaa, 0x27, 0xef, 0x6f, 0xaa, 0x1b, 0xaf, 0x2e, 0xae, 0x06, 0x1b,
0x93, 0x6c, 0x9b, 0x7d, 0xd8, 0x99, 0xe8, 0x09, 0x0b, 0x04, 0xd3, 0xe3, 0x28, 0x62, 0x43, 0x11,
0xc6, 0x33, 0x34, 0x92, 0xbb, 0x4f, 0x8c, 0x24, 0x9e, 0x17, 0x40, 0x26, 0x69, 0x27, 0x97, 0x01,
0x2f, 0x60, 0x8f, 0xa4, 0xf7, 0x13, 0x83, 0xf1, 0x61, 0x12, 0x0e, 0x8a, 0x0c, 0x63, 0x79, 0x2d,
0x26, 0xee, 0x55, 0xfc, 0x64, 0x0d, 0x72, 0x74, 0xa5, 0x28, 0x2e, 0x98, 0x70, 0x97, 0x5c, 0x8f,
0x67, 0x8f, 0xc2, 0x31, 0x47, 0xa1, 0xda, 0xcb, 0x8a, 0x83, 0x51, 0xa1, 0xfc, 0x6d, 0x39, 0x15,
0x13, 0xca, 0x22, 0x16, 0xf0, 0x22, 0xed, 0x04, 0xef, 0x03, 0xca, 0xfa, 0xed, 0x05, 0x89, 0x08,
0x15, 0xfa, 0x75, 0x09, 0xef, 0x42, 0x53, 0xf5, 0xbb, 0x06, 0xbf, 0x91, 0x6e, 0x5d, 0x97, 0xfd,
0xae, 0xb1, 0x6f, 0x4b, 0xf8, 0x10, 0xf0, 0xaa, 0xdf, 0x75, 0xe2, 0xbb, 0x92, 0x9c, 0x01, 0xd5,
0xef, 0x0a, 0xe4, 0xe8, 0xfb, 0x94, 0x57, 0xf6, 0xb6, 0x5e, 0xfa, 0xa2, 0x84, 0x0f, 0x60, 0x27,
0xef, 0x6d, 0x8d, 0xff, 0x50, 0xc2, 0x3b, 0xd0, 0x50, 0x14, 0x99, 0xf7, 0xe8, 0x8f, 0x92, 0x6a,
0x37, 0xdf, 0x2e, 0x87, 0xff, 0x4c, 0x57, 0xa6, 0x2a, 0xd4, 0x84, 0xa1, 0x0f, 0xca, 0xa9, 0x82,
0x6c, 0x65, 0x0a, 0x7e, 0x58, 0xc6, 0xdb, 0x00, 0x4a, 0x56, 0x0a, 0x7c, 0x24, 0xa7, 0xab, 0x36,
0x31, 0x67, 0x9c, 0x25, 0x02, 0xbd, 0x5b, 0x51, 0x91, 0xc1, 0x22, 0x26, 0x18, 0x7a, 0xaf, 0x82,
0xeb, 0xb0, 0x39, 0x51, 0xe7, 0x8d, 0x9e, 0xa7, 0x29, 0x97, 0x05, 0xc9, 0xf0, 0x0a, 0xfd, 0x5c,
0x51, 0x4e, 0xa4, 0x11, 0x65, 0x7c, 0x11, 0x09, 0xf4, 0x4b, 0x45, 0x6d, 0x78, 0xc1, 0xc4, 0x7a,
0xc4, 0xd1, 0xaf, 0x15, 0xfc, 0x1f, 0x68, 0x49, 0x70, 0x6d, 0xb9, 0xcc, 0x84, 0x5c, 0x84, 0x43,
0x8e, 0x7e, 0xab, 0xe0, 0x23, 0x38, 0x94, 0xe9, 0x95, 0xea, 0x42, 0xf6, 0xf7, 0x4a, 0xaa, 0x3f,
0x15, 0x69, 0xce, 0x1e, 0xc5, 0xe8, 0xc7, 0x2a, 0x6e, 0x82, 0x36, 0xf1, 0xc2, 0x29, 0xf3, 0xc2,
0xe1, 0x04, 0x7d, 0xac, 0x29, 0x97, 0xef, 0x2d, 0x58, 0xb2, 0xb4, 0xe3, 0x11, 0x93, 0xd5, 0x1c,
0x7d, 0xa2, 0x29, 0x99, 0xd2, 0xe5, 0x54, 0xe6, 0xa7, 0x29, 0x40, 0xd9, 0x3b, 0x0b, 0xc6, 0x85,
0x69, 0xa0, 0xcf, 0xe4, 0x2f, 0xb0, 0x9e, 0x03, 0x9e, 0xeb, 0xa0, 0xcf, 0x35, 0xe5, 0x6c, 0x3b,
0x8a, 0xe2, 0x61, 0x20, 0x56, 0xce, 0x7e, 0xa1, 0xa9, 0xf3, 0x2d, 0x5c, 0xac, 0xac, 0xb9, 0x2f,
0x35, 0x75, 0x68, 0xc5, 0x4b, 0x61, 0xc8, 0xf9, 0xff, 0x4a, 0x3b, 0x3f, 0x7f, 0xf3, 0xf5, 0x71,
0x28, 0xae, 0x16, 0x03, 0xf9, 0xa8, 0x9c, 0x3d, 0x0b, 0xa3, 0x28, 0x7c, 0x26, 0xd8, 0xf0, 0xea,
0x2c, 0x7d, 0x70, 0x6e, 0x8f, 0x42, 0x2e, 0x92, 0x70, 0xb0, 0x10, 0x6c, 0x74, 0x16, 0xce, 0x04,
0x4b, 0x66, 0x41, 0x74, 0xa6, 0x5e, 0xa1, 0xb3, 0xf4, 0x15, 0x9a, 0x0f, 0x06, 0x9b, 0x2a, 0x7e,
0xe5, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x85, 0xb7, 0x70, 0x68, 0x08, 0x00, 0x00,
}

2
scripts/run_go_unittest.sh
View File

@ -20,7 +20,7 @@ go test -race -cover "${MILVUS_DIR}/kv/..." "${MILVUS_DIR}/tso/..." "${MILVUS_DI
go test -race -cover "${MILVUS_DIR}/datanode/..." -failfast
go test -race -cover "${MILVUS_DIR}/indexnode/..." -failfast
#go test -race -cover "${MILVUS_DIR}/msgstream/..." "${MILVUS_DIR}/querynode/..." "${MILVUS_DIR}/storage" "${MILVUS_DIR}/util/..." -failfast
go test -race -cover "${MILVUS_DIR}/querynode/..." -failfast
go test -cover "${MILVUS_DIR}/querynode/..." -failfast
#go test -race -cover "${MILVUS_DIR}/msgstream/..." "${MILVUS_DIR}/storage" "${MILVUS_DIR}/util/..." -failfast
#go test -race -cover "${MILVUS_DIR}/msgstream/..." "${MILVUS_DIR}/util/..." -failfast
go test -race -cover "${MILVUS_DIR}/msgstream/..." -failfast