mirror of
https://gitee.com/milvus-io/milvus.git
synced 2026-01-07 19:31:51 +08:00
Save binlog path in SegmentInfo (#6590)
issue: #6589 Signed-off-by: sunby <bingyi.sun@zilliz.com>
This commit is contained in:
sunby
GitHub
parent
648d22ee40
commit
4f7c3e7d3a
@ -1,183 +0,0 @@
|
||||
package datacoord
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"path"
|
||||
"strconv"
|
||||
|
||||
"github.com/golang/protobuf/proto"
|
||||
"github.com/milvus-io/milvus/internal/proto/commonpb"
|
||||
"github.com/milvus-io/milvus/internal/proto/datapb"
|
||||
"github.com/milvus-io/milvus/internal/proto/internalpb"
|
||||
)
|
||||
|
||||
// binlog helper functions persisting binlog paths into kv storage.
|
||||
// migrated from datanode[Author XuanYang-cn]
|
||||
// ddl binlog etcd meta key:
|
||||
// ${prefix}/${collectionID}/${idx}
|
||||
// segment binlog etcd meta key:
|
||||
// ${prefix}/${segmentID}/${fieldID}/${idx}
|
||||
|
||||
// genKey gives a valid key string for lists of UniqueIDs:
|
||||
// if alloc is true, the returned keys will have a generated-unique ID at the end.
|
||||
// if alloc is false, the returned keys will only consist of provided ids.
|
||||
func (s *Server) genKey(alloc bool, ids ...UniqueID) (key string, err error) {
|
||||
if alloc {
|
||||
idx, err := s.allocator.allocID()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
ids = append(ids, idx)
|
||||
}
|
||||
|
||||
idStr := make([]string, len(ids))
|
||||
for _, id := range ids {
|
||||
idStr = append(idStr, strconv.FormatInt(id, 10))
|
||||
}
|
||||
|
||||
key = path.Join(idStr...)
|
||||
return key, nil
|
||||
}
|
||||
|
||||
var (
|
||||
errNilKvClient = errors.New("kv client not initialized")
|
||||
errNilID2Paths = errors.New("nil ID2PathList")
|
||||
errNilSegmentInfo = errors.New("nil segment info")
|
||||
)
|
||||
|
||||
//SaveBinLogMetaTxn saves segment-field2Path, collection-tsPath into kv store in transcation
|
||||
func (s *Server) SaveBinLogMetaTxn(meta map[string]string) error {
|
||||
if s.kvClient == nil {
|
||||
return errNilKvClient
|
||||
}
|
||||
return s.kvClient.MultiSave(meta)
|
||||
}
|
||||
|
||||
// prepareField2PathMeta parses fields2Paths ID2PathList
|
||||
// into key-value for kv store
|
||||
func (s *Server) prepareField2PathMeta(segID UniqueID, field2Paths *datapb.ID2PathList) (result map[string]string, err error) {
|
||||
if field2Paths == nil {
|
||||
return nil, errNilID2Paths
|
||||
}
|
||||
result = make(map[string]string, len(field2Paths.GetPaths()))
|
||||
fieldID := field2Paths.GetID()
|
||||
var key string
|
||||
for _, p := range field2Paths.GetPaths() {
|
||||
key, err = s.genKey(true, segID, fieldID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
binlogPath := proto.MarshalTextString(&datapb.SegmentFieldBinlogMeta{
|
||||
FieldID: fieldID,
|
||||
BinlogPath: p,
|
||||
})
|
||||
|
||||
result[path.Join(Params.SegmentBinlogSubPath, key)] = binlogPath
|
||||
}
|
||||
return result, err
|
||||
}
|
||||
|
||||
// getFieldBinlogMeta querys field binlog meta from kv store
|
||||
func (s *Server) getFieldBinlogMeta(segmentID UniqueID,
|
||||
fieldID UniqueID) (metas []*datapb.SegmentFieldBinlogMeta, err error) {
|
||||
|
||||
prefix, err := s.genKey(false, segmentID, fieldID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
_, vs, err := s.kvClient.LoadWithPrefix(path.Join(Params.SegmentBinlogSubPath, prefix))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
for _, blob := range vs {
|
||||
m := &datapb.SegmentFieldBinlogMeta{}
|
||||
if err = proto.UnmarshalText(blob, m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
metas = append(metas, m)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// getSegmentBinlogMeta querys segment bin log meta from kv store
|
||||
func (s *Server) getSegmentBinlogMeta(segmentID UniqueID) (metas []*datapb.SegmentFieldBinlogMeta, err error) {
|
||||
|
||||
prefix, err := s.genKey(false, segmentID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
_, vs, err := s.kvClient.LoadWithPrefix(path.Join(Params.SegmentBinlogSubPath, prefix))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
for _, blob := range vs {
|
||||
m := &datapb.SegmentFieldBinlogMeta{}
|
||||
if err = proto.UnmarshalText(blob, m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
metas = append(metas, m)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// GetVChanPositions get vchannel latest postitions with provided dml channel names
|
||||
func (s *Server) GetVChanPositions(vchans []vchannel, isAccurate bool) ([]*datapb.VchannelInfo, error) {
|
||||
if s.kvClient == nil {
|
||||
return nil, errNilKvClient
|
||||
}
|
||||
pairs := make([]*datapb.VchannelInfo, 0, len(vchans))
|
||||
|
||||
for _, vchan := range vchans {
|
||||
segments := s.meta.GetSegmentsByChannel(vchan.DmlChannel)
|
||||
flushedSegmentIDs := make([]UniqueID, 0)
|
||||
unflushed := make([]*datapb.SegmentInfo, 0)
|
||||
var seekPosition *internalpb.MsgPosition
|
||||
var useUnflushedPosition bool
|
||||
for _, s := range segments {
|
||||
if s.State == commonpb.SegmentState_Flushing || s.State == commonpb.SegmentState_Flushed {
|
||||
flushedSegmentIDs = append(flushedSegmentIDs, s.ID)
|
||||
if seekPosition == nil || (!useUnflushedPosition && s.DmlPosition.Timestamp > seekPosition.Timestamp) {
|
||||
seekPosition = s.DmlPosition
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if s.DmlPosition == nil {
|
||||
continue
|
||||
}
|
||||
|
||||
unflushed = append(unflushed, s.SegmentInfo)
|
||||
|
||||
if seekPosition == nil || !useUnflushedPosition || s.DmlPosition.Timestamp < seekPosition.Timestamp {
|
||||
useUnflushedPosition = true
|
||||
if isAccurate {
|
||||
seekPosition = s.DmlPosition
|
||||
} else {
|
||||
seekPosition = s.StartPosition
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pairs = append(pairs, &datapb.VchannelInfo{
|
||||
CollectionID: vchan.CollectionID,
|
||||
ChannelName: vchan.DmlChannel,
|
||||
SeekPosition: seekPosition,
|
||||
UnflushedSegments: unflushed,
|
||||
FlushedSegments: flushedSegmentIDs,
|
||||
})
|
||||
}
|
||||
return pairs, nil
|
||||
}
|
||||
|
||||
func zeroPos(name string) internalpb.MsgPosition {
|
||||
return internalpb.MsgPosition{
|
||||
ChannelName: name,
|
||||
}
|
||||
}
|
||||
@ -22,14 +22,14 @@ type vchannel struct {
|
||||
|
||||
// positionProvider provides vchannel pair related position pairs
|
||||
type positionProvider interface {
|
||||
GetVChanPositions(vchans []vchannel, isAccurate bool) ([]*datapb.VchannelInfo, error)
|
||||
GetVChanPositions(vchans []vchannel, seekFromStartPosition bool) ([]*datapb.VchannelInfo, error)
|
||||
GetDdlChannel() string
|
||||
}
|
||||
|
||||
type dummyPosProvider struct{}
|
||||
|
||||
//GetVChanPositions implements positionProvider
|
||||
func (dp dummyPosProvider) GetVChanPositions(vchans []vchannel, isAccurate bool) ([]*datapb.VchannelInfo, error) {
|
||||
func (dp dummyPosProvider) GetVChanPositions(vchans []vchannel, seekFromStartPosition bool) ([]*datapb.VchannelInfo, error) {
|
||||
pairs := make([]*datapb.VchannelInfo, 0, len(vchans))
|
||||
for _, vchan := range vchans {
|
||||
pairs = append(pairs, &datapb.VchannelInfo{
|
||||
|
||||
@ -3,11 +3,9 @@ package datacoord
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"path"
|
||||
"strconv"
|
||||
"sync/atomic"
|
||||
|
||||
"github.com/golang/protobuf/proto"
|
||||
"github.com/milvus-io/milvus/internal/log"
|
||||
"github.com/milvus-io/milvus/internal/proto/commonpb"
|
||||
"github.com/milvus-io/milvus/internal/proto/datapb"
|
||||
@ -173,27 +171,17 @@ func (s *Server) GetInsertBinlogPaths(ctx context.Context, req *datapb.GetInsert
|
||||
resp.Status.Reason = serverNotServingErrMsg
|
||||
return resp, nil
|
||||
}
|
||||
p := path.Join(Params.SegmentBinlogSubPath, strconv.FormatInt(req.SegmentID, 10)) + "/" // prefix/id/ instead of prefix/id
|
||||
_, values, err := s.kvClient.LoadWithPrefix(p)
|
||||
if err != nil {
|
||||
resp.Status.Reason = err.Error()
|
||||
segment := s.meta.GetSegment(req.GetSegmentID())
|
||||
if segment == nil {
|
||||
resp.Status.Reason = "segment not found"
|
||||
return resp, nil
|
||||
}
|
||||
m := make(map[int64][]string)
|
||||
tMeta := &datapb.SegmentFieldBinlogMeta{}
|
||||
for _, v := range values {
|
||||
if err := proto.UnmarshalText(v, tMeta); err != nil {
|
||||
resp.Status.Reason = fmt.Errorf("DataCoord GetInsertBinlogPaths UnmarshalText datapb.SegmentFieldBinlogMeta err:%w", err).Error()
|
||||
return resp, nil
|
||||
}
|
||||
m[tMeta.FieldID] = append(m[tMeta.FieldID], tMeta.BinlogPath)
|
||||
}
|
||||
|
||||
fids := make([]UniqueID, len(m))
|
||||
paths := make([]*internalpb.StringList, len(m))
|
||||
for k, v := range m {
|
||||
fids = append(fids, k)
|
||||
paths = append(paths, &internalpb.StringList{Values: v})
|
||||
binlogs := segment.GetBinlogs()
|
||||
fids := make([]UniqueID, 0, len(binlogs))
|
||||
paths := make([]*internalpb.StringList, 0, len(binlogs))
|
||||
for _, field := range binlogs {
|
||||
fids = append(fids, field.GetFieldID())
|
||||
paths = append(paths, &internalpb.StringList{Values: field.GetBinlogs()})
|
||||
}
|
||||
resp.Status.ErrorCode = commonpb.ErrorCode_Success
|
||||
resp.FieldIDs = fids
|
||||
@ -279,16 +267,9 @@ func (s *Server) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPath
|
||||
zap.Int64("segmentID", req.GetSegmentID()),
|
||||
zap.Any("checkpoints", req.GetCheckPoints()))
|
||||
|
||||
binlogs, err := s.prepareBinlog(req)
|
||||
if err != nil {
|
||||
log.Error("prepare binlog meta failed", zap.Error(err))
|
||||
resp.Reason = err.Error()
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// set segment to SegmentState_Flushing and save binlogs and checkpoints
|
||||
err = s.meta.SaveBinlogAndCheckPoints(req.GetSegmentID(), req.GetFlushed(),
|
||||
binlogs, req.GetCheckPoints(), req.GetStartPositions())
|
||||
err := s.meta.UpdateFlushSegmentsInfo(req.GetSegmentID(), req.GetFlushed(),
|
||||
req.GetField2BinlogPaths(), req.GetCheckPoints(), req.GetStartPositions())
|
||||
if err != nil {
|
||||
log.Error("save binlog and checkpoints failed",
|
||||
zap.Int64("segmentID", req.GetSegmentID()),
|
||||
@ -297,7 +278,7 @@ func (s *Server) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPath
|
||||
return resp, nil
|
||||
}
|
||||
log.Debug("flush segment with meta", zap.Int64("id", req.SegmentID),
|
||||
zap.Any("meta", binlogs))
|
||||
zap.Any("meta", req.GetField2BinlogPaths()))
|
||||
|
||||
if req.Flushed {
|
||||
s.segmentManager.DropSegment(ctx, req.SegmentID)
|
||||
@ -361,15 +342,10 @@ func (s *Server) GetRecoveryInfo(ctx context.Context, req *datapb.GetRecoveryInf
|
||||
continue
|
||||
}
|
||||
|
||||
meta, err := s.getSegmentBinlogMeta(id)
|
||||
if err != nil {
|
||||
log.Error("get segment binlog meta failed", zap.Int64("segmentID", id))
|
||||
resp.Status.Reason = err.Error()
|
||||
return resp, nil
|
||||
}
|
||||
binlogs := segment.GetBinlogs()
|
||||
field2Binlog := make(map[UniqueID][]string)
|
||||
for _, m := range meta {
|
||||
field2Binlog[m.FieldID] = append(field2Binlog[m.FieldID], m.BinlogPath)
|
||||
for _, field := range binlogs {
|
||||
field2Binlog[field.GetFieldID()] = append(field2Binlog[field.GetFieldID()], field.GetBinlogs()...)
|
||||
}
|
||||
|
||||
for f, paths := range field2Binlog {
|
||||
|
||||
@ -150,43 +150,64 @@ func (m *meta) SetState(segmentID UniqueID, state commonpb.SegmentState) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *meta) SaveBinlogAndCheckPoints(segID UniqueID, flushed bool,
|
||||
binlogs map[string]string, checkpoints []*datapb.CheckPoint,
|
||||
func (m *meta) UpdateFlushSegmentsInfo(segmentID UniqueID, flushed bool,
|
||||
binlogs []*datapb.FieldBinlog, checkpoints []*datapb.CheckPoint,
|
||||
startPositions []*datapb.SegmentStartPosition) error {
|
||||
m.Lock()
|
||||
defer m.Unlock()
|
||||
kv := make(map[string]string)
|
||||
for k, v := range binlogs {
|
||||
kv[k] = v
|
||||
}
|
||||
if flushed {
|
||||
m.segments.SetState(segID, commonpb.SegmentState_Flushing)
|
||||
|
||||
segment := m.segments.GetSegment(segmentID)
|
||||
if segment == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
modSegments := make([]UniqueID, 0)
|
||||
kv := make(map[string]string)
|
||||
modSegments := make(map[UniqueID]struct{})
|
||||
|
||||
if flushed {
|
||||
m.segments.SetState(segmentID, commonpb.SegmentState_Flushing)
|
||||
modSegments[segmentID] = struct{}{}
|
||||
}
|
||||
|
||||
currBinlogs := segment.Clone().SegmentInfo.GetBinlogs()
|
||||
var getFieldBinlogs = func(id UniqueID, binlogs []*datapb.FieldBinlog) *datapb.FieldBinlog {
|
||||
for _, binlog := range binlogs {
|
||||
if id == binlog.GetFieldID() {
|
||||
return binlog
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
for _, tBinlogs := range binlogs {
|
||||
fieldBinlogs := getFieldBinlogs(tBinlogs.GetFieldID(), currBinlogs)
|
||||
if fieldBinlogs == nil {
|
||||
currBinlogs = append(currBinlogs, tBinlogs)
|
||||
} else {
|
||||
fieldBinlogs.Binlogs = append(fieldBinlogs.Binlogs, tBinlogs.Binlogs...)
|
||||
}
|
||||
}
|
||||
m.segments.SetBinlogs(segmentID, currBinlogs)
|
||||
modSegments[segmentID] = struct{}{}
|
||||
|
||||
for _, pos := range startPositions {
|
||||
if len(pos.GetStartPosition().GetMsgID()) != 0 {
|
||||
if len(pos.GetStartPosition().GetMsgID()) == 0 {
|
||||
continue
|
||||
}
|
||||
if segment := m.segments.GetSegment(pos.GetSegmentID()); segment != nil {
|
||||
m.segments.SetStartPosition(pos.GetSegmentID(), pos.GetStartPosition())
|
||||
modSegments = append(modSegments, pos.GetSegmentID())
|
||||
}
|
||||
m.segments.SetStartPosition(pos.GetSegmentID(), pos.GetStartPosition())
|
||||
modSegments[segmentID] = struct{}{}
|
||||
}
|
||||
|
||||
for _, cp := range checkpoints {
|
||||
if segment := m.segments.GetSegment(cp.GetSegmentID()); segment != nil {
|
||||
if segment.DmlPosition != nil && segment.DmlPosition.Timestamp >= cp.Position.Timestamp {
|
||||
// segment position in etcd is larger than checkpoint, then dont change it
|
||||
continue
|
||||
}
|
||||
m.segments.SetDmlPositino(cp.GetSegmentID(), cp.GetPosition())
|
||||
m.segments.SetRowCount(cp.GetSegmentID(), cp.GetNumOfRows())
|
||||
modSegments = append(modSegments, segment.GetID())
|
||||
if segment.DmlPosition != nil && segment.DmlPosition.Timestamp >= cp.Position.Timestamp {
|
||||
// segment position in etcd is larger than checkpoint, then dont change it
|
||||
continue
|
||||
}
|
||||
m.segments.SetDmlPosition(cp.GetSegmentID(), cp.GetPosition())
|
||||
m.segments.SetRowCount(cp.GetSegmentID(), cp.GetNumOfRows())
|
||||
modSegments[segmentID] = struct{}{}
|
||||
}
|
||||
|
||||
for _, id := range modSegments {
|
||||
for id := range modSegments {
|
||||
if segment := m.segments.GetSegment(id); segment != nil {
|
||||
segBytes := proto.MarshalTextString(segment.SegmentInfo)
|
||||
key := buildSegmentPath(segment.GetCollectionID(), segment.GetPartitionID(), segment.GetID())
|
||||
|
||||
@ -55,58 +55,64 @@ func (s *SegmentsInfo) SetSegment(segmentID UniqueID, segment *SegmentInfo) {
|
||||
|
||||
func (s *SegmentsInfo) SetRowCount(segmentID UniqueID, rowCount int64) {
|
||||
if segment, ok := s.segments[segmentID]; ok {
|
||||
s.segments[segmentID] = s.ShadowClone(segment, SetRowCount(rowCount))
|
||||
s.segments[segmentID] = segment.ShadowClone(SetRowCount(rowCount))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SegmentsInfo) SetLasteExpiraTime(segmentID UniqueID, expireTs Timestamp) {
|
||||
if segment, ok := s.segments[segmentID]; ok {
|
||||
s.segments[segmentID] = s.ShadowClone(segment, SetExpireTime(expireTs))
|
||||
s.segments[segmentID] = segment.ShadowClone(SetExpireTime(expireTs))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SegmentsInfo) SetState(segmentID UniqueID, state commonpb.SegmentState) {
|
||||
if segment, ok := s.segments[segmentID]; ok {
|
||||
s.segments[segmentID] = s.ShadowClone(segment, SetState(state))
|
||||
s.segments[segmentID] = segment.ShadowClone(SetState(state))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SegmentsInfo) SetDmlPositino(segmentID UniqueID, pos *internalpb.MsgPosition) {
|
||||
func (s *SegmentsInfo) SetDmlPosition(segmentID UniqueID, pos *internalpb.MsgPosition) {
|
||||
if segment, ok := s.segments[segmentID]; ok {
|
||||
s.segments[segmentID] = s.Clone(segment, SetDmlPositino(pos))
|
||||
s.segments[segmentID] = segment.Clone(SetDmlPosition(pos))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SegmentsInfo) SetStartPosition(segmentID UniqueID, pos *internalpb.MsgPosition) {
|
||||
if segment, ok := s.segments[segmentID]; ok {
|
||||
s.segments[segmentID] = s.Clone(segment, SetStartPosition(pos))
|
||||
s.segments[segmentID] = segment.Clone(SetStartPosition(pos))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SegmentsInfo) SetAllocations(segmentID UniqueID, allocations []*Allocation) {
|
||||
if segment, ok := s.segments[segmentID]; ok {
|
||||
s.segments[segmentID] = s.ShadowClone(segment, SetAllocations(allocations))
|
||||
s.segments[segmentID] = segment.ShadowClone(SetAllocations(allocations))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SegmentsInfo) AddAllocation(segmentID UniqueID, allocation *Allocation) {
|
||||
if segment, ok := s.segments[segmentID]; ok {
|
||||
s.segments[segmentID] = s.Clone(segment, AddAllocation(allocation))
|
||||
s.segments[segmentID] = segment.Clone(AddAllocation(allocation))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SegmentsInfo) SetCurrentRows(segmentID UniqueID, rows int64) {
|
||||
if segment, ok := s.segments[segmentID]; ok {
|
||||
s.segments[segmentID] = s.ShadowClone(segment, SetCurrentRows(rows))
|
||||
s.segments[segmentID] = segment.ShadowClone(SetCurrentRows(rows))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SegmentsInfo) Clone(segment *SegmentInfo, opts ...SegmentInfoOption) *SegmentInfo {
|
||||
info := proto.Clone(segment.SegmentInfo).(*datapb.SegmentInfo)
|
||||
func (s *SegmentsInfo) SetBinlogs(segmentID UniqueID, binlogs []*datapb.FieldBinlog) {
|
||||
if segment, ok := s.segments[segmentID]; ok {
|
||||
s.segments[segmentID] = segment.Clone(SetBinlogs(binlogs))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *SegmentInfo) Clone(opts ...SegmentInfoOption) *SegmentInfo {
|
||||
info := proto.Clone(s.SegmentInfo).(*datapb.SegmentInfo)
|
||||
cloned := &SegmentInfo{
|
||||
SegmentInfo: info,
|
||||
currRows: segment.currRows,
|
||||
allocations: segment.allocations,
|
||||
currRows: s.currRows,
|
||||
allocations: s.allocations,
|
||||
}
|
||||
for _, opt := range opts {
|
||||
opt(cloned)
|
||||
@ -114,11 +120,11 @@ func (s *SegmentsInfo) Clone(segment *SegmentInfo, opts ...SegmentInfoOption) *S
|
||||
return cloned
|
||||
}
|
||||
|
||||
func (s *SegmentsInfo) ShadowClone(segment *SegmentInfo, opts ...SegmentInfoOption) *SegmentInfo {
|
||||
func (s *SegmentInfo) ShadowClone(opts ...SegmentInfoOption) *SegmentInfo {
|
||||
cloned := &SegmentInfo{
|
||||
SegmentInfo: segment.SegmentInfo,
|
||||
currRows: segment.currRows,
|
||||
allocations: segment.allocations,
|
||||
SegmentInfo: s.SegmentInfo,
|
||||
currRows: s.currRows,
|
||||
allocations: s.allocations,
|
||||
}
|
||||
|
||||
for _, opt := range opts {
|
||||
@ -147,7 +153,7 @@ func SetState(state commonpb.SegmentState) SegmentInfoOption {
|
||||
}
|
||||
}
|
||||
|
||||
func SetDmlPositino(pos *internalpb.MsgPosition) SegmentInfoOption {
|
||||
func SetDmlPosition(pos *internalpb.MsgPosition) SegmentInfoOption {
|
||||
return func(segment *SegmentInfo) {
|
||||
segment.DmlPosition = pos
|
||||
}
|
||||
@ -177,3 +183,9 @@ func SetCurrentRows(rows int64) SegmentInfoOption {
|
||||
segment.currRows = rows
|
||||
}
|
||||
}
|
||||
|
||||
func SetBinlogs(binlogs []*datapb.FieldBinlog) SegmentInfoOption {
|
||||
return func(segment *SegmentInfo) {
|
||||
segment.Binlogs = binlogs
|
||||
}
|
||||
}
|
||||
|
||||
@ -13,6 +13,7 @@ package datacoord
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"sync"
|
||||
@ -34,6 +35,7 @@ import (
|
||||
|
||||
"github.com/milvus-io/milvus/internal/proto/commonpb"
|
||||
"github.com/milvus-io/milvus/internal/proto/datapb"
|
||||
"github.com/milvus-io/milvus/internal/proto/internalpb"
|
||||
"github.com/milvus-io/milvus/internal/proto/milvuspb"
|
||||
)
|
||||
|
||||
@ -56,6 +58,8 @@ type (
|
||||
Timestamp = typeutil.Timestamp
|
||||
)
|
||||
|
||||
var errNilKvClient = errors.New("kv client not initialized")
|
||||
|
||||
// ServerState type alias
|
||||
type ServerState = int64
|
||||
|
||||
@ -593,18 +597,51 @@ func (s *Server) loadCollectionFromRootCoord(ctx context.Context, collectionID i
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Server) prepareBinlog(req *datapb.SaveBinlogPathsRequest) (map[string]string, error) {
|
||||
meta := make(map[string]string)
|
||||
|
||||
for _, fieldBlp := range req.Field2BinlogPaths {
|
||||
fieldMeta, err := s.prepareField2PathMeta(req.SegmentID, fieldBlp)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for k, v := range fieldMeta {
|
||||
meta[k] = v
|
||||
}
|
||||
// GetVChanPositions get vchannel latest postitions with provided dml channel names
|
||||
func (s *Server) GetVChanPositions(vchans []vchannel, seekFromStartPosition bool) ([]*datapb.VchannelInfo, error) {
|
||||
if s.kvClient == nil {
|
||||
return nil, errNilKvClient
|
||||
}
|
||||
pairs := make([]*datapb.VchannelInfo, 0, len(vchans))
|
||||
|
||||
return meta, nil
|
||||
for _, vchan := range vchans {
|
||||
segments := s.meta.GetSegmentsByChannel(vchan.DmlChannel)
|
||||
flushedSegmentIDs := make([]UniqueID, 0)
|
||||
unflushed := make([]*datapb.SegmentInfo, 0)
|
||||
var seekPosition *internalpb.MsgPosition
|
||||
var useUnflushedPosition bool
|
||||
for _, s := range segments {
|
||||
if s.State == commonpb.SegmentState_Flushing || s.State == commonpb.SegmentState_Flushed {
|
||||
flushedSegmentIDs = append(flushedSegmentIDs, s.ID)
|
||||
if seekPosition == nil || (!useUnflushedPosition && s.DmlPosition.Timestamp > seekPosition.Timestamp) {
|
||||
seekPosition = s.DmlPosition
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if s.DmlPosition == nil {
|
||||
continue
|
||||
}
|
||||
|
||||
unflushed = append(unflushed, s.SegmentInfo)
|
||||
|
||||
if seekPosition == nil || !useUnflushedPosition || s.DmlPosition.Timestamp < seekPosition.Timestamp {
|
||||
useUnflushedPosition = true
|
||||
if !seekFromStartPosition {
|
||||
seekPosition = s.DmlPosition
|
||||
} else {
|
||||
seekPosition = s.StartPosition
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pairs = append(pairs, &datapb.VchannelInfo{
|
||||
CollectionID: vchan.CollectionID,
|
||||
ChannelName: vchan.DmlChannel,
|
||||
SeekPosition: seekPosition,
|
||||
UnflushedSegments: unflushed,
|
||||
FlushedSegments: flushedSegmentIDs,
|
||||
})
|
||||
}
|
||||
return pairs, nil
|
||||
}
|
||||
|
||||
@ -235,6 +235,10 @@ func TestGetInsertBinlogPaths(t *testing.T) {
|
||||
svr := newTestServer(t, nil)
|
||||
defer closeTestServer(t, svr)
|
||||
|
||||
info := &datapb.SegmentInfo{
|
||||
ID: 0,
|
||||
}
|
||||
svr.meta.AddSegment(NewSegmentInfo(info))
|
||||
req := &datapb.GetInsertBinlogPathsRequest{
|
||||
SegmentID: 0,
|
||||
}
|
||||
@ -399,10 +403,10 @@ func TestSaveBinlogPaths(t *testing.T) {
|
||||
},
|
||||
SegmentID: 2,
|
||||
CollectionID: 0,
|
||||
Field2BinlogPaths: []*datapb.ID2PathList{
|
||||
Field2BinlogPaths: []*datapb.FieldBinlog{
|
||||
{
|
||||
ID: 1,
|
||||
Paths: []string{
|
||||
FieldID: 1,
|
||||
Binlogs: []string{
|
||||
"/by-dev/test/0/1/2/1/Allo1",
|
||||
"/by-dev/test/0/1/2/1/Allo2",
|
||||
},
|
||||
@ -425,23 +429,16 @@ func TestSaveBinlogPaths(t *testing.T) {
|
||||
assert.Nil(t, err)
|
||||
assert.EqualValues(t, resp.ErrorCode, commonpb.ErrorCode_Success)
|
||||
|
||||
metas, err := svr.getFieldBinlogMeta(2, 1)
|
||||
assert.Nil(t, err)
|
||||
if assert.EqualValues(t, 2, len(metas)) {
|
||||
assert.EqualValues(t, 1, metas[0].FieldID)
|
||||
assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo1", metas[0].BinlogPath)
|
||||
assert.EqualValues(t, 1, metas[1].FieldID)
|
||||
assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo2", metas[1].BinlogPath)
|
||||
}
|
||||
|
||||
metas, err = svr.getSegmentBinlogMeta(2)
|
||||
assert.Nil(t, err)
|
||||
if assert.EqualValues(t, 2, len(metas)) {
|
||||
assert.EqualValues(t, 1, metas[0].FieldID)
|
||||
assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo1", metas[0].BinlogPath)
|
||||
assert.EqualValues(t, 1, metas[1].FieldID)
|
||||
assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo2", metas[1].BinlogPath)
|
||||
}
|
||||
segment := svr.meta.GetSegment(2)
|
||||
assert.NotNil(t, segment)
|
||||
binlogs := segment.GetBinlogs()
|
||||
assert.EqualValues(t, 1, len(binlogs))
|
||||
fieldBinlogs := binlogs[0]
|
||||
assert.NotNil(t, fieldBinlogs)
|
||||
assert.EqualValues(t, 2, len(fieldBinlogs.GetBinlogs()))
|
||||
assert.EqualValues(t, 1, fieldBinlogs.GetFieldID())
|
||||
assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo1", fieldBinlogs.GetBinlogs()[0])
|
||||
assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo2", fieldBinlogs.GetBinlogs()[1])
|
||||
|
||||
segmentInfo := svr.meta.GetSegment(0)
|
||||
assert.NotNil(t, segmentInfo)
|
||||
@ -853,20 +850,22 @@ func TestGetRecoveryInfo(t *testing.T) {
|
||||
binlogReq := &datapb.SaveBinlogPathsRequest{
|
||||
SegmentID: 0,
|
||||
CollectionID: 0,
|
||||
Field2BinlogPaths: []*datapb.ID2PathList{
|
||||
Field2BinlogPaths: []*datapb.FieldBinlog{
|
||||
{
|
||||
ID: 1,
|
||||
Paths: []string{
|
||||
FieldID: 1,
|
||||
Binlogs: []string{
|
||||
"/binlog/file1",
|
||||
"/binlog/file2",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
meta, err := svr.prepareBinlog(binlogReq)
|
||||
segment := createSegment(0, 0, 0, 100, 10, "ch1", commonpb.SegmentState_Flushed)
|
||||
err := svr.meta.AddSegment(NewSegmentInfo(segment))
|
||||
assert.Nil(t, err)
|
||||
err = svr.kvClient.MultiSave(meta)
|
||||
sResp, err := svr.SaveBinlogPaths(context.TODO(), binlogReq)
|
||||
assert.Nil(t, err)
|
||||
assert.EqualValues(t, commonpb.ErrorCode_Success, sResp.ErrorCode)
|
||||
|
||||
req := &datapb.GetRecoveryInfoRequest{
|
||||
CollectionID: 0,
|
||||
|
||||
@ -467,7 +467,7 @@ func (node *DataNode) FlushSegments(ctx context.Context, req *datapb.FlushSegmen
|
||||
zap.Int64s("segments", req.SegmentIDs),
|
||||
)
|
||||
|
||||
dmlFlushedCh := make(chan []*datapb.ID2PathList, len(req.SegmentIDs))
|
||||
dmlFlushedCh := make(chan []*datapb.FieldBinlog, len(req.SegmentIDs))
|
||||
for _, id := range req.SegmentIDs {
|
||||
chanName := node.getChannelNamebySegmentID(id)
|
||||
log.Debug("vchannel",
|
||||
@ -514,8 +514,8 @@ func (node *DataNode) FlushSegments(ctx context.Context, req *datapb.FlushSegmen
|
||||
if len(msg) != 1 {
|
||||
panic("flush size expect to 1")
|
||||
}
|
||||
if msg[0].Paths == nil {
|
||||
failedSegments += fmt.Sprintf(" %d", msg[0].ID)
|
||||
if msg[0].Binlogs == nil {
|
||||
failedSegments += fmt.Sprintf(" %d", msg[0].FieldID)
|
||||
}
|
||||
}
|
||||
if len(failedSegments) != 0 {
|
||||
|
||||
@ -105,10 +105,10 @@ func (dsService *dataSyncService) initNodes(vchanInfo *datapb.VchannelInfo) erro
|
||||
}
|
||||
|
||||
saveBinlog := func(fu *segmentFlushUnit) error {
|
||||
id2path := []*datapb.ID2PathList{}
|
||||
id2path := []*datapb.FieldBinlog{}
|
||||
checkPoints := []*datapb.CheckPoint{}
|
||||
for k, v := range fu.field2Path {
|
||||
id2path = append(id2path, &datapb.ID2PathList{ID: k, Paths: []string{v}})
|
||||
id2path = append(id2path, &datapb.FieldBinlog{FieldID: k, Binlogs: []string{v}})
|
||||
}
|
||||
for k, v := range fu.checkPoint {
|
||||
v := v
|
||||
|
||||
@ -559,7 +559,7 @@ func (ibNode *insertBufferNode) Operate(in []flowgraph.Msg) []flowgraph.Msg {
|
||||
flushed: true,
|
||||
})
|
||||
ibNode.replica.segmentFlushed(currentSegID)
|
||||
fmsg.dmlFlushedCh <- []*datapb.ID2PathList{{ID: currentSegID, Paths: []string{}}}
|
||||
fmsg.dmlFlushedCh <- []*datapb.FieldBinlog{{FieldID: currentSegID, Binlogs: []string{}}}
|
||||
} else { //insertBuffer(not empty) -> binLogs -> minIO/S3
|
||||
log.Debug(".. Buffer not empty, flushing ..")
|
||||
finishCh := make(chan segmentFlushUnit, 1)
|
||||
@ -571,7 +571,7 @@ func (ibNode *insertBufferNode) Operate(in []flowgraph.Msg) []flowgraph.Msg {
|
||||
log.Debug(".. Clearing flush Buffer ..")
|
||||
ibNode.flushMap.Delete(currentSegID)
|
||||
close(finishCh)
|
||||
fmsg.dmlFlushedCh <- []*datapb.ID2PathList{{ID: currentSegID, Paths: nil}}
|
||||
fmsg.dmlFlushedCh <- []*datapb.FieldBinlog{{FieldID: currentSegID, Binlogs: nil}}
|
||||
}
|
||||
|
||||
collID, partitionID, err := ibNode.getCollectionandPartitionIDbySegID(currentSegID)
|
||||
@ -603,7 +603,7 @@ func (ibNode *insertBufferNode) Operate(in []flowgraph.Msg) []flowgraph.Msg {
|
||||
ibNode.replica.segmentFlushed(fu.segID)
|
||||
}
|
||||
}
|
||||
fmsg.dmlFlushedCh <- []*datapb.ID2PathList{{ID: currentSegID, Paths: []string{}}}
|
||||
fmsg.dmlFlushedCh <- []*datapb.FieldBinlog{{FieldID: currentSegID, Binlogs: []string{}}}
|
||||
}
|
||||
|
||||
default:
|
||||
|
||||
@ -72,7 +72,7 @@ func TestFlowGraphInsertBufferNode_Operate(t *testing.T) {
|
||||
flushChan := make(chan *flushMsg, 100)
|
||||
iBNode := newInsertBufferNode(ctx, replica, msFactory, NewAllocatorFactory(), flushChan, saveBinlog, "string")
|
||||
|
||||
dmlFlushedCh := make(chan []*datapb.ID2PathList, 1)
|
||||
dmlFlushedCh := make(chan []*datapb.FieldBinlog, 1)
|
||||
|
||||
flushChan <- &flushMsg{
|
||||
msgID: 1,
|
||||
@ -413,7 +413,7 @@ func TestFlowGraphInsertBufferNode_AutoFlush(t *testing.T) {
|
||||
assert.Equal(t, len(iBNode.insertBuffer.insertData), 1)
|
||||
assert.Equal(t, iBNode.insertBuffer.size(3), int32(50+16000))
|
||||
|
||||
dmlFlushedCh := make(chan []*datapb.ID2PathList, 1)
|
||||
dmlFlushedCh := make(chan []*datapb.FieldBinlog, 1)
|
||||
|
||||
flushChan <- &flushMsg{
|
||||
msgID: 3,
|
||||
@ -431,8 +431,8 @@ func TestFlowGraphInsertBufferNode_AutoFlush(t *testing.T) {
|
||||
flushSeg := <-dmlFlushedCh
|
||||
assert.NotNil(t, flushSeg)
|
||||
assert.Equal(t, len(flushSeg), 1)
|
||||
assert.Equal(t, flushSeg[0].ID, int64(1))
|
||||
assert.NotNil(t, flushSeg[0].Paths)
|
||||
assert.Equal(t, flushSeg[0].FieldID, int64(1))
|
||||
assert.NotNil(t, flushSeg[0].Binlogs)
|
||||
assert.Equal(t, len(iBNode.segmentCheckPoints), 2)
|
||||
assert.Equal(t, iBNode.segmentCheckPoints[2].numRows, int64(100+32000))
|
||||
assert.Equal(t, iBNode.segmentCheckPoints[3].numRows, int64(0))
|
||||
@ -465,8 +465,8 @@ func TestFlowGraphInsertBufferNode_AutoFlush(t *testing.T) {
|
||||
flushSeg = <-dmlFlushedCh
|
||||
assert.NotNil(t, flushSeg)
|
||||
assert.Equal(t, len(flushSeg), 1)
|
||||
assert.Equal(t, flushSeg[0].ID, int64(3))
|
||||
assert.NotNil(t, flushSeg[0].Paths)
|
||||
assert.Equal(t, flushSeg[0].FieldID, int64(3))
|
||||
assert.NotNil(t, flushSeg[0].Binlogs)
|
||||
assert.Equal(t, len(iBNode.segmentCheckPoints), 1)
|
||||
assert.Equal(t, iBNode.segmentCheckPoints[2].numRows, int64(100+32000))
|
||||
assert.Equal(t, iBNode.segmentCheckPoints[2].pos.Timestamp, Timestamp(234))
|
||||
|
||||
@ -35,7 +35,7 @@ type flushMsg struct {
|
||||
timestamp Timestamp
|
||||
segmentID UniqueID
|
||||
collectionID UniqueID
|
||||
dmlFlushedCh chan<- []*datapb.ID2PathList
|
||||
dmlFlushedCh chan<- []*datapb.FieldBinlog
|
||||
}
|
||||
|
||||
func (iMsg *insertMsg) TimeTick() Timestamp {
|
||||
|
||||
@ -172,29 +172,6 @@ message SegmentMsg{
|
||||
SegmentInfo segment = 2;
|
||||
}
|
||||
|
||||
// key: ${prefix}/${segmentID}/${fieldID}/${idx}
|
||||
message SegmentFieldBinlogMeta {
|
||||
int64 fieldID = 1;
|
||||
string binlog_path = 2;
|
||||
}
|
||||
|
||||
// key: ${prefix}/${collectionID}/${idx}
|
||||
message DDLBinlogMeta {
|
||||
string ddl_binlog_path = 1;
|
||||
string ts_binlog_path = 2;
|
||||
}
|
||||
|
||||
message FieldFlushMeta {
|
||||
int64 fieldID = 1;
|
||||
repeated string binlog_paths = 2;
|
||||
}
|
||||
|
||||
message SegmentFlushMeta{
|
||||
int64 segmentID = 1;
|
||||
bool is_flushed = 2;
|
||||
repeated FieldFlushMeta fields = 5;
|
||||
}
|
||||
|
||||
message DDLFlushMeta {
|
||||
int64 collectionID = 1;
|
||||
repeated string binlog_paths = 2;
|
||||
@ -212,16 +189,13 @@ message SegmentInfo {
|
||||
string insert_channel = 4;
|
||||
int64 num_of_rows = 5;
|
||||
common.SegmentState state = 6;
|
||||
internal.MsgPosition dml_position = 7;
|
||||
int64 max_row_num = 8;
|
||||
uint64 last_expire_time = 9;
|
||||
internal.MsgPosition start_position = 10;
|
||||
int64 max_row_num = 7;
|
||||
uint64 last_expire_time = 8;
|
||||
internal.MsgPosition start_position = 9;
|
||||
internal.MsgPosition dml_position = 10;
|
||||
repeated FieldBinlog binlogs = 11;
|
||||
}
|
||||
|
||||
message ID2PathList {
|
||||
int64 ID = 1;
|
||||
repeated string Paths = 2;
|
||||
}
|
||||
|
||||
message SegmentStartPosition {
|
||||
internal.MsgPosition start_position = 1;
|
||||
@ -232,7 +206,7 @@ message SaveBinlogPathsRequest {
|
||||
common.MsgBase base = 1;
|
||||
int64 segmentID = 2;
|
||||
int64 collectionID = 3;
|
||||
repeated ID2PathList field2BinlogPaths = 4;
|
||||
repeated FieldBinlog field2BinlogPaths = 4;
|
||||
repeated CheckPoint checkPoints = 5;
|
||||
repeated SegmentStartPosition start_positions = 6;
|
||||
bool flushed = 7;
|
||||
|
||||
@ -1255,204 +1255,6 @@ func (m *SegmentMsg) GetSegment() *SegmentInfo {
|
||||
return nil
|
||||
}
|
||||
|
||||
// key: ${prefix}/${segmentID}/${fieldID}/${idx}
|
||||
type SegmentFieldBinlogMeta struct {
|
||||
FieldID int64 `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"`
|
||||
BinlogPath string `protobuf:"bytes,2,opt,name=binlog_path,json=binlogPath,proto3" json:"binlog_path,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *SegmentFieldBinlogMeta) Reset() { *m = SegmentFieldBinlogMeta{} }
|
||||
func (m *SegmentFieldBinlogMeta) String() string { return proto.CompactTextString(m) }
|
||||
func (*SegmentFieldBinlogMeta) ProtoMessage() {}
|
||||
func (*SegmentFieldBinlogMeta) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{22}
|
||||
}
|
||||
|
||||
func (m *SegmentFieldBinlogMeta) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_SegmentFieldBinlogMeta.Unmarshal(m, b)
|
||||
}
|
||||
func (m *SegmentFieldBinlogMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_SegmentFieldBinlogMeta.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *SegmentFieldBinlogMeta) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_SegmentFieldBinlogMeta.Merge(m, src)
|
||||
}
|
||||
func (m *SegmentFieldBinlogMeta) XXX_Size() int {
|
||||
return xxx_messageInfo_SegmentFieldBinlogMeta.Size(m)
|
||||
}
|
||||
func (m *SegmentFieldBinlogMeta) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_SegmentFieldBinlogMeta.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_SegmentFieldBinlogMeta proto.InternalMessageInfo
|
||||
|
||||
func (m *SegmentFieldBinlogMeta) GetFieldID() int64 {
|
||||
if m != nil {
|
||||
return m.FieldID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *SegmentFieldBinlogMeta) GetBinlogPath() string {
|
||||
if m != nil {
|
||||
return m.BinlogPath
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// key: ${prefix}/${collectionID}/${idx}
|
||||
type DDLBinlogMeta struct {
|
||||
DdlBinlogPath string `protobuf:"bytes,1,opt,name=ddl_binlog_path,json=ddlBinlogPath,proto3" json:"ddl_binlog_path,omitempty"`
|
||||
TsBinlogPath string `protobuf:"bytes,2,opt,name=ts_binlog_path,json=tsBinlogPath,proto3" json:"ts_binlog_path,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *DDLBinlogMeta) Reset() { *m = DDLBinlogMeta{} }
|
||||
func (m *DDLBinlogMeta) String() string { return proto.CompactTextString(m) }
|
||||
func (*DDLBinlogMeta) ProtoMessage() {}
|
||||
func (*DDLBinlogMeta) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{23}
|
||||
}
|
||||
|
||||
func (m *DDLBinlogMeta) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_DDLBinlogMeta.Unmarshal(m, b)
|
||||
}
|
||||
func (m *DDLBinlogMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_DDLBinlogMeta.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *DDLBinlogMeta) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_DDLBinlogMeta.Merge(m, src)
|
||||
}
|
||||
func (m *DDLBinlogMeta) XXX_Size() int {
|
||||
return xxx_messageInfo_DDLBinlogMeta.Size(m)
|
||||
}
|
||||
func (m *DDLBinlogMeta) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_DDLBinlogMeta.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_DDLBinlogMeta proto.InternalMessageInfo
|
||||
|
||||
func (m *DDLBinlogMeta) GetDdlBinlogPath() string {
|
||||
if m != nil {
|
||||
return m.DdlBinlogPath
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (m *DDLBinlogMeta) GetTsBinlogPath() string {
|
||||
if m != nil {
|
||||
return m.TsBinlogPath
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
type FieldFlushMeta struct {
|
||||
FieldID int64 `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"`
|
||||
BinlogPaths []string `protobuf:"bytes,2,rep,name=binlog_paths,json=binlogPaths,proto3" json:"binlog_paths,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *FieldFlushMeta) Reset() { *m = FieldFlushMeta{} }
|
||||
func (m *FieldFlushMeta) String() string { return proto.CompactTextString(m) }
|
||||
func (*FieldFlushMeta) ProtoMessage() {}
|
||||
func (*FieldFlushMeta) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{24}
|
||||
}
|
||||
|
||||
func (m *FieldFlushMeta) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_FieldFlushMeta.Unmarshal(m, b)
|
||||
}
|
||||
func (m *FieldFlushMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_FieldFlushMeta.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *FieldFlushMeta) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_FieldFlushMeta.Merge(m, src)
|
||||
}
|
||||
func (m *FieldFlushMeta) XXX_Size() int {
|
||||
return xxx_messageInfo_FieldFlushMeta.Size(m)
|
||||
}
|
||||
func (m *FieldFlushMeta) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_FieldFlushMeta.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_FieldFlushMeta proto.InternalMessageInfo
|
||||
|
||||
func (m *FieldFlushMeta) GetFieldID() int64 {
|
||||
if m != nil {
|
||||
return m.FieldID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *FieldFlushMeta) GetBinlogPaths() []string {
|
||||
if m != nil {
|
||||
return m.BinlogPaths
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type SegmentFlushMeta struct {
|
||||
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
|
||||
IsFlushed bool `protobuf:"varint,2,opt,name=is_flushed,json=isFlushed,proto3" json:"is_flushed,omitempty"`
|
||||
Fields []*FieldFlushMeta `protobuf:"bytes,5,rep,name=fields,proto3" json:"fields,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *SegmentFlushMeta) Reset() { *m = SegmentFlushMeta{} }
|
||||
func (m *SegmentFlushMeta) String() string { return proto.CompactTextString(m) }
|
||||
func (*SegmentFlushMeta) ProtoMessage() {}
|
||||
func (*SegmentFlushMeta) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{25}
|
||||
}
|
||||
|
||||
func (m *SegmentFlushMeta) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_SegmentFlushMeta.Unmarshal(m, b)
|
||||
}
|
||||
func (m *SegmentFlushMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_SegmentFlushMeta.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *SegmentFlushMeta) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_SegmentFlushMeta.Merge(m, src)
|
||||
}
|
||||
func (m *SegmentFlushMeta) XXX_Size() int {
|
||||
return xxx_messageInfo_SegmentFlushMeta.Size(m)
|
||||
}
|
||||
func (m *SegmentFlushMeta) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_SegmentFlushMeta.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_SegmentFlushMeta proto.InternalMessageInfo
|
||||
|
||||
func (m *SegmentFlushMeta) GetSegmentID() int64 {
|
||||
if m != nil {
|
||||
return m.SegmentID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *SegmentFlushMeta) GetIsFlushed() bool {
|
||||
if m != nil {
|
||||
return m.IsFlushed
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (m *SegmentFlushMeta) GetFields() []*FieldFlushMeta {
|
||||
if m != nil {
|
||||
return m.Fields
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type DDLFlushMeta struct {
|
||||
CollectionID int64 `protobuf:"varint,1,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
|
||||
BinlogPaths []string `protobuf:"bytes,2,rep,name=binlog_paths,json=binlogPaths,proto3" json:"binlog_paths,omitempty"`
|
||||
@ -1465,7 +1267,7 @@ func (m *DDLFlushMeta) Reset() { *m = DDLFlushMeta{} }
|
||||
func (m *DDLFlushMeta) String() string { return proto.CompactTextString(m) }
|
||||
func (*DDLFlushMeta) ProtoMessage() {}
|
||||
func (*DDLFlushMeta) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{26}
|
||||
return fileDescriptor_82cd95f524594f49, []int{22}
|
||||
}
|
||||
|
||||
func (m *DDLFlushMeta) XXX_Unmarshal(b []byte) error {
|
||||
@ -1513,7 +1315,7 @@ func (m *CollectionInfo) Reset() { *m = CollectionInfo{} }
|
||||
func (m *CollectionInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*CollectionInfo) ProtoMessage() {}
|
||||
func (*CollectionInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{27}
|
||||
return fileDescriptor_82cd95f524594f49, []int{23}
|
||||
}
|
||||
|
||||
func (m *CollectionInfo) XXX_Unmarshal(b []byte) error {
|
||||
@ -1562,10 +1364,11 @@ type SegmentInfo struct {
|
||||
InsertChannel string `protobuf:"bytes,4,opt,name=insert_channel,json=insertChannel,proto3" json:"insert_channel,omitempty"`
|
||||
NumOfRows int64 `protobuf:"varint,5,opt,name=num_of_rows,json=numOfRows,proto3" json:"num_of_rows,omitempty"`
|
||||
State commonpb.SegmentState `protobuf:"varint,6,opt,name=state,proto3,enum=milvus.proto.common.SegmentState" json:"state,omitempty"`
|
||||
DmlPosition *internalpb.MsgPosition `protobuf:"bytes,7,opt,name=dml_position,json=dmlPosition,proto3" json:"dml_position,omitempty"`
|
||||
MaxRowNum int64 `protobuf:"varint,8,opt,name=max_row_num,json=maxRowNum,proto3" json:"max_row_num,omitempty"`
|
||||
LastExpireTime uint64 `protobuf:"varint,9,opt,name=last_expire_time,json=lastExpireTime,proto3" json:"last_expire_time,omitempty"`
|
||||
StartPosition *internalpb.MsgPosition `protobuf:"bytes,10,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"`
|
||||
MaxRowNum int64 `protobuf:"varint,7,opt,name=max_row_num,json=maxRowNum,proto3" json:"max_row_num,omitempty"`
|
||||
LastExpireTime uint64 `protobuf:"varint,8,opt,name=last_expire_time,json=lastExpireTime,proto3" json:"last_expire_time,omitempty"`
|
||||
StartPosition *internalpb.MsgPosition `protobuf:"bytes,9,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"`
|
||||
DmlPosition *internalpb.MsgPosition `protobuf:"bytes,10,opt,name=dml_position,json=dmlPosition,proto3" json:"dml_position,omitempty"`
|
||||
Binlogs []*FieldBinlog `protobuf:"bytes,11,rep,name=binlogs,proto3" json:"binlogs,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
@ -1575,7 +1378,7 @@ func (m *SegmentInfo) Reset() { *m = SegmentInfo{} }
|
||||
func (m *SegmentInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*SegmentInfo) ProtoMessage() {}
|
||||
func (*SegmentInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{28}
|
||||
return fileDescriptor_82cd95f524594f49, []int{24}
|
||||
}
|
||||
|
||||
func (m *SegmentInfo) XXX_Unmarshal(b []byte) error {
|
||||
@ -1638,13 +1441,6 @@ func (m *SegmentInfo) GetState() commonpb.SegmentState {
|
||||
return commonpb.SegmentState_SegmentStateNone
|
||||
}
|
||||
|
||||
func (m *SegmentInfo) GetDmlPosition() *internalpb.MsgPosition {
|
||||
if m != nil {
|
||||
return m.DmlPosition
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *SegmentInfo) GetMaxRowNum() int64 {
|
||||
if m != nil {
|
||||
return m.MaxRowNum
|
||||
@ -1666,49 +1462,16 @@ func (m *SegmentInfo) GetStartPosition() *internalpb.MsgPosition {
|
||||
return nil
|
||||
}
|
||||
|
||||
type ID2PathList struct {
|
||||
ID int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
|
||||
Paths []string `protobuf:"bytes,2,rep,name=Paths,proto3" json:"Paths,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *ID2PathList) Reset() { *m = ID2PathList{} }
|
||||
func (m *ID2PathList) String() string { return proto.CompactTextString(m) }
|
||||
func (*ID2PathList) ProtoMessage() {}
|
||||
func (*ID2PathList) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{29}
|
||||
}
|
||||
|
||||
func (m *ID2PathList) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_ID2PathList.Unmarshal(m, b)
|
||||
}
|
||||
func (m *ID2PathList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_ID2PathList.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *ID2PathList) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_ID2PathList.Merge(m, src)
|
||||
}
|
||||
func (m *ID2PathList) XXX_Size() int {
|
||||
return xxx_messageInfo_ID2PathList.Size(m)
|
||||
}
|
||||
func (m *ID2PathList) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_ID2PathList.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_ID2PathList proto.InternalMessageInfo
|
||||
|
||||
func (m *ID2PathList) GetID() int64 {
|
||||
func (m *SegmentInfo) GetDmlPosition() *internalpb.MsgPosition {
|
||||
if m != nil {
|
||||
return m.ID
|
||||
return m.DmlPosition
|
||||
}
|
||||
return 0
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *ID2PathList) GetPaths() []string {
|
||||
func (m *SegmentInfo) GetBinlogs() []*FieldBinlog {
|
||||
if m != nil {
|
||||
return m.Paths
|
||||
return m.Binlogs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@ -1725,7 +1488,7 @@ func (m *SegmentStartPosition) Reset() { *m = SegmentStartPosition{} }
|
||||
func (m *SegmentStartPosition) String() string { return proto.CompactTextString(m) }
|
||||
func (*SegmentStartPosition) ProtoMessage() {}
|
||||
func (*SegmentStartPosition) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{30}
|
||||
return fileDescriptor_82cd95f524594f49, []int{25}
|
||||
}
|
||||
|
||||
func (m *SegmentStartPosition) XXX_Unmarshal(b []byte) error {
|
||||
@ -1764,7 +1527,7 @@ type SaveBinlogPathsRequest struct {
|
||||
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
|
||||
SegmentID int64 `protobuf:"varint,2,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
|
||||
CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
|
||||
Field2BinlogPaths []*ID2PathList `protobuf:"bytes,4,rep,name=field2BinlogPaths,proto3" json:"field2BinlogPaths,omitempty"`
|
||||
Field2BinlogPaths []*FieldBinlog `protobuf:"bytes,4,rep,name=field2BinlogPaths,proto3" json:"field2BinlogPaths,omitempty"`
|
||||
CheckPoints []*CheckPoint `protobuf:"bytes,5,rep,name=checkPoints,proto3" json:"checkPoints,omitempty"`
|
||||
StartPositions []*SegmentStartPosition `protobuf:"bytes,6,rep,name=start_positions,json=startPositions,proto3" json:"start_positions,omitempty"`
|
||||
Flushed bool `protobuf:"varint,7,opt,name=flushed,proto3" json:"flushed,omitempty"`
|
||||
@ -1777,7 +1540,7 @@ func (m *SaveBinlogPathsRequest) Reset() { *m = SaveBinlogPathsRequest{}
|
||||
func (m *SaveBinlogPathsRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*SaveBinlogPathsRequest) ProtoMessage() {}
|
||||
func (*SaveBinlogPathsRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{31}
|
||||
return fileDescriptor_82cd95f524594f49, []int{26}
|
||||
}
|
||||
|
||||
func (m *SaveBinlogPathsRequest) XXX_Unmarshal(b []byte) error {
|
||||
@ -1819,7 +1582,7 @@ func (m *SaveBinlogPathsRequest) GetCollectionID() int64 {
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *SaveBinlogPathsRequest) GetField2BinlogPaths() []*ID2PathList {
|
||||
func (m *SaveBinlogPathsRequest) GetField2BinlogPaths() []*FieldBinlog {
|
||||
if m != nil {
|
||||
return m.Field2BinlogPaths
|
||||
}
|
||||
@ -1860,7 +1623,7 @@ func (m *CheckPoint) Reset() { *m = CheckPoint{} }
|
||||
func (m *CheckPoint) String() string { return proto.CompactTextString(m) }
|
||||
func (*CheckPoint) ProtoMessage() {}
|
||||
func (*CheckPoint) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{32}
|
||||
return fileDescriptor_82cd95f524594f49, []int{27}
|
||||
}
|
||||
|
||||
func (m *CheckPoint) XXX_Unmarshal(b []byte) error {
|
||||
@ -1915,7 +1678,7 @@ func (m *DataNodeTtMsg) Reset() { *m = DataNodeTtMsg{} }
|
||||
func (m *DataNodeTtMsg) String() string { return proto.CompactTextString(m) }
|
||||
func (*DataNodeTtMsg) ProtoMessage() {}
|
||||
func (*DataNodeTtMsg) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{33}
|
||||
return fileDescriptor_82cd95f524594f49, []int{28}
|
||||
}
|
||||
|
||||
func (m *DataNodeTtMsg) XXX_Unmarshal(b []byte) error {
|
||||
@ -1970,7 +1733,7 @@ func (m *ChannelStatus) Reset() { *m = ChannelStatus{} }
|
||||
func (m *ChannelStatus) String() string { return proto.CompactTextString(m) }
|
||||
func (*ChannelStatus) ProtoMessage() {}
|
||||
func (*ChannelStatus) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{34}
|
||||
return fileDescriptor_82cd95f524594f49, []int{29}
|
||||
}
|
||||
|
||||
func (m *ChannelStatus) XXX_Unmarshal(b []byte) error {
|
||||
@ -2025,7 +1788,7 @@ func (m *DataNodeInfo) Reset() { *m = DataNodeInfo{} }
|
||||
func (m *DataNodeInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*DataNodeInfo) ProtoMessage() {}
|
||||
func (*DataNodeInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{35}
|
||||
return fileDescriptor_82cd95f524594f49, []int{30}
|
||||
}
|
||||
|
||||
func (m *DataNodeInfo) XXX_Unmarshal(b []byte) error {
|
||||
@ -2079,7 +1842,7 @@ func (m *SegmentBinlogs) Reset() { *m = SegmentBinlogs{} }
|
||||
func (m *SegmentBinlogs) String() string { return proto.CompactTextString(m) }
|
||||
func (*SegmentBinlogs) ProtoMessage() {}
|
||||
func (*SegmentBinlogs) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{36}
|
||||
return fileDescriptor_82cd95f524594f49, []int{31}
|
||||
}
|
||||
|
||||
func (m *SegmentBinlogs) XXX_Unmarshal(b []byte) error {
|
||||
@ -2126,7 +1889,7 @@ func (m *FieldBinlog) Reset() { *m = FieldBinlog{} }
|
||||
func (m *FieldBinlog) String() string { return proto.CompactTextString(m) }
|
||||
func (*FieldBinlog) ProtoMessage() {}
|
||||
func (*FieldBinlog) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{37}
|
||||
return fileDescriptor_82cd95f524594f49, []int{32}
|
||||
}
|
||||
|
||||
func (m *FieldBinlog) XXX_Unmarshal(b []byte) error {
|
||||
@ -2174,7 +1937,7 @@ func (m *GetRecoveryInfoResponse) Reset() { *m = GetRecoveryInfoResponse
|
||||
func (m *GetRecoveryInfoResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetRecoveryInfoResponse) ProtoMessage() {}
|
||||
func (*GetRecoveryInfoResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{38}
|
||||
return fileDescriptor_82cd95f524594f49, []int{33}
|
||||
}
|
||||
|
||||
func (m *GetRecoveryInfoResponse) XXX_Unmarshal(b []byte) error {
|
||||
@ -2229,7 +1992,7 @@ func (m *GetRecoveryInfoRequest) Reset() { *m = GetRecoveryInfoRequest{}
|
||||
func (m *GetRecoveryInfoRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetRecoveryInfoRequest) ProtoMessage() {}
|
||||
func (*GetRecoveryInfoRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{39}
|
||||
return fileDescriptor_82cd95f524594f49, []int{34}
|
||||
}
|
||||
|
||||
func (m *GetRecoveryInfoRequest) XXX_Unmarshal(b []byte) error {
|
||||
@ -2284,7 +2047,7 @@ func (m *GetFlushedSegmentsRequest) Reset() { *m = GetFlushedSegmentsReq
|
||||
func (m *GetFlushedSegmentsRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetFlushedSegmentsRequest) ProtoMessage() {}
|
||||
func (*GetFlushedSegmentsRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{40}
|
||||
return fileDescriptor_82cd95f524594f49, []int{35}
|
||||
}
|
||||
|
||||
func (m *GetFlushedSegmentsRequest) XXX_Unmarshal(b []byte) error {
|
||||
@ -2338,7 +2101,7 @@ func (m *GetFlushedSegmentsResponse) Reset() { *m = GetFlushedSegmentsRe
|
||||
func (m *GetFlushedSegmentsResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*GetFlushedSegmentsResponse) ProtoMessage() {}
|
||||
func (*GetFlushedSegmentsResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{41}
|
||||
return fileDescriptor_82cd95f524594f49, []int{36}
|
||||
}
|
||||
|
||||
func (m *GetFlushedSegmentsResponse) XXX_Unmarshal(b []byte) error {
|
||||
@ -2385,7 +2148,7 @@ func (m *SegmentFlushCompletedMsg) Reset() { *m = SegmentFlushCompletedM
|
||||
func (m *SegmentFlushCompletedMsg) String() string { return proto.CompactTextString(m) }
|
||||
func (*SegmentFlushCompletedMsg) ProtoMessage() {}
|
||||
func (*SegmentFlushCompletedMsg) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{42}
|
||||
return fileDescriptor_82cd95f524594f49, []int{37}
|
||||
}
|
||||
|
||||
func (m *SegmentFlushCompletedMsg) XXX_Unmarshal(b []byte) error {
|
||||
@ -2433,7 +2196,7 @@ func (m *ChannelWatchInfo) Reset() { *m = ChannelWatchInfo{} }
|
||||
func (m *ChannelWatchInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*ChannelWatchInfo) ProtoMessage() {}
|
||||
func (*ChannelWatchInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_82cd95f524594f49, []int{43}
|
||||
return fileDescriptor_82cd95f524594f49, []int{38}
|
||||
}
|
||||
|
||||
func (m *ChannelWatchInfo) XXX_Unmarshal(b []byte) error {
|
||||
@ -2499,14 +2262,9 @@ func init() {
|
||||
proto.RegisterType((*WatchDmChannelsRequest)(nil), "milvus.proto.data.WatchDmChannelsRequest")
|
||||
proto.RegisterType((*FlushSegmentsRequest)(nil), "milvus.proto.data.FlushSegmentsRequest")
|
||||
proto.RegisterType((*SegmentMsg)(nil), "milvus.proto.data.SegmentMsg")
|
||||
proto.RegisterType((*SegmentFieldBinlogMeta)(nil), "milvus.proto.data.SegmentFieldBinlogMeta")
|
||||
proto.RegisterType((*DDLBinlogMeta)(nil), "milvus.proto.data.DDLBinlogMeta")
|
||||
proto.RegisterType((*FieldFlushMeta)(nil), "milvus.proto.data.FieldFlushMeta")
|
||||
proto.RegisterType((*SegmentFlushMeta)(nil), "milvus.proto.data.SegmentFlushMeta")
|
||||
proto.RegisterType((*DDLFlushMeta)(nil), "milvus.proto.data.DDLFlushMeta")
|
||||
proto.RegisterType((*CollectionInfo)(nil), "milvus.proto.data.CollectionInfo")
|
||||
proto.RegisterType((*SegmentInfo)(nil), "milvus.proto.data.SegmentInfo")
|
||||
proto.RegisterType((*ID2PathList)(nil), "milvus.proto.data.ID2PathList")
|
||||
proto.RegisterType((*SegmentStartPosition)(nil), "milvus.proto.data.SegmentStartPosition")
|
||||
proto.RegisterType((*SaveBinlogPathsRequest)(nil), "milvus.proto.data.SaveBinlogPathsRequest")
|
||||
proto.RegisterType((*CheckPoint)(nil), "milvus.proto.data.CheckPoint")
|
||||
@ -2526,136 +2284,129 @@ func init() {
|
||||
func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
|
||||
|
||||
var fileDescriptor_82cd95f524594f49 = []byte{
|
||||
// 2060 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x1a, 0x5b, 0x6f, 0x1b, 0x59,
|
||||
0xb9, 0xe3, 0x89, 0x13, 0xfb, 0xf3, 0x25, 0xc9, 0x21, 0x64, 0x8d, 0xdb, 0xa6, 0xe9, 0xb0, 0xdb,
|
||||
0xcd, 0x16, 0x36, 0xd9, 0xba, 0x20, 0x2e, 0x65, 0x41, 0xdb, 0xb8, 0x8d, 0x2c, 0x92, 0x12, 0x4e,
|
||||
0xba, 0xbb, 0x12, 0x2b, 0x64, 0x4d, 0x3c, 0x27, 0xce, 0x90, 0xb9, 0x78, 0xe7, 0x8c, 0xd3, 0xf4,
|
||||
0x69, 0x57, 0x8b, 0x04, 0x02, 0x21, 0x2e, 0x42, 0xbc, 0x21, 0x71, 0x91, 0x90, 0x90, 0x78, 0xe1,
|
||||
0x1f, 0xf0, 0xca, 0xcf, 0x42, 0xe7, 0x32, 0xf7, 0xb1, 0x3d, 0x71, 0x68, 0xf3, 0x96, 0x73, 0xe6,
|
||||
0xbb, 0x9d, 0xef, 0xfe, 0x7d, 0x0e, 0xac, 0x18, 0xba, 0xaf, 0xf7, 0x07, 0xae, 0xeb, 0x19, 0xdb,
|
||||
0x23, 0xcf, 0xf5, 0x5d, 0xb4, 0x6a, 0x9b, 0xd6, 0xf9, 0x98, 0x8a, 0xd3, 0x36, 0xfb, 0xdc, 0xae,
|
||||
0x0f, 0x5c, 0xdb, 0x76, 0x1d, 0x71, 0xd5, 0x6e, 0x9a, 0x8e, 0x4f, 0x3c, 0x47, 0xb7, 0xe4, 0xb9,
|
||||
0x1e, 0x47, 0x68, 0xd7, 0xe9, 0xe0, 0x94, 0xd8, 0xba, 0x38, 0x69, 0x17, 0x50, 0x7f, 0x6a, 0x8d,
|
||||
0xe9, 0x29, 0x26, 0x9f, 0x8e, 0x09, 0xf5, 0xd1, 0x7b, 0xb0, 0x70, 0xac, 0x53, 0xd2, 0x52, 0x36,
|
||||
0x95, 0xad, 0x5a, 0xe7, 0xd6, 0x76, 0x82, 0x97, 0xe4, 0x72, 0x40, 0x87, 0x8f, 0x75, 0x4a, 0x30,
|
||||
0x87, 0x44, 0x08, 0x16, 0x8c, 0xe3, 0x5e, 0xb7, 0x55, 0xda, 0x54, 0xb6, 0x54, 0xcc, 0xff, 0x46,
|
||||
0x1a, 0xd4, 0x07, 0xae, 0x65, 0x91, 0x81, 0x6f, 0xba, 0x4e, 0xaf, 0xdb, 0x5a, 0xe0, 0xdf, 0x12,
|
||||
0x77, 0xda, 0x9f, 0x15, 0x68, 0x48, 0xd6, 0x74, 0xe4, 0x3a, 0x94, 0xa0, 0x87, 0xb0, 0x48, 0x7d,
|
||||
0xdd, 0x1f, 0x53, 0xc9, 0xfd, 0x66, 0x2e, 0xf7, 0x23, 0x0e, 0x82, 0x25, 0x68, 0x21, 0xf6, 0x6a,
|
||||
0x96, 0x3d, 0xda, 0x00, 0xa0, 0x64, 0x68, 0x13, 0xc7, 0xef, 0x75, 0x69, 0x6b, 0x61, 0x53, 0xdd,
|
||||
0x52, 0x71, 0xec, 0x46, 0xfb, 0x83, 0x02, 0x2b, 0x47, 0xc1, 0x31, 0xd0, 0xce, 0x1a, 0x94, 0x07,
|
||||
0xee, 0xd8, 0xf1, 0xb9, 0x80, 0x0d, 0x2c, 0x0e, 0xe8, 0x2e, 0xd4, 0x07, 0xa7, 0xba, 0xe3, 0x10,
|
||||
0xab, 0xef, 0xe8, 0x36, 0xe1, 0xa2, 0x54, 0x71, 0x4d, 0xde, 0x3d, 0xd3, 0x6d, 0x52, 0x48, 0xa2,
|
||||
0x4d, 0xa8, 0x8d, 0x74, 0xcf, 0x37, 0x13, 0x3a, 0x8b, 0x5f, 0x69, 0x7f, 0x55, 0x60, 0xfd, 0x03,
|
||||
0x4a, 0xcd, 0xa1, 0x93, 0x91, 0x6c, 0x1d, 0x16, 0x1d, 0xd7, 0x20, 0xbd, 0x2e, 0x17, 0x4d, 0xc5,
|
||||
0xf2, 0x84, 0x6e, 0x42, 0x75, 0x44, 0x88, 0xd7, 0xf7, 0x5c, 0x2b, 0x10, 0xac, 0xc2, 0x2e, 0xb0,
|
||||
0x6b, 0x11, 0xf4, 0x63, 0x58, 0xa5, 0x29, 0x42, 0xb4, 0xa5, 0x6e, 0xaa, 0x5b, 0xb5, 0xce, 0x57,
|
||||
0xb7, 0x33, 0x5e, 0xb6, 0x9d, 0x66, 0x8a, 0xb3, 0xd8, 0xda, 0xe7, 0x25, 0xf8, 0x52, 0x08, 0x27,
|
||||
0x64, 0x65, 0x7f, 0x33, 0xcd, 0x51, 0x32, 0x0c, 0xc5, 0x13, 0x87, 0x22, 0x9a, 0x0b, 0x55, 0xae,
|
||||
0xc6, 0x55, 0x5e, 0xc0, 0xc1, 0xd2, 0xfa, 0x2c, 0x67, 0xf4, 0x89, 0xee, 0x40, 0x8d, 0x5c, 0x8c,
|
||||
0x4c, 0x8f, 0xf4, 0x7d, 0xd3, 0x26, 0xad, 0xc5, 0x4d, 0x65, 0x6b, 0x01, 0x83, 0xb8, 0x7a, 0x6e,
|
||||
0xda, 0x71, 0x8f, 0x5c, 0x2a, 0xec, 0x91, 0xda, 0xdf, 0x15, 0x78, 0x23, 0x63, 0x25, 0xe9, 0xe2,
|
||||
0x18, 0x56, 0xf8, 0xcb, 0x23, 0xcd, 0x30, 0x67, 0x67, 0x0a, 0xbf, 0x37, 0x4d, 0xe1, 0x11, 0x38,
|
||||
0xce, 0xe0, 0xc7, 0x84, 0x2c, 0x15, 0x17, 0xf2, 0x0c, 0xde, 0xd8, 0x23, 0xbe, 0x64, 0xc0, 0xbe,
|
||||
0x11, 0x3a, 0x7f, 0x0a, 0x48, 0xc6, 0x52, 0x29, 0x13, 0x4b, 0xff, 0x2e, 0x85, 0xb1, 0xc4, 0x59,
|
||||
0xf5, 0x9c, 0x13, 0x17, 0xdd, 0x82, 0x6a, 0x08, 0x22, 0xbd, 0x22, 0xba, 0x40, 0xdf, 0x82, 0x32,
|
||||
0x93, 0x54, 0xb8, 0x44, 0xb3, 0x73, 0x37, 0xff, 0x4d, 0x31, 0x9a, 0x58, 0xc0, 0xa3, 0x1e, 0x34,
|
||||
0xa9, 0xaf, 0x7b, 0x7e, 0x7f, 0xe4, 0x52, 0x6e, 0x67, 0xee, 0x38, 0xb5, 0x8e, 0x96, 0xa4, 0x10,
|
||||
0xa6, 0xc8, 0x03, 0x3a, 0x3c, 0x94, 0x90, 0xb8, 0xc1, 0x31, 0x83, 0x23, 0x7a, 0x02, 0x75, 0xe2,
|
||||
0x18, 0x11, 0xa1, 0x85, 0xc2, 0x84, 0x6a, 0xc4, 0x31, 0x42, 0x32, 0x91, 0x7d, 0xca, 0xc5, 0xed,
|
||||
0xf3, 0x1b, 0x05, 0x5a, 0x59, 0x03, 0x5d, 0x25, 0x51, 0x3e, 0x12, 0x48, 0x44, 0x18, 0x68, 0x6a,
|
||||
0x84, 0x87, 0x46, 0xc2, 0x12, 0x45, 0x33, 0xe1, 0xcb, 0x91, 0x34, 0xfc, 0xcb, 0x2b, 0x73, 0x96,
|
||||
0x9f, 0x2b, 0xb0, 0x9e, 0xe6, 0x75, 0x95, 0x77, 0x7f, 0x03, 0xca, 0xa6, 0x73, 0xe2, 0x06, 0xcf,
|
||||
0xde, 0x98, 0x12, 0x67, 0x8c, 0x97, 0x00, 0xd6, 0x6c, 0xb8, 0xb9, 0x47, 0xfc, 0x9e, 0x43, 0x89,
|
||||
0xe7, 0x3f, 0x36, 0x1d, 0xcb, 0x1d, 0x1e, 0xea, 0xfe, 0xe9, 0x15, 0x62, 0x24, 0xe1, 0xee, 0xa5,
|
||||
0x94, 0xbb, 0x6b, 0xff, 0x54, 0xe0, 0x56, 0x3e, 0x3f, 0xf9, 0xf4, 0x36, 0x54, 0x4e, 0x4c, 0x62,
|
||||
0x19, 0x4c, 0x67, 0x0a, 0xd7, 0x59, 0x78, 0x66, 0xb1, 0x32, 0x62, 0xc0, 0xf2, 0x85, 0x77, 0x27,
|
||||
0x38, 0xe8, 0x91, 0xef, 0x99, 0xce, 0x70, 0xdf, 0xa4, 0x3e, 0x16, 0xf0, 0x31, 0x7d, 0xaa, 0xc5,
|
||||
0x3d, 0xf3, 0xd7, 0x0a, 0x6c, 0xec, 0x11, 0x7f, 0x37, 0x4c, 0xb5, 0xec, 0xbb, 0x49, 0x7d, 0x73,
|
||||
0x40, 0x5f, 0x6d, 0x13, 0x91, 0x53, 0x33, 0xb5, 0xdf, 0x29, 0x70, 0x67, 0xa2, 0x30, 0x52, 0x75,
|
||||
0x32, 0x95, 0x04, 0x89, 0x36, 0x3f, 0x95, 0xfc, 0x90, 0xbc, 0xfc, 0x48, 0xb7, 0xc6, 0xe4, 0x50,
|
||||
0x37, 0x3d, 0x91, 0x4a, 0xe6, 0x4c, 0xac, 0xff, 0x52, 0xe0, 0xf6, 0x1e, 0xf1, 0x0f, 0x83, 0x32,
|
||||
0x73, 0x8d, 0xda, 0x29, 0xd0, 0x51, 0xfc, 0x56, 0x18, 0x33, 0x57, 0xda, 0x6b, 0x51, 0xdf, 0x06,
|
||||
0x8f, 0x83, 0x58, 0x40, 0xee, 0x8a, 0x5e, 0x40, 0x2a, 0x4f, 0xfb, 0x53, 0x09, 0xea, 0x1f, 0xc9,
|
||||
0xfe, 0x80, 0x97, 0x91, 0xb4, 0x1e, 0x94, 0x7c, 0x3d, 0xc4, 0x5a, 0x8a, 0xbc, 0x2e, 0x63, 0x0f,
|
||||
0x1a, 0x94, 0x90, 0xb3, 0x79, 0x8a, 0x46, 0x9d, 0x21, 0x86, 0xc9, 0x7e, 0x1f, 0x56, 0xc7, 0xce,
|
||||
0x09, 0x6b, 0x6b, 0x89, 0x21, 0x5f, 0x21, 0xba, 0xcb, 0xd9, 0x99, 0x27, 0x8b, 0x88, 0xb6, 0x60,
|
||||
0x39, 0x4d, 0xab, 0xcc, 0x83, 0x3f, 0x7d, 0xad, 0xfd, 0x4a, 0x81, 0xf5, 0x8f, 0x75, 0x7f, 0x70,
|
||||
0xda, 0xb5, 0xa5, 0xc6, 0xae, 0xe0, 0x6f, 0xef, 0x43, 0xf5, 0x5c, 0x6a, 0x27, 0x48, 0x2a, 0x77,
|
||||
0x72, 0x84, 0x8f, 0xdb, 0x01, 0x47, 0x18, 0xac, 0x4d, 0x5d, 0xe3, 0x9d, 0x7d, 0x20, 0xdd, 0xeb,
|
||||
0xf7, 0xfc, 0x59, 0xdd, 0xfd, 0x05, 0x80, 0x14, 0xee, 0x80, 0x0e, 0xe7, 0x90, 0xeb, 0xdb, 0xb0,
|
||||
0x24, 0xa9, 0x49, 0xe7, 0x9e, 0x65, 0xdc, 0x00, 0x5c, 0x3b, 0x82, 0x75, 0x79, 0xff, 0x94, 0xe5,
|
||||
0x6f, 0x91, 0xeb, 0x0f, 0x88, 0xaf, 0xa3, 0x16, 0x2c, 0xc9, 0x94, 0x2e, 0x9d, 0x38, 0x38, 0xb2,
|
||||
0x3e, 0xf5, 0x98, 0xc3, 0xf5, 0x59, 0xde, 0x96, 0xfe, 0x0b, 0xc7, 0x61, 0x99, 0xd0, 0x7e, 0x0a,
|
||||
0x8d, 0x6e, 0x77, 0x3f, 0x46, 0xeb, 0x1e, 0x2c, 0x1b, 0x86, 0xd5, 0x8f, 0x63, 0x29, 0x1c, 0xab,
|
||||
0x61, 0x18, 0x56, 0x54, 0x5f, 0xd0, 0x9b, 0xd0, 0xf4, 0x69, 0x3f, 0x4b, 0xbc, 0xee, 0xd3, 0x08,
|
||||
0x4a, 0x3b, 0x80, 0x26, 0x17, 0x96, 0x1b, 0x75, 0x86, 0xac, 0x77, 0xa1, 0x1e, 0x23, 0x27, 0xdc,
|
||||
0xa7, 0x8a, 0x6b, 0x91, 0xb0, 0xbc, 0x82, 0x04, 0xed, 0x60, 0x44, 0x71, 0x7a, 0x3b, 0x78, 0x1b,
|
||||
0xc0, 0xa4, 0x7d, 0xe9, 0xf4, 0x5c, 0xc6, 0x0a, 0xae, 0x9a, 0xf4, 0xa9, 0xb8, 0x40, 0xdf, 0x81,
|
||||
0x45, 0xce, 0x5f, 0x84, 0x47, 0x26, 0x49, 0x71, 0x6b, 0x24, 0x5f, 0x80, 0x25, 0x82, 0xf6, 0x21,
|
||||
0xd4, 0xbb, 0xdd, 0xfd, 0x48, 0x8e, 0x22, 0xf9, 0xa4, 0xc0, 0x1b, 0x3f, 0x83, 0x66, 0x54, 0x94,
|
||||
0x78, 0xa2, 0x6a, 0x42, 0x29, 0x24, 0x57, 0xea, 0x75, 0xd1, 0xfb, 0xb0, 0x28, 0x26, 0x71, 0xe9,
|
||||
0x41, 0x6f, 0x25, 0x65, 0x96, 0x53, 0x7a, 0xac, 0xb2, 0xf1, 0x0b, 0x2c, 0x91, 0x98, 0x87, 0x87,
|
||||
0x89, 0x5c, 0x0c, 0x6d, 0x2a, 0x8e, 0xdd, 0x68, 0xff, 0x51, 0xa1, 0x16, 0x73, 0xc0, 0x0c, 0xfb,
|
||||
0xf4, 0x3b, 0x4b, 0xb3, 0xeb, 0x87, 0x9a, 0x9d, 0xa0, 0xde, 0x82, 0xa6, 0xc9, 0x7b, 0x96, 0xbe,
|
||||
0x8c, 0x7e, 0x5e, 0x64, 0xaa, 0xb8, 0x21, 0x6e, 0x65, 0x2a, 0x42, 0x1b, 0x50, 0x73, 0xc6, 0x76,
|
||||
0xdf, 0x3d, 0xe9, 0x7b, 0xee, 0x0b, 0x2a, 0x47, 0xb1, 0xaa, 0x33, 0xb6, 0x7f, 0x74, 0x82, 0xdd,
|
||||
0x17, 0x34, 0xea, 0xf6, 0x17, 0x2f, 0xd9, 0xed, 0x3f, 0x81, 0xba, 0x61, 0x5b, 0x51, 0xda, 0x5e,
|
||||
0x2a, 0xde, 0xa2, 0x1b, 0xb6, 0x15, 0x66, 0xed, 0x0d, 0xa8, 0xd9, 0xfa, 0x05, 0x13, 0xae, 0xef,
|
||||
0x8c, 0xed, 0x56, 0x45, 0xc8, 0x67, 0xeb, 0x17, 0xd8, 0x7d, 0xf1, 0x6c, 0x6c, 0xa3, 0x2d, 0x58,
|
||||
0xb1, 0x74, 0xea, 0xf7, 0xe3, 0xd3, 0x62, 0x95, 0x4f, 0x8b, 0x4d, 0x76, 0xff, 0x24, 0x9a, 0x18,
|
||||
0xb3, 0xe3, 0x07, 0xcc, 0x39, 0x7e, 0x68, 0x0f, 0xa1, 0xd6, 0xeb, 0x76, 0x98, 0x3b, 0xb1, 0x9e,
|
||||
0x2d, 0x63, 0xc0, 0x35, 0x28, 0x1f, 0xc6, 0xbc, 0xaf, 0x1c, 0xf8, 0xdd, 0x5a, 0xa4, 0xa7, 0xd8,
|
||||
0x2c, 0x93, 0x95, 0x4b, 0x99, 0x77, 0x2c, 0x9a, 0xde, 0xc9, 0xfe, 0x52, 0x85, 0xf5, 0x23, 0xfd,
|
||||
0x9c, 0xbc, 0xfa, 0xa6, 0xb9, 0x50, 0x21, 0xd8, 0x87, 0x55, 0x1e, 0xe8, 0x9d, 0x98, 0x3c, 0x53,
|
||||
0xea, 0x71, 0x4c, 0xe1, 0x38, 0x8b, 0x88, 0x7e, 0xc0, 0x1a, 0x09, 0x32, 0x38, 0x3b, 0x74, 0xcd,
|
||||
0xa0, 0x16, 0xd7, 0x3a, 0xb7, 0x73, 0xe8, 0xec, 0x86, 0x50, 0x38, 0x8e, 0x81, 0x0e, 0x61, 0x39,
|
||||
0x69, 0x06, 0xda, 0x5a, 0xe4, 0x44, 0xde, 0x9e, 0x3a, 0x8d, 0x45, 0xda, 0xc7, 0xcd, 0x84, 0x31,
|
||||
0x28, 0xcf, 0xc4, 0x32, 0x2d, 0x2e, 0xf1, 0xb4, 0x18, 0x1c, 0x59, 0x9a, 0x85, 0x48, 0x8e, 0x19,
|
||||
0x09, 0xf6, 0xfb, 0x50, 0x09, 0x3d, 0xa3, 0x54, 0xd8, 0x33, 0x42, 0x9c, 0x74, 0x84, 0xab, 0xa9,
|
||||
0x08, 0xd7, 0xbe, 0x50, 0xa0, 0xd1, 0xd5, 0x7d, 0xfd, 0x99, 0x6b, 0x90, 0xe7, 0x73, 0x16, 0xdd,
|
||||
0x02, 0xdb, 0xa2, 0x5b, 0x50, 0x65, 0xc1, 0x49, 0x7d, 0xdd, 0x1e, 0x71, 0x21, 0x16, 0x70, 0x74,
|
||||
0xc1, 0x46, 0xcb, 0x86, 0x4c, 0x49, 0x47, 0xe1, 0xf6, 0x90, 0x93, 0x12, 0xc5, 0x91, 0xff, 0x8d,
|
||||
0xbe, 0x9b, 0x5c, 0x3d, 0xbc, 0x99, 0x6b, 0x5e, 0x4e, 0x84, 0x37, 0x5c, 0x89, 0x7c, 0x54, 0x64,
|
||||
0x66, 0xf9, 0x5c, 0x81, 0x7a, 0xa0, 0x0a, 0x9e, 0x9a, 0x5b, 0xb0, 0xa4, 0x1b, 0x86, 0x47, 0x28,
|
||||
0x95, 0x72, 0x04, 0x47, 0xf6, 0xe5, 0x9c, 0x78, 0x34, 0x30, 0x8a, 0x8a, 0x83, 0x23, 0xfa, 0x1e,
|
||||
0x54, 0xc2, 0x0e, 0x4d, 0x6c, 0xec, 0x36, 0x27, 0xcb, 0x29, 0x7b, 0xec, 0x10, 0x43, 0xf3, 0xa0,
|
||||
0x29, 0x9d, 0x4b, 0x78, 0x37, 0x9d, 0xe1, 0x1d, 0x8f, 0xa1, 0x7e, 0x12, 0x75, 0x2b, 0xd3, 0x46,
|
||||
0xe9, 0x58, 0x53, 0x83, 0x13, 0x38, 0xda, 0x07, 0x50, 0x8b, 0x7d, 0x9c, 0xd2, 0x41, 0xb4, 0x60,
|
||||
0xe9, 0x38, 0xc6, 0xa7, 0x8a, 0x83, 0xa3, 0xf6, 0x5f, 0x85, 0x6f, 0xad, 0x30, 0x19, 0xb8, 0xe7,
|
||||
0xc4, 0x7b, 0x79, 0xf5, 0xdd, 0xc0, 0xa3, 0x98, 0x16, 0x0b, 0xf6, 0xb9, 0x21, 0x02, 0x7a, 0x14,
|
||||
0xc9, 0xa9, 0x4e, 0xec, 0x3a, 0x92, 0x6a, 0x8e, 0x9e, 0xf2, 0x7b, 0xb1, 0xe5, 0x48, 0x3e, 0x65,
|
||||
0xde, 0x34, 0xf9, 0x7f, 0xa9, 0xe5, 0xda, 0x1f, 0x15, 0xf8, 0xca, 0x1e, 0xf1, 0x9f, 0x26, 0x27,
|
||||
0x8b, 0xeb, 0x96, 0xca, 0x86, 0x76, 0x9e, 0x50, 0x57, 0xb1, 0x7a, 0x1b, 0x2a, 0x34, 0x18, 0xa7,
|
||||
0xc4, 0xfe, 0x29, 0x3c, 0x6b, 0xbf, 0x50, 0xa0, 0x15, 0xef, 0x4d, 0x77, 0x5d, 0x7b, 0x64, 0x11,
|
||||
0x9f, 0x18, 0xaf, 0x7b, 0x4e, 0xf8, 0x8b, 0x02, 0x2b, 0xf1, 0x34, 0xc3, 0x33, 0xc5, 0x37, 0xa1,
|
||||
0xcc, 0xc7, 0x2c, 0x29, 0xc1, 0x4c, 0x67, 0x15, 0xd0, 0x2c, 0xa2, 0x78, 0xd5, 0x78, 0x4e, 0x83,
|
||||
0x34, 0x22, 0x8f, 0x51, 0xae, 0x53, 0x2f, 0x9d, 0xeb, 0xee, 0x3f, 0x80, 0xd5, 0xcc, 0x37, 0xd4,
|
||||
0x04, 0xf8, 0xd0, 0x19, 0x48, 0xa5, 0xad, 0xdc, 0x40, 0x75, 0xa8, 0x04, 0x2a, 0x5c, 0x51, 0x3a,
|
||||
0x7f, 0xab, 0x43, 0x95, 0xa5, 0xbe, 0x5d, 0xd7, 0xf5, 0x0c, 0x34, 0x02, 0xc4, 0x77, 0x37, 0xf6,
|
||||
0xc8, 0x75, 0xc2, 0x25, 0x27, 0x7a, 0x6f, 0x42, 0xdd, 0xc9, 0x82, 0x4a, 0xd7, 0x6c, 0xdf, 0x9b,
|
||||
0x80, 0x91, 0x02, 0xd7, 0x6e, 0x20, 0x9b, 0x73, 0x64, 0x8d, 0xda, 0x73, 0x73, 0x70, 0x16, 0x74,
|
||||
0xa7, 0x53, 0x38, 0xa6, 0x40, 0x03, 0x8e, 0xa9, 0xdd, 0xa9, 0x3c, 0x88, 0x05, 0x5b, 0xe0, 0x9b,
|
||||
0xda, 0x0d, 0xf4, 0x29, 0xac, 0xed, 0x11, 0x3f, 0xda, 0xa9, 0x04, 0x0c, 0x3b, 0x93, 0x19, 0x66,
|
||||
0x80, 0x2f, 0xc9, 0x72, 0x1f, 0xca, 0xdc, 0x6f, 0x51, 0x9e, 0x6f, 0xc4, 0x7f, 0xe9, 0x6b, 0x6f,
|
||||
0x4e, 0x06, 0x08, 0xa9, 0xfd, 0x0c, 0x96, 0x53, 0xbf, 0x64, 0xa0, 0x77, 0x72, 0xd0, 0xf2, 0x7f,
|
||||
0x93, 0x6a, 0xdf, 0x2f, 0x02, 0x1a, 0xf2, 0x1a, 0x42, 0x33, 0xb9, 0xf9, 0x41, 0x5b, 0x39, 0xf8,
|
||||
0xb9, 0x5b, 0xe8, 0xf6, 0x3b, 0x05, 0x20, 0x43, 0x46, 0x36, 0xac, 0xa4, 0x37, 0xeb, 0xe8, 0xfe,
|
||||
0x54, 0x02, 0x49, 0x77, 0xfb, 0x5a, 0x21, 0xd8, 0x90, 0xdd, 0x4b, 0xee, 0x04, 0x99, 0xcd, 0x2e,
|
||||
0xda, 0xce, 0x27, 0x33, 0x69, 0xe5, 0xdc, 0xde, 0x29, 0x0c, 0x1f, 0xb2, 0xfe, 0x42, 0xd4, 0xcb,
|
||||
0xbc, 0xed, 0x28, 0x7a, 0x90, 0x4f, 0x6e, 0xca, 0x5a, 0xb7, 0xdd, 0xb9, 0x0c, 0x4a, 0x28, 0xc4,
|
||||
0x67, 0xbc, 0xd0, 0xe5, 0x6c, 0x18, 0xd3, 0x71, 0x17, 0xd0, 0x9b, 0xbc, 0x3a, 0x6d, 0x3f, 0xb8,
|
||||
0x04, 0x46, 0x28, 0x80, 0x9b, 0xfe, 0xed, 0x22, 0x08, 0xc3, 0x9d, 0x99, 0x5e, 0x33, 0x5f, 0x0c,
|
||||
0x7e, 0x02, 0xcb, 0xa9, 0x09, 0x28, 0x37, 0x6a, 0xf2, 0xa7, 0xa4, 0xf6, 0xb4, 0x12, 0x26, 0x42,
|
||||
0x32, 0xd5, 0x37, 0xa0, 0x09, 0xde, 0x9f, 0xd3, 0x5b, 0xb4, 0xef, 0x17, 0x01, 0x0d, 0x1f, 0x42,
|
||||
0x79, 0xba, 0x4c, 0xd5, 0x5e, 0xf4, 0xf5, 0x7c, 0x1a, 0xf9, 0x7d, 0x43, 0xfb, 0xdd, 0x82, 0xd0,
|
||||
0x01, 0xd3, 0xce, 0x3f, 0x54, 0xa8, 0x04, 0xed, 0xf1, 0x35, 0x94, 0x88, 0x6b, 0xc8, 0xd9, 0x9f,
|
||||
0xc0, 0x72, 0x6a, 0x75, 0x9b, 0x6b, 0xd2, 0xfc, 0xf5, 0xee, 0x2c, 0x7f, 0xf9, 0x58, 0xfe, 0x97,
|
||||
0x45, 0x68, 0xbe, 0xb7, 0x27, 0xe5, 0xfd, 0xb4, 0xe5, 0xa6, 0x13, 0x7e, 0xfc, 0xf0, 0x27, 0x0f,
|
||||
0x86, 0xa6, 0x7f, 0x3a, 0x3e, 0x66, 0x5f, 0x76, 0x04, 0xe8, 0xbb, 0xa6, 0x2b, 0xff, 0xda, 0x09,
|
||||
0x14, 0xb4, 0xc3, 0xb1, 0x77, 0x18, 0x9b, 0xd1, 0xf1, 0xf1, 0x22, 0x3f, 0x3d, 0xfc, 0x5f, 0x00,
|
||||
0x00, 0x00, 0xff, 0xff, 0x91, 0x15, 0x9b, 0xbf, 0xd6, 0x22, 0x00, 0x00,
|
||||
// 1945 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xdb, 0x6f, 0x23, 0x57,
|
||||
0x19, 0xdf, 0xf1, 0xe4, 0x62, 0x7f, 0x76, 0x9c, 0xe4, 0xb0, 0xa4, 0x66, 0x76, 0x9b, 0xcd, 0x0e,
|
||||
0xb4, 0x75, 0x17, 0x9a, 0x74, 0xbd, 0x20, 0x2a, 0x96, 0x82, 0xba, 0x71, 0x37, 0xb2, 0xc8, 0x2e,
|
||||
0xe1, 0x64, 0xdb, 0x4a, 0xf4, 0xc1, 0x1a, 0xdb, 0x27, 0xce, 0x10, 0xcf, 0x8c, 0x3b, 0x67, 0x9c,
|
||||
0xcd, 0x3e, 0x6d, 0x55, 0x24, 0x10, 0x08, 0x71, 0x11, 0xe2, 0x0d, 0x89, 0x8b, 0x84, 0x84, 0xc4,
|
||||
0x0b, 0x7f, 0x06, 0xff, 0x12, 0x6f, 0xe8, 0x5c, 0xe6, 0xcc, 0xd5, 0xf6, 0xc4, 0x61, 0x9b, 0x37,
|
||||
0x9f, 0x33, 0xdf, 0xed, 0x7c, 0xe7, 0xbb, 0xfc, 0xce, 0x67, 0xd8, 0x18, 0x58, 0x81, 0xd5, 0xed,
|
||||
0x7b, 0x9e, 0x3f, 0xd8, 0x1d, 0xfb, 0x5e, 0xe0, 0xa1, 0x4d, 0xc7, 0x1e, 0x9d, 0x4f, 0xa8, 0x58,
|
||||
0xed, 0xb2, 0xcf, 0x46, 0xad, 0xef, 0x39, 0x8e, 0xe7, 0x8a, 0x2d, 0xa3, 0x6e, 0xbb, 0x01, 0xf1,
|
||||
0x5d, 0x6b, 0x24, 0xd7, 0xb5, 0x38, 0x83, 0x51, 0xa3, 0xfd, 0x53, 0xe2, 0x58, 0x62, 0x65, 0x5e,
|
||||
0x40, 0xed, 0xf1, 0x68, 0x42, 0x4f, 0x31, 0xf9, 0x6c, 0x42, 0x68, 0x80, 0xde, 0x85, 0xa5, 0x9e,
|
||||
0x45, 0x49, 0x43, 0xdb, 0xd1, 0x9a, 0xd5, 0xd6, 0xed, 0xdd, 0x84, 0x2e, 0xa9, 0xe5, 0x09, 0x1d,
|
||||
0x3e, 0xb2, 0x28, 0xc1, 0x9c, 0x12, 0x21, 0x58, 0x1a, 0xf4, 0x3a, 0xed, 0x46, 0x69, 0x47, 0x6b,
|
||||
0xea, 0x98, 0xff, 0x46, 0x26, 0xd4, 0xfa, 0xde, 0x68, 0x44, 0xfa, 0x81, 0xed, 0xb9, 0x9d, 0x76,
|
||||
0x63, 0x89, 0x7f, 0x4b, 0xec, 0x99, 0x7f, 0xd6, 0x60, 0x4d, 0xaa, 0xa6, 0x63, 0xcf, 0xa5, 0x04,
|
||||
0x3d, 0x80, 0x15, 0x1a, 0x58, 0xc1, 0x84, 0x4a, 0xed, 0xb7, 0x72, 0xb5, 0x1f, 0x73, 0x12, 0x2c,
|
||||
0x49, 0x0b, 0xa9, 0xd7, 0xb3, 0xea, 0xd1, 0x36, 0x00, 0x25, 0x43, 0x87, 0xb8, 0x41, 0xa7, 0x4d,
|
||||
0x1b, 0x4b, 0x3b, 0x7a, 0x53, 0xc7, 0xb1, 0x1d, 0xf3, 0x0f, 0x1a, 0x6c, 0x1c, 0x87, 0xcb, 0xd0,
|
||||
0x3b, 0x37, 0x61, 0xb9, 0xef, 0x4d, 0xdc, 0x80, 0x1b, 0xb8, 0x86, 0xc5, 0x02, 0xdd, 0x85, 0x5a,
|
||||
0xff, 0xd4, 0x72, 0x5d, 0x32, 0xea, 0xba, 0x96, 0x43, 0xb8, 0x29, 0x15, 0x5c, 0x95, 0x7b, 0x4f,
|
||||
0x2d, 0x87, 0x14, 0xb2, 0x68, 0x07, 0xaa, 0x63, 0xcb, 0x0f, 0xec, 0x84, 0xcf, 0xe2, 0x5b, 0xe6,
|
||||
0x5f, 0x35, 0xd8, 0xfa, 0x80, 0x52, 0x7b, 0xe8, 0x66, 0x2c, 0xdb, 0x82, 0x15, 0xd7, 0x1b, 0x90,
|
||||
0x4e, 0x9b, 0x9b, 0xa6, 0x63, 0xb9, 0x42, 0xb7, 0xa0, 0x32, 0x26, 0xc4, 0xef, 0xfa, 0xde, 0x28,
|
||||
0x34, 0xac, 0xcc, 0x36, 0xb0, 0x37, 0x22, 0xe8, 0x27, 0xb0, 0x49, 0x53, 0x82, 0x68, 0x43, 0xdf,
|
||||
0xd1, 0x9b, 0xd5, 0xd6, 0xd7, 0x77, 0x33, 0x51, 0xb6, 0x9b, 0x56, 0x8a, 0xb3, 0xdc, 0xe6, 0xe7,
|
||||
0x25, 0xf8, 0x8a, 0xa2, 0x13, 0xb6, 0xb2, 0xdf, 0xcc, 0x73, 0x94, 0x0c, 0x95, 0x79, 0x62, 0x51,
|
||||
0xc4, 0x73, 0xca, 0xe5, 0x7a, 0xdc, 0xe5, 0x05, 0x02, 0x2c, 0xed, 0xcf, 0xe5, 0x8c, 0x3f, 0xd1,
|
||||
0x1d, 0xa8, 0x92, 0x8b, 0xb1, 0xed, 0x93, 0x6e, 0x60, 0x3b, 0xa4, 0xb1, 0xb2, 0xa3, 0x35, 0x97,
|
||||
0x30, 0x88, 0xad, 0x67, 0xb6, 0x13, 0x8f, 0xc8, 0xd5, 0xc2, 0x11, 0x69, 0xfe, 0x5d, 0x83, 0xd7,
|
||||
0x32, 0xb7, 0x24, 0x43, 0x1c, 0xc3, 0x06, 0x3f, 0x79, 0xe4, 0x19, 0x16, 0xec, 0xcc, 0xe1, 0x6f,
|
||||
0xce, 0x72, 0x78, 0x44, 0x8e, 0x33, 0xfc, 0x31, 0x23, 0x4b, 0xc5, 0x8d, 0x3c, 0x83, 0xd7, 0x0e,
|
||||
0x48, 0x20, 0x15, 0xb0, 0x6f, 0x84, 0x2e, 0x5e, 0x02, 0x92, 0xb9, 0x54, 0xca, 0xe4, 0xd2, 0xbf,
|
||||
0x4b, 0x2a, 0x97, 0xb8, 0xaa, 0x8e, 0x7b, 0xe2, 0xa1, 0xdb, 0x50, 0x51, 0x24, 0x32, 0x2a, 0xa2,
|
||||
0x0d, 0xf4, 0x5d, 0x58, 0x66, 0x96, 0x8a, 0x90, 0xa8, 0xb7, 0xee, 0xe6, 0x9f, 0x29, 0x26, 0x13,
|
||||
0x0b, 0x7a, 0xd4, 0x81, 0x3a, 0x0d, 0x2c, 0x3f, 0xe8, 0x8e, 0x3d, 0xca, 0xef, 0x99, 0x07, 0x4e,
|
||||
0xb5, 0x65, 0x26, 0x25, 0xa8, 0x12, 0xf9, 0x84, 0x0e, 0x8f, 0x24, 0x25, 0x5e, 0xe3, 0x9c, 0xe1,
|
||||
0x12, 0x7d, 0x08, 0x35, 0xe2, 0x0e, 0x22, 0x41, 0x4b, 0x85, 0x05, 0x55, 0x89, 0x3b, 0x50, 0x62,
|
||||
0xa2, 0xfb, 0x59, 0x2e, 0x7e, 0x3f, 0xbf, 0xd1, 0xa0, 0x91, 0xbd, 0xa0, 0xab, 0x14, 0xca, 0x87,
|
||||
0x82, 0x89, 0x88, 0x0b, 0x9a, 0x99, 0xe1, 0xea, 0x92, 0xb0, 0x64, 0x31, 0x6d, 0xf8, 0x6a, 0x64,
|
||||
0x0d, 0xff, 0xf2, 0xca, 0x82, 0xe5, 0xe7, 0x1a, 0x6c, 0xa5, 0x75, 0x5d, 0xe5, 0xdc, 0xdf, 0x86,
|
||||
0x65, 0xdb, 0x3d, 0xf1, 0xc2, 0x63, 0x6f, 0xcf, 0xc8, 0x33, 0xa6, 0x4b, 0x10, 0x9b, 0x0e, 0xdc,
|
||||
0x3a, 0x20, 0x41, 0xc7, 0xa5, 0xc4, 0x0f, 0x1e, 0xd9, 0xee, 0xc8, 0x1b, 0x1e, 0x59, 0xc1, 0xe9,
|
||||
0x15, 0x72, 0x24, 0x11, 0xee, 0xa5, 0x54, 0xb8, 0x9b, 0xff, 0xd4, 0xe0, 0x76, 0xbe, 0x3e, 0x79,
|
||||
0x74, 0x03, 0xca, 0x27, 0x36, 0x19, 0x0d, 0x98, 0xcf, 0x34, 0xee, 0x33, 0xb5, 0x66, 0xb9, 0x32,
|
||||
0x66, 0xc4, 0xf2, 0x84, 0x77, 0xa7, 0x04, 0xe8, 0x71, 0xe0, 0xdb, 0xee, 0xf0, 0xd0, 0xa6, 0x01,
|
||||
0x16, 0xf4, 0x31, 0x7f, 0xea, 0xc5, 0x23, 0xf3, 0xd7, 0x1a, 0x6c, 0x1f, 0x90, 0x60, 0x5f, 0x95,
|
||||
0x5a, 0xf6, 0xdd, 0xa6, 0x81, 0xdd, 0xa7, 0xaf, 0x16, 0x44, 0xe4, 0xf4, 0x4c, 0xf3, 0x77, 0x1a,
|
||||
0xdc, 0x99, 0x6a, 0x8c, 0x74, 0x9d, 0x2c, 0x25, 0x61, 0xa1, 0xcd, 0x2f, 0x25, 0x3f, 0x22, 0x2f,
|
||||
0x3e, 0xb6, 0x46, 0x13, 0x72, 0x64, 0xd9, 0xbe, 0x28, 0x25, 0x0b, 0x16, 0xd6, 0x7f, 0x69, 0xf0,
|
||||
0xfa, 0x01, 0x09, 0x8e, 0xc2, 0x36, 0x73, 0x8d, 0xde, 0x29, 0x80, 0x28, 0x7e, 0x2b, 0x2e, 0x33,
|
||||
0xd7, 0xda, 0x6b, 0x71, 0xdf, 0x36, 0xcf, 0x83, 0x58, 0x42, 0xee, 0x0b, 0x2c, 0x20, 0x9d, 0x67,
|
||||
0xfe, 0xa9, 0x04, 0xb5, 0x8f, 0x25, 0x3e, 0xe0, 0x6d, 0x24, 0xed, 0x07, 0x2d, 0xdf, 0x0f, 0x31,
|
||||
0x48, 0x91, 0x87, 0x32, 0x0e, 0x60, 0x8d, 0x12, 0x72, 0xb6, 0x48, 0xd3, 0xa8, 0x31, 0x46, 0x55,
|
||||
0xec, 0x0f, 0x61, 0x73, 0xe2, 0x9e, 0x30, 0x58, 0x4b, 0x06, 0xf2, 0x14, 0x02, 0x5d, 0xce, 0xaf,
|
||||
0x3c, 0x59, 0x46, 0xd4, 0x84, 0xf5, 0xb4, 0xac, 0x65, 0x9e, 0xfc, 0xe9, 0x6d, 0xf3, 0x57, 0x1a,
|
||||
0x6c, 0x7d, 0x62, 0x05, 0xfd, 0xd3, 0xb6, 0x23, 0x3d, 0x76, 0x85, 0x78, 0x7b, 0x1f, 0x2a, 0xe7,
|
||||
0xd2, 0x3b, 0x61, 0x51, 0xb9, 0x93, 0x63, 0x7c, 0xfc, 0x1e, 0x70, 0xc4, 0xc1, 0x60, 0xea, 0x4d,
|
||||
0x8e, 0xec, 0x43, 0xeb, 0xbe, 0xfc, 0xc8, 0x9f, 0x87, 0xee, 0x2f, 0x00, 0xa4, 0x71, 0x4f, 0xe8,
|
||||
0x70, 0x01, 0xbb, 0xde, 0x83, 0x55, 0x29, 0x4d, 0x06, 0xf7, 0xbc, 0xcb, 0x0d, 0xc9, 0xcd, 0x8f,
|
||||
0xa0, 0xd6, 0x6e, 0x1f, 0x72, 0xf7, 0x3c, 0x21, 0x81, 0x55, 0x28, 0x7e, 0xef, 0x42, 0xad, 0xc7,
|
||||
0x7b, 0x42, 0x37, 0xaa, 0xf3, 0x15, 0x5c, 0xed, 0x45, 0x7d, 0xc2, 0x7c, 0x09, 0xf5, 0xa8, 0x08,
|
||||
0xf2, 0xc4, 0xa8, 0x43, 0x49, 0x89, 0x2b, 0x75, 0xda, 0xe8, 0x7d, 0x58, 0x11, 0x2f, 0x3f, 0x69,
|
||||
0xf1, 0x1b, 0x49, 0x8b, 0xe5, 0xab, 0x30, 0x56, 0x49, 0xf9, 0x06, 0x96, 0x4c, 0xcc, 0xa3, 0xaa,
|
||||
0x70, 0x88, 0x47, 0x82, 0x8e, 0x63, 0x3b, 0xe6, 0x7f, 0x75, 0xa8, 0xc6, 0x0e, 0x9c, 0x51, 0x9f,
|
||||
0x3e, 0x67, 0x69, 0x7e, 0xbd, 0xd2, 0xb3, 0x88, 0xfd, 0x0d, 0xa8, 0xdb, 0xbc, 0x47, 0x76, 0x65,
|
||||
0xb4, 0xf1, 0xa2, 0x56, 0xc1, 0x6b, 0x62, 0x57, 0x86, 0x3e, 0xda, 0x86, 0xaa, 0x3b, 0x71, 0xba,
|
||||
0xde, 0x49, 0xd7, 0xf7, 0x9e, 0x53, 0x09, 0xfd, 0x2b, 0xee, 0xc4, 0xf9, 0xf1, 0x09, 0xf6, 0x9e,
|
||||
0xd3, 0x08, 0x5d, 0xae, 0x5c, 0x12, 0x5d, 0x6e, 0x43, 0xd5, 0xb1, 0x2e, 0x98, 0xd4, 0xae, 0x3b,
|
||||
0x71, 0xf8, 0xab, 0x40, 0xc7, 0x15, 0xc7, 0xba, 0xc0, 0xde, 0xf3, 0xa7, 0x13, 0x07, 0x35, 0x61,
|
||||
0x63, 0x64, 0xd1, 0xa0, 0x1b, 0x7f, 0x56, 0x94, 0xf9, 0xb3, 0xa2, 0xce, 0xf6, 0x3f, 0x8c, 0x9e,
|
||||
0x16, 0x59, 0x9c, 0x5a, 0xb9, 0x02, 0x4e, 0x1d, 0x38, 0xa3, 0x48, 0x10, 0x14, 0xc7, 0xa9, 0x03,
|
||||
0x67, 0xa4, 0xc4, 0xbc, 0x07, 0xab, 0x22, 0xa2, 0x68, 0xa3, 0x3a, 0xb5, 0x60, 0x3d, 0x66, 0xa0,
|
||||
0x43, 0x00, 0x14, 0x1c, 0x92, 0x9b, 0x2f, 0xe1, 0x66, 0xe4, 0xac, 0x98, 0x61, 0xd9, 0x33, 0x6a,
|
||||
0x8b, 0x9e, 0x71, 0x36, 0x7c, 0xfa, 0xa5, 0x0e, 0x5b, 0xc7, 0xd6, 0x39, 0x79, 0xf5, 0x48, 0xad,
|
||||
0x50, 0xf5, 0x39, 0x84, 0x4d, 0x0e, 0xce, 0x5a, 0x31, 0x7b, 0x66, 0x34, 0x81, 0xb8, 0x4f, 0xb3,
|
||||
0x8c, 0xe8, 0x87, 0xac, 0x7b, 0x91, 0xfe, 0xd9, 0x91, 0x67, 0x87, 0x0d, 0xa0, 0xda, 0x7a, 0x3d,
|
||||
0x47, 0xce, 0xbe, 0xa2, 0xc2, 0x71, 0x0e, 0x74, 0x04, 0xeb, 0xc9, 0x6b, 0xa0, 0x8d, 0x15, 0x2e,
|
||||
0xe4, 0xad, 0x99, 0x4f, 0x80, 0xc8, 0xfb, 0xb8, 0x9e, 0xb8, 0x0c, 0x8a, 0x1a, 0xb0, 0x2a, 0x1b,
|
||||
0x10, 0x4f, 0x81, 0x32, 0x0e, 0x97, 0x0c, 0x1d, 0x42, 0x64, 0xc7, 0x9c, 0x47, 0xde, 0x0f, 0xa0,
|
||||
0xac, 0x22, 0xa3, 0x54, 0x38, 0x32, 0x14, 0x4f, 0x3a, 0xcd, 0xf5, 0x54, 0x9a, 0x9b, 0x5f, 0x68,
|
||||
0xb0, 0xd6, 0xb6, 0x02, 0xeb, 0xa9, 0x37, 0x20, 0xcf, 0x16, 0xac, 0xf4, 0x05, 0x46, 0x14, 0xb7,
|
||||
0xa1, 0xc2, 0x12, 0x9d, 0x06, 0x96, 0x33, 0xe6, 0x46, 0x2c, 0xe1, 0x68, 0x83, 0xbd, 0x67, 0xd6,
|
||||
0x64, 0x5d, 0x3a, 0x56, 0x23, 0x2b, 0x2e, 0x4a, 0xe3, 0xa2, 0xf8, 0x6f, 0xf4, 0xbd, 0xe4, 0x7b,
|
||||
0xf7, 0x1b, 0xb9, 0xd7, 0xcb, 0x85, 0xf0, 0x2e, 0x9f, 0x28, 0x4a, 0x45, 0x80, 0xf2, 0xe7, 0x1a,
|
||||
0xd4, 0x42, 0x57, 0xf0, 0xfa, 0xdc, 0x80, 0x55, 0x6b, 0x30, 0xf0, 0x09, 0xa5, 0xd2, 0x8e, 0x70,
|
||||
0xc9, 0xbe, 0x9c, 0x13, 0x9f, 0x86, 0x97, 0xa2, 0xe3, 0x70, 0x89, 0xbe, 0x0f, 0x65, 0x05, 0x0b,
|
||||
0xc4, 0x98, 0x68, 0x67, 0xba, 0x9d, 0x12, 0xd8, 0x29, 0x0e, 0xd3, 0x87, 0xba, 0x0c, 0x2e, 0x11,
|
||||
0xdd, 0x74, 0x4e, 0x74, 0x3c, 0x82, 0xda, 0x49, 0x94, 0x19, 0xb3, 0xde, 0x6f, 0xf1, 0x04, 0x4a,
|
||||
0xf0, 0x98, 0x1f, 0x40, 0x35, 0xf6, 0x91, 0xc7, 0xad, 0x78, 0x35, 0x49, 0x75, 0xe1, 0x92, 0x7d,
|
||||
0xe9, 0xc5, 0xf4, 0x54, 0xa2, 0xe2, 0xf6, 0x1f, 0x8d, 0x8f, 0x4a, 0x30, 0xe9, 0x7b, 0xe7, 0xc4,
|
||||
0x7f, 0x71, 0xf5, 0x07, 0xe9, 0xc3, 0x98, 0x17, 0x0b, 0x82, 0x2b, 0xc5, 0x80, 0x1e, 0x46, 0x76,
|
||||
0xea, 0x79, 0x78, 0x3c, 0x9e, 0xc3, 0xd2, 0x09, 0xd1, 0x51, 0x7e, 0x2f, 0x9e, 0xd6, 0xc9, 0xa3,
|
||||
0x2c, 0x5a, 0x26, 0xff, 0x2f, 0x0d, 0xdd, 0xfc, 0xa3, 0x06, 0x5f, 0x3b, 0x20, 0xc1, 0xe3, 0x24,
|
||||
0x9c, 0xbd, 0x6e, 0xab, 0x1c, 0x30, 0xf2, 0x8c, 0xba, 0xca, 0xad, 0x1b, 0x50, 0xa6, 0x21, 0x86,
|
||||
0x17, 0x43, 0x0f, 0xb5, 0x36, 0x7f, 0xa1, 0x41, 0x43, 0x6a, 0xe1, 0x3a, 0xf7, 0x3d, 0x67, 0x3c,
|
||||
0x22, 0x01, 0x19, 0x7c, 0xd9, 0xe0, 0xf4, 0x2f, 0x1a, 0x6c, 0xc4, 0xcb, 0x0c, 0xaf, 0x14, 0xdf,
|
||||
0x81, 0x65, 0x8e, 0xed, 0xa5, 0x05, 0x73, 0x83, 0x55, 0x50, 0xb3, 0x8c, 0xe2, 0x5d, 0xe3, 0x19,
|
||||
0x0d, 0xcb, 0x88, 0x5c, 0x46, 0xb5, 0x4e, 0xbf, 0x74, 0xad, 0xbb, 0x77, 0x1f, 0x36, 0x33, 0xdf,
|
||||
0x50, 0x1d, 0xe0, 0x23, 0xb7, 0x2f, 0x9d, 0xb6, 0x71, 0x03, 0xd5, 0xa0, 0x1c, 0xba, 0x70, 0x43,
|
||||
0x6b, 0xfd, 0xad, 0x06, 0x15, 0x56, 0xfa, 0xf6, 0x3d, 0xcf, 0x1f, 0xa0, 0x31, 0x20, 0x3e, 0x30,
|
||||
0x70, 0xc6, 0x9e, 0xab, 0x26, 0x6b, 0xe8, 0xdd, 0x29, 0x7d, 0x27, 0x4b, 0x2a, 0x43, 0xd3, 0x78,
|
||||
0x73, 0x0a, 0x47, 0x8a, 0xdc, 0xbc, 0x81, 0x1c, 0xae, 0x91, 0x81, 0xbe, 0x67, 0x76, 0xff, 0x2c,
|
||||
0x84, 0xa8, 0x33, 0x34, 0xa6, 0x48, 0x43, 0x8d, 0xa9, 0x81, 0x9d, 0x5c, 0x88, 0xa9, 0x4e, 0x18,
|
||||
0x9b, 0xe6, 0x0d, 0xf4, 0x19, 0xdc, 0x64, 0x2f, 0x68, 0xf5, 0x90, 0x0f, 0x15, 0xb6, 0xa6, 0x2b,
|
||||
0xcc, 0x10, 0x5f, 0x52, 0xe5, 0x21, 0x2c, 0xf3, 0xb8, 0x45, 0x79, 0xb1, 0x11, 0xff, 0x7b, 0xc9,
|
||||
0xd8, 0x99, 0x4e, 0xa0, 0xa4, 0xfd, 0x0c, 0xd6, 0x53, 0xe3, 0x73, 0xf4, 0x76, 0x0e, 0x5b, 0xfe,
|
||||
0x1f, 0x21, 0xc6, 0xbd, 0x22, 0xa4, 0x4a, 0xd7, 0x10, 0xea, 0xc9, 0x71, 0x03, 0x6a, 0xe6, 0xf0,
|
||||
0xe7, 0x8e, 0x3e, 0x8d, 0xb7, 0x0b, 0x50, 0x2a, 0x45, 0x0e, 0x6c, 0xa4, 0xc7, 0xb9, 0xe8, 0xde,
|
||||
0x4c, 0x01, 0xc9, 0x70, 0xfb, 0x66, 0x21, 0x5a, 0xa5, 0xee, 0x05, 0x0f, 0x82, 0xcc, 0x38, 0x11,
|
||||
0xed, 0xe6, 0x8b, 0x99, 0x36, 0xe7, 0x34, 0xf6, 0x0a, 0xd3, 0x2b, 0xd5, 0x5f, 0x88, 0x7e, 0x99,
|
||||
0x37, 0x92, 0x43, 0xf7, 0xf3, 0xc5, 0xcd, 0x98, 0x25, 0x1a, 0xad, 0xcb, 0xb0, 0x28, 0x23, 0x5e,
|
||||
0xf2, 0x46, 0x97, 0x33, 0xd6, 0x4a, 0xe7, 0x5d, 0x28, 0x6f, 0xfa, 0xbc, 0xce, 0xb8, 0x7f, 0x09,
|
||||
0x0e, 0x65, 0x80, 0x97, 0x1e, 0x98, 0x87, 0x69, 0xb8, 0x37, 0x37, 0x6a, 0x16, 0xcb, 0xc1, 0x4f,
|
||||
0x61, 0x3d, 0xf5, 0x02, 0xca, 0xcd, 0x9a, 0xfc, 0x57, 0x92, 0x31, 0xab, 0x85, 0x89, 0x94, 0x4c,
|
||||
0xe1, 0x06, 0x34, 0x25, 0xfa, 0x73, 0xb0, 0x85, 0x71, 0xaf, 0x08, 0xa9, 0x3a, 0x08, 0xe5, 0xe5,
|
||||
0x32, 0xd5, 0x7b, 0xd1, 0xb7, 0xf2, 0x65, 0xe4, 0xe3, 0x06, 0xe3, 0x9d, 0x82, 0xd4, 0xa1, 0xd2,
|
||||
0xd6, 0x3f, 0x74, 0x28, 0x87, 0xf0, 0xf8, 0x1a, 0x5a, 0xc4, 0x35, 0xd4, 0xec, 0x4f, 0x61, 0x3d,
|
||||
0x35, 0x2f, 0xcc, 0xbd, 0xd2, 0xfc, 0x99, 0xe2, 0xbc, 0x78, 0xf9, 0x44, 0xfe, 0xb5, 0xaf, 0xae,
|
||||
0xef, 0xad, 0x69, 0x75, 0x3f, 0x7d, 0x73, 0xb3, 0x05, 0x3f, 0x7a, 0xf0, 0xd3, 0xfb, 0x43, 0x3b,
|
||||
0x38, 0x9d, 0xf4, 0xd8, 0x97, 0x3d, 0x41, 0xfa, 0x8e, 0xed, 0xc9, 0x5f, 0x7b, 0xa1, 0x83, 0xf6,
|
||||
0x38, 0xf7, 0x1e, 0x53, 0x33, 0xee, 0xf5, 0x56, 0xf8, 0xea, 0xc1, 0xff, 0x02, 0x00, 0x00, 0xff,
|
||||
0xff, 0x2a, 0xb9, 0xcc, 0x2e, 0x4b, 0x21, 0x00, 0x00,
|
||||
}
|
||||
|
||||
// Reference imports to suppress errors if they are not otherwise used.
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user