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

Add DropVirtualChannel for DataCoord (#12361) 

Signed-off-by: Congqi Xia <congqi.xia@zilliz.com>
pull/12416/head
congqixia 2021-11-29 22:35:41 +08:00 committed by GitHub
parent c4f0837d84
commit 06ced4d1d1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 865 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
internal/datacoord/channel_store.go
View File

@ -319,7 +319,7 @@ func (c *ChannelStore) remove(nodeID int64) error {
func (c *ChannelStore) txn(opSet ChannelOpSet) error {
saves := make(map[string]string)
removals := make([]string, 0)
var removals []string
for _, update := range opSet {
for i, c := range update.Channels {
k := buildChannelKey(update.NodeID, c.Name)

156
internal/datacoord/meta.go
View File

@ -36,6 +36,7 @@ import (
const (
metaPrefix = "datacoord-meta"
segmentPrefix = metaPrefix + "/s"
channelRemovePrefix = metaPrefix + "/channel-removal"
handoffSegmentPrefix = "querycoord-handoff"
)
@ -334,6 +335,153 @@ func (m *meta) UpdateFlushSegmentsInfo(
return nil
}
// UpdateDropChannelSegmentInfo updates segment checkpoints and binlogs before drop
// reusing segment info to pass segment id, binlogs, statslog, deltalog, start position and checkpoint
func (m *meta) UpdateDropChannelSegmentInfo(channel string, segments []*SegmentInfo) error {
m.Lock()
defer m.Unlock()
modSegments := make(map[UniqueID]*SegmentInfo)
for _, seg2Drop := range segments {
segment := m.mergeDropSegment(seg2Drop)
if segment != nil {
modSegments[seg2Drop.GetID()] = segment
}
}
return m.batchSaveDropSegments(channel, modSegments)
}
// mergeDropSegment merges drop segment information with meta segments
func (m *meta) mergeDropSegment(seg2Drop *SegmentInfo) *SegmentInfo {
segment := m.segments.GetSegment(seg2Drop.ID)
// healthy check makes sure the Idempotence
if segment == nil || !isSegmentHealthy(segment) {
log.Warn("UpdateDropChannel skipping nil or unhealthy", zap.Bool("is nil", segment == nil),
zap.Bool("isHealthy", isSegmentHealthy(segment)))
return nil
}
clonedSegment := segment.Clone()
clonedSegment.State = commonpb.SegmentState_Dropped
currBinlogs := clonedSegment.GetBinlogs()
var getFieldBinlogs = func(id UniqueID, binlogs []*datapb.FieldBinlog) *datapb.FieldBinlog {
for _, binlog := range binlogs {
if id == binlog.GetFieldID() {
return binlog
}
}
return nil
}
// binlogs
for _, tBinlogs := range seg2Drop.GetBinlogs() {
fieldBinlogs := getFieldBinlogs(tBinlogs.GetFieldID(), currBinlogs)
if fieldBinlogs == nil {
currBinlogs = append(currBinlogs, tBinlogs)
} else {
fieldBinlogs.Binlogs = append(fieldBinlogs.Binlogs, tBinlogs.Binlogs...)
}
}
clonedSegment.Binlogs = currBinlogs
// statlogs
currStatsLogs := clonedSegment.GetStatslogs()
for _, tStatsLogs := range seg2Drop.GetStatslogs() {
fieldStatsLog := getFieldBinlogs(tStatsLogs.GetFieldID(), currStatsLogs)
if fieldStatsLog == nil {
currStatsLogs = append(currStatsLogs, tStatsLogs)
} else {
fieldStatsLog.Binlogs = append(fieldStatsLog.Binlogs, tStatsLogs.Binlogs...)
}
}
clonedSegment.Statslogs = currStatsLogs
// deltalogs
clonedSegment.Deltalogs = append(clonedSegment.Deltalogs, seg2Drop.GetDeltalogs()...)
// start position
if seg2Drop.GetStartPosition() != nil {
clonedSegment.StartPosition = seg2Drop.GetStartPosition()
}
// checkpoint
if seg2Drop.GetDmlPosition() != nil {
clonedSegment.DmlPosition = seg2Drop.GetDmlPosition()
}
clonedSegment.currRows = seg2Drop.currRows
return clonedSegment
}
// batchSaveDropSegments saves drop segments info with channel removal flag
// since the channel unwatching operation is not atomic here
// ** the removal flag is always with last batch
// ** the last batch must contains at least one segment
// 1. when failure occurs between batches, failover mechanism will continue with the earlist checkpoint of this channel
// since the flag is not marked so data node can re-consume the drop collection msg
// 2. when failure occurs between save meta and unwatch channel, the removal flag shall be check before let datanode watch this channel
func (m *meta) batchSaveDropSegments(channel string, modSegments map[int64]*SegmentInfo) error {
// the limitation of etcd operations number per transaction is 128, since segment number might be enormous so we shall split
// all save operations into batches
// since the removal flag shall always be with the last batch, so the last batch shall be maxOperationNumber - 1
for len(modSegments) > maxOperationsPerTxn-1 {
err := m.saveDropSegmentAndRemove(channel, modSegments, false, func(kv map[string]string, modSegments map[int64]*SegmentInfo) bool {
// batch filled or only one segment left
// since the last batch must contains at least on segment
return len(kv) == maxOperationsPerTxn || len(modSegments) == 1
})
if err != nil {
return err
}
}
// removal flag should be saved with last batch
return m.saveDropSegmentAndRemove(channel, modSegments, true, func(_ map[string]string, _ map[int64]*SegmentInfo) bool { return false })
}
func (m *meta) saveDropSegmentAndRemove(channel string, modSegments map[int64]*SegmentInfo, withFlag bool, stopper func(kv map[string]string, modSegment map[int64]*SegmentInfo) bool) error {
kv := make(map[string]string)
update := make([]*SegmentInfo, 0, maxOperationsPerTxn)
for id, s := range modSegments {
key := buildSegmentPath(s.GetCollectionID(), s.GetPartitionID(), s.GetID())
delete(modSegments, id)
segBytes, err := proto.Marshal(s.SegmentInfo)
if err != nil {
return fmt.Errorf("DataCoord UpdateDropChannelSegmentInfo segmentID:%d, marshal failed:%w", s.GetID(), err)
}
kv[key] = string(segBytes)
update = append(update, s)
if stopper(kv, modSegments) {
break
}
}
if withFlag {
// add removal flag into meta, preventing non-atomic removal channel failure
removalFlag := buildChannelRemovePath(channel)
kv[removalFlag] = ""
}
err := m.saveKvTxn(kv)
if err != nil {
log.Warn("Failed to txn save segment info batch for DropChannel", zap.Error(err))
return err
}
// update memory info
for _, s := range update {
m.segments.SetSegment(s.GetID(), s)
}
return nil
}
// FinishRemoveChannel removes channel remove flag after whole procedure is finished
func (m *meta) FinishRemoveChannel(channel string) error {
key := buildChannelRemovePath(channel)
return m.client.Remove(key)
}
// ListSegmentFiles lists all segments' logs
func (m *meta) ListSegmentFiles() []string {
m.RLock()
@ -758,6 +906,11 @@ func buildQuerySegmentPath(collectionID UniqueID, partitionID UniqueID, segmentI
return fmt.Sprintf("%s/%d/%d/%d", handoffSegmentPrefix, collectionID, partitionID, segmentID)
}
// buildChannelRemovePat builds vchannel remove flag path
func buildChannelRemovePath(channel string) string {
return fmt.Sprintf("%s/%s", channelRemovePrefix, channel)
}
// buildSegment utility function for compose datapb.SegmentInfo struct with provided info
func buildSegment(collectionID UniqueID, partitionID UniqueID, segmentID UniqueID, channelName string) *SegmentInfo {
info := &datapb.SegmentInfo{
@ -772,6 +925,7 @@ func buildSegment(collectionID UniqueID, partitionID UniqueID, segmentID UniqueI
}
func isSegmentHealthy(segment *SegmentInfo) bool {
return segment.GetState() != commonpb.SegmentState_NotExist &&
return segment.GetState() != commonpb.SegmentState_SegmentStateNone &&
segment.GetState() != commonpb.SegmentState_NotExist &&
segment.GetState() != commonpb.SegmentState_Dropped
}

8
internal/datacoord/meta_test.go
View File

@ -515,7 +515,8 @@ func Test_meta_SetSegmentCompacting(t *testing.T) {
map[int64]*SegmentInfo{
1: {
SegmentInfo: &datapb.SegmentInfo{
ID: 1,
ID: 1,
State: commonpb.SegmentState_Flushed,
},
isCompacting: false,
},
@ -563,18 +564,21 @@ func Test_meta_GetSegmentsOfCollection(t *testing.T) {
SegmentInfo: &datapb.SegmentInfo{
ID: 1,
CollectionID: 1,
State: commonpb.SegmentState_Flushed,
},
},
2: {
SegmentInfo: &datapb.SegmentInfo{
ID: 2,
CollectionID: 1,
State: commonpb.SegmentState_Growing,
},
},
3: {
SegmentInfo: &datapb.SegmentInfo{
ID: 3,
CollectionID: 2,
State: commonpb.SegmentState_Flushed,
},
},
},
@ -588,12 +592,14 @@ func Test_meta_GetSegmentsOfCollection(t *testing.T) {
SegmentInfo: &datapb.SegmentInfo{
ID: 1,
CollectionID: 1,
State: commonpb.SegmentState_Flushed,
},
},
{
SegmentInfo: &datapb.SegmentInfo{
ID: 2,
CollectionID: 1,
State: commonpb.SegmentState_Growing,
},
},
},

3
internal/datacoord/segment_manager_test.go
View File

@ -520,12 +520,14 @@ func TestSegmentManager_DropSegmentsOfChannel(t *testing.T) {
SegmentInfo: &datapb.SegmentInfo{
ID: 1,
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
},
},
2: {
SegmentInfo: &datapb.SegmentInfo{
ID: 2,
InsertChannel: "ch2",
State: commonpb.SegmentState_Flushed,
},
},
},
@ -555,6 +557,7 @@ func TestSegmentManager_DropSegmentsOfChannel(t *testing.T) {
SegmentInfo: &datapb.SegmentInfo{
ID: 2,
InsertChannel: "ch2",
State: commonpb.SegmentState_Growing,
},
},
},

148
internal/datacoord/server_test.go
View File

@ -346,6 +346,7 @@ func TestGetInsertBinlogPaths(t *testing.T) {
},
},
},
State: commonpb.SegmentState_Growing,
}
err := svr.meta.AddSegment(NewSegmentInfo(info))
assert.Nil(t, err)
@ -372,6 +373,8 @@ func TestGetInsertBinlogPaths(t *testing.T) {
},
},
},
State: commonpb.SegmentState_Growing,
}
err := svr.meta.AddSegment(NewSegmentInfo(info))
assert.Nil(t, err)
@ -450,7 +453,8 @@ func TestGetSegmentInfo(t *testing.T) {
defer closeTestServer(t, svr)
segInfo := &datapb.SegmentInfo{
ID: 0,
ID: 0,
State: commonpb.SegmentState_Flushed,
}
err := svr.meta.AddSegment(NewSegmentInfo(segInfo))
assert.Nil(t, err)
@ -467,7 +471,8 @@ func TestGetSegmentInfo(t *testing.T) {
defer closeTestServer(t, svr)
segInfo := &datapb.SegmentInfo{
ID: 0,
ID: 0,
State: commonpb.SegmentState_Flushed,
}
err := svr.meta.AddSegment(NewSegmentInfo(segInfo))
assert.Nil(t, err)
@ -816,6 +821,7 @@ func TestSaveBinlogPaths(t *testing.T) {
ID: segment.id,
CollectionID: segment.collectionID,
InsertChannel: "ch1",
State: commonpb.SegmentState_Growing,
}
err := svr.meta.AddSegment(NewSegmentInfo(s))
assert.Nil(t, err)
@ -897,6 +903,7 @@ func TestSaveBinlogPaths(t *testing.T) {
ID: 1,
CollectionID: 1,
InsertChannel: "ch1",
State: commonpb.SegmentState_Growing,
},
})
assert.Nil(t, err)
@ -915,6 +922,143 @@ func TestSaveBinlogPaths(t *testing.T) {
})
}
func TestDropVirtualChannel(t *testing.T) {
t.Run("normal DropVirtualChannel", func(t *testing.T) {
spyCh := make(chan struct{}, 1)
svr := newTestServer(t, nil, SetSegmentManager(&spySegmentManager{spyCh: spyCh}))
defer closeTestServer(t, svr)
svr.meta.AddCollection(&datapb.CollectionInfo{ID: 0})
type testSegment struct {
id UniqueID
collectionID UniqueID
}
segments := make([]testSegment, 0, maxOperationsPerTxn) // test batch overflow
for i := 0; i < maxOperationsPerTxn; i++ {
segments = append(segments, testSegment{
id: int64(i),
collectionID: 0,
})
}
for idx, segment := range segments {
s := &datapb.SegmentInfo{
ID: segment.id,
CollectionID: segment.collectionID,
InsertChannel: "ch1",
State: commonpb.SegmentState_Growing,
}
if idx%2 == 0 {
s.Binlogs = []*datapb.FieldBinlog{
{FieldID: 1},
}
s.Statslogs = []*datapb.FieldBinlog{
{FieldID: 1},
}
}
err := svr.meta.AddSegment(NewSegmentInfo(s))
assert.Nil(t, err)
}
err := svr.channelManager.AddNode(0)
require.Nil(t, err)
err = svr.channelManager.Watch(&channel{"ch1", 0})
require.Nil(t, err)
ctx := context.Background()
req := &datapb.DropVirtualChannelRequest{
Base: &commonpb.MsgBase{
Timestamp: uint64(time.Now().Unix()),
},
ChannelName: "ch1",
Segments: make([]*datapb.DropVirtualChannelSegment, 0, maxOperationsPerTxn),
}
for _, segment := range segments {
seg2Drop := &datapb.DropVirtualChannelSegment{
SegmentID: segment.id,
CollectionID: segment.collectionID,
Field2BinlogPaths: []*datapb.FieldBinlog{
{
FieldID: 1,
Binlogs: []string{
"/by-dev/test/0/1/2/1/Allo1",
"/by-dev/test/0/1/2/1/Allo2",
},
},
},
Field2StatslogPaths: []*datapb.FieldBinlog{
{
FieldID: 1,
Binlogs: []string{
"/by-dev/test/0/1/2/1/stats1",
"/by-dev/test/0/1/2/1/stats2",
},
},
},
Deltalogs: []*datapb.DeltaLogInfo{
{
RecordEntries: 1,
DeltaLogPath: "/by-dev/test/0/1/2/1/delta1",
},
},
CheckPoint: &internalpb.MsgPosition{
ChannelName: "ch1",
MsgID: []byte{1, 2, 3},
MsgGroup: "",
Timestamp: 0,
},
StartPosition: &internalpb.MsgPosition{
ChannelName: "ch1",
MsgID: []byte{1, 2, 3},
MsgGroup: "",
Timestamp: 0,
},
NumOfRows: 10,
}
req.Segments = append(req.Segments, seg2Drop)
}
resp, err := svr.DropVirtualChannel(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
<-spyCh
err = svr.channelManager.Watch(&channel{"ch1", 0})
require.Nil(t, err)
//resend
resp, err = svr.DropVirtualChannel(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
t.Run("with channel not matched", func(t *testing.T) {
svr := newTestServer(t, nil)
defer closeTestServer(t, svr)
err := svr.channelManager.AddNode(0)
require.Nil(t, err)
err = svr.channelManager.Watch(&channel{"ch1", 0})
require.Nil(t, err)
resp, err := svr.DropVirtualChannel(context.Background(), &datapb.DropVirtualChannelRequest{
ChannelName: "ch2",
})
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetStatus().GetErrorCode())
})
t.Run("with closed server", func(t *testing.T) {
svr := newTestServer(t, nil)
closeTestServer(t, svr)
resp, err := svr.DropVirtualChannel(context.Background(), &datapb.DropVirtualChannelRequest{})
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetStatus().GetErrorCode())
assert.Equal(t, serverNotServingErrMsg, resp.GetStatus().GetReason())
})
}
func TestDataNodeTtChannel(t *testing.T) {
genMsg := func(msgType commonpb.MsgType, ch string, t Timestamp) *msgstream.DataNodeTtMsg {
return &msgstream.DataNodeTtMsg{

64
internal/datacoord/services.go
View File

@ -384,6 +384,70 @@ func (s *Server) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPath
return resp, nil
}
// DropVirtualChannel notifies vchannel dropped
// And contains the remaining data log & checkpoint to update
func (s *Server) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
resp := &datapb.DropVirtualChannelResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
},
}
if s.isClosed() {
resp.Status.Reason = serverNotServingErrMsg
return resp, nil
}
channel := req.GetChannelName()
log.Debug("receive DropVirtualChannel request",
zap.String("channel name", channel))
// validate
nodeID := req.GetBase().GetSourceID()
if !s.channelManager.Match(nodeID, channel) {
FailResponse(resp.Status, fmt.Sprintf("channel %s is not watched on node %d", channel, nodeID))
log.Warn("node is not matched with channel", zap.String("channel", channel), zap.Int64("nodeID", nodeID))
return resp, nil
}
segments := make([]*SegmentInfo, 0, len(req.GetSegments()))
for _, seg2Drop := range req.GetSegments() {
info := &datapb.SegmentInfo{
ID: seg2Drop.GetSegmentID(),
CollectionID: seg2Drop.GetCollectionID(),
InsertChannel: channel,
Binlogs: seg2Drop.GetField2BinlogPaths(),
Statslogs: seg2Drop.GetField2StatslogPaths(),
Deltalogs: seg2Drop.GetDeltalogs(),
StartPosition: seg2Drop.GetStartPosition(),
DmlPosition: seg2Drop.GetCheckPoint(),
NumOfRows: seg2Drop.GetNumOfRows(),
}
segment := NewSegmentInfo(info)
segments = append(segments, segment)
}
err := s.meta.UpdateDropChannelSegmentInfo(channel, segments)
if err != nil {
log.Error("Update Drop Channel segment info failed", zap.String("channel", channel), zap.Error(err))
resp.Status.Reason = err.Error()
return resp, nil
}
log.Debug("DropVChannel plan to remove", zap.String("channel", channel))
err = s.channelManager.RemoveChannel(channel)
if err != nil {
log.Warn("DropVChannel failed to RemoveChannel", zap.String("channel", channel), zap.Error(err))
}
s.segmentManager.DropSegmentsOfChannel(ctx, channel)
// clean up removal flag
s.meta.FinishRemoveChannel(channel)
// no compaction triggerred in Drop procedure
resp.Status.ErrorCode = commonpb.ErrorCode_Success
return resp, nil
}
// GetComponentStates returns DataCoord's current state
func (s *Server) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
nodeID := common.NotRegisteredID

18
internal/distributed/datacoord/client/client.go
View File

@ -675,3 +675,21 @@ func (c *Client) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateR
}
return ret.(*milvuspb.GetFlushStateResponse), err
}
// DropVirtualChannel drops virtual channel in datacoord.
func (c *Client) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
ret, err := c.recall(func() (interface{}, error) {
client, err := c.getGrpcClient()
if err != nil {
return nil, err
}
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.DropVirtualChannel(ctx, req)
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*datapb.DropVirtualChannelResponse), err
}

8
internal/distributed/datacoord/client/client_test.go
View File

@ -116,6 +116,11 @@ func (m *MockDataCoordClient) WatchChannels(ctx context.Context, req *datapb.Wat
func (m *MockDataCoordClient) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest, opts ...grpc.CallOption) (*milvuspb.GetFlushStateResponse, error) {
return &milvuspb.GetFlushStateResponse{}, m.err
}
func (m *MockDataCoordClient) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest, opts ...grpc.CallOption) (*datapb.DropVirtualChannelResponse, error) {
return &datapb.DropVirtualChannelResponse{}, m.err
}
func Test_NewClient(t *testing.T) {
proxy.Params.InitOnce()
@ -203,6 +208,9 @@ func Test_NewClient(t *testing.T) {
r20, err := client.WatchChannels(ctx, nil)
retCheck(retNotNil, r20, err)
r21, err := client.DropVirtualChannel(ctx, nil)
retCheck(retNotNil, r21, err)
}
client.getGrpcClient = func() (datapb.DataCoordClient, error) {

5
internal/distributed/datacoord/service.go
View File

@ -305,3 +305,8 @@ func (s *Server) WatchChannels(ctx context.Context, req *datapb.WatchChannelsReq
func (s *Server) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error) {
return s.dataCoord.GetFlushState(ctx, req)
}
// DropVirtualChannel drop virtual channel in datacoord
func (s *Server) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
return s.dataCoord.DropVirtualChannel(ctx, req)
}

14
internal/distributed/datacoord/service_test.go
View File

@ -53,6 +53,7 @@ type MockDataCoord struct {
compactionPlansResp *milvuspb.GetCompactionPlansResponse
watchChannelsResp *datapb.WatchChannelsResponse
getFlushStateResp *milvuspb.GetFlushStateResponse
dropVChanResp *datapb.DropVirtualChannelResponse
}
func (m *MockDataCoord) Init() error {
@ -155,6 +156,10 @@ func (m *MockDataCoord) GetFlushState(ctx context.Context, req *milvuspb.GetFlus
return m.getFlushStateResp, m.err
}
func (m *MockDataCoord) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
return m.dropVChanResp, m.err
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
func Test_NewServer(t *testing.T) {
ctx := context.Background()
@ -321,6 +326,15 @@ func Test_NewServer(t *testing.T) {
assert.NotNil(t, resp)
})
t.Run("DropVirtualChannel", func(t *testing.T) {
server.dataCoord = &MockDataCoord{
dropVChanResp: &datapb.DropVirtualChannelResponse{},
}
resp, err := server.DropVirtualChannel(ctx, nil)
assert.Nil(t, err)
assert.NotNil(t, resp)
})
err = server.Stop()
assert.Nil(t, err)
}

4
internal/distributed/proxy/service_test.go
View File

@ -403,6 +403,10 @@ func (m *MockDataCoord) GetFlushState(ctx context.Context, req *milvuspb.GetFlus
return nil, nil
}
func (m *MockDataCoord) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
return &datapb.DropVirtualChannelResponse{}, nil
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
type MockProxy struct {
MockBase

22
internal/proto/data_coord.proto
View File

@ -40,6 +40,7 @@ service DataCoord {
rpc WatchChannels(WatchChannelsRequest) returns (WatchChannelsResponse) {}
rpc GetFlushState(milvus.GetFlushStateRequest) returns (milvus.GetFlushStateResponse) {}
rpc DropVirtualChannel(DropVirtualChannelRequest) returns (DropVirtualChannelResponse) {}
}
service DataNode {
@ -364,3 +365,24 @@ message WatchChannelsRequest {
message WatchChannelsResponse {
common.Status status = 1;
}
message DropVirtualChannelRequest {
common.MsgBase base = 1;
string channel_name = 2;
repeated DropVirtualChannelSegment segments = 3;
}
message DropVirtualChannelSegment {
int64 segmentID = 1;
int64 collectionID = 2;
repeated FieldBinlog field2BinlogPaths = 3;
repeated FieldBinlog field2StatslogPaths = 4;
repeated DeltaLogInfo deltalogs = 5;
internal.MsgPosition startPosition = 6;
internal.MsgPosition checkPoint = 7;
int64 numOfRows = 8;
}
message DropVirtualChannelResponse {
common.Status status = 1;
}

568
internal/proto/datapb/data_coord.pb.go
View File

@ -2766,6 +2766,195 @@ func (m *WatchChannelsResponse) GetStatus() *commonpb.Status {
return nil
}
type DropVirtualChannelRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
ChannelName string `protobuf:"bytes,2,opt,name=channel_name,json=channelName,proto3" json:"channel_name,omitempty"`
Segments []*DropVirtualChannelSegment `protobuf:"bytes,3,rep,name=segments,proto3" json:"segments,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DropVirtualChannelRequest) Reset() { *m = DropVirtualChannelRequest{} }
func (m *DropVirtualChannelRequest) String() string { return proto.CompactTextString(m) }
func (*DropVirtualChannelRequest) ProtoMessage() {}
func (*DropVirtualChannelRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{45}
}
func (m *DropVirtualChannelRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DropVirtualChannelRequest.Unmarshal(m, b)
}
func (m *DropVirtualChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DropVirtualChannelRequest.Marshal(b, m, deterministic)
}
func (m *DropVirtualChannelRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DropVirtualChannelRequest.Merge(m, src)
}
func (m *DropVirtualChannelRequest) XXX_Size() int {
return xxx_messageInfo_DropVirtualChannelRequest.Size(m)
}
func (m *DropVirtualChannelRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DropVirtualChannelRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DropVirtualChannelRequest proto.InternalMessageInfo
func (m *DropVirtualChannelRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *DropVirtualChannelRequest) GetChannelName() string {
if m != nil {
return m.ChannelName
}
return ""
}
func (m *DropVirtualChannelRequest) GetSegments() []*DropVirtualChannelSegment {
if m != nil {
return m.Segments
}
return nil
}
type DropVirtualChannelSegment struct {
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
Field2BinlogPaths []*FieldBinlog `protobuf:"bytes,3,rep,name=field2BinlogPaths,proto3" json:"field2BinlogPaths,omitempty"`
Field2StatslogPaths []*FieldBinlog `protobuf:"bytes,4,rep,name=field2StatslogPaths,proto3" json:"field2StatslogPaths,omitempty"`
Deltalogs []*DeltaLogInfo `protobuf:"bytes,5,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
StartPosition *internalpb.MsgPosition `protobuf:"bytes,6,opt,name=startPosition,proto3" json:"startPosition,omitempty"`
CheckPoint *internalpb.MsgPosition `protobuf:"bytes,7,opt,name=checkPoint,proto3" json:"checkPoint,omitempty"`
NumOfRows int64 `protobuf:"varint,8,opt,name=numOfRows,proto3" json:"numOfRows,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DropVirtualChannelSegment) Reset() { *m = DropVirtualChannelSegment{} }
func (m *DropVirtualChannelSegment) String() string { return proto.CompactTextString(m) }
func (*DropVirtualChannelSegment) ProtoMessage() {}
func (*DropVirtualChannelSegment) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{46}
}
func (m *DropVirtualChannelSegment) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DropVirtualChannelSegment.Unmarshal(m, b)
}
func (m *DropVirtualChannelSegment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DropVirtualChannelSegment.Marshal(b, m, deterministic)
}
func (m *DropVirtualChannelSegment) XXX_Merge(src proto.Message) {
xxx_messageInfo_DropVirtualChannelSegment.Merge(m, src)
}
func (m *DropVirtualChannelSegment) XXX_Size() int {
return xxx_messageInfo_DropVirtualChannelSegment.Size(m)
}
func (m *DropVirtualChannelSegment) XXX_DiscardUnknown() {
xxx_messageInfo_DropVirtualChannelSegment.DiscardUnknown(m)
}
var xxx_messageInfo_DropVirtualChannelSegment proto.InternalMessageInfo
func (m *DropVirtualChannelSegment) GetSegmentID() int64 {
if m != nil {
return m.SegmentID
}
return 0
}
func (m *DropVirtualChannelSegment) GetCollectionID() int64 {
if m != nil {
return m.CollectionID
}
return 0
}
func (m *DropVirtualChannelSegment) GetField2BinlogPaths() []*FieldBinlog {
if m != nil {
return m.Field2BinlogPaths
}
return nil
}
func (m *DropVirtualChannelSegment) GetField2StatslogPaths() []*FieldBinlog {
if m != nil {
return m.Field2StatslogPaths
}
return nil
}
func (m *DropVirtualChannelSegment) GetDeltalogs() []*DeltaLogInfo {
if m != nil {
return m.Deltalogs
}
return nil
}
func (m *DropVirtualChannelSegment) GetStartPosition() *internalpb.MsgPosition {
if m != nil {
return m.StartPosition
}
return nil
}
func (m *DropVirtualChannelSegment) GetCheckPoint() *internalpb.MsgPosition {
if m != nil {
return m.CheckPoint
}
return nil
}
func (m *DropVirtualChannelSegment) GetNumOfRows() int64 {
if m != nil {
return m.NumOfRows
}
return 0
}
type DropVirtualChannelResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DropVirtualChannelResponse) Reset() { *m = DropVirtualChannelResponse{} }
func (m *DropVirtualChannelResponse) String() string { return proto.CompactTextString(m) }
func (*DropVirtualChannelResponse) ProtoMessage() {}
func (*DropVirtualChannelResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{47}
}
func (m *DropVirtualChannelResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DropVirtualChannelResponse.Unmarshal(m, b)
}
func (m *DropVirtualChannelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DropVirtualChannelResponse.Marshal(b, m, deterministic)
}
func (m *DropVirtualChannelResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_DropVirtualChannelResponse.Merge(m, src)
}
func (m *DropVirtualChannelResponse) XXX_Size() int {
return xxx_messageInfo_DropVirtualChannelResponse.Size(m)
}
func (m *DropVirtualChannelResponse) XXX_DiscardUnknown() {
xxx_messageInfo_DropVirtualChannelResponse.DiscardUnknown(m)
}
var xxx_messageInfo_DropVirtualChannelResponse proto.InternalMessageInfo
func (m *DropVirtualChannelResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
func init() {
proto.RegisterEnum("milvus.proto.data.ChannelWatchState", ChannelWatchState_name, ChannelWatchState_value)
proto.RegisterEnum("milvus.proto.data.CompactionType", CompactionType_name, CompactionType_value)
@ -2814,177 +3003,188 @@ func init() {
proto.RegisterType((*SegmentFieldBinlogMeta)(nil), "milvus.proto.data.SegmentFieldBinlogMeta")
proto.RegisterType((*WatchChannelsRequest)(nil), "milvus.proto.data.WatchChannelsRequest")
proto.RegisterType((*WatchChannelsResponse)(nil), "milvus.proto.data.WatchChannelsResponse")
proto.RegisterType((*DropVirtualChannelRequest)(nil), "milvus.proto.data.DropVirtualChannelRequest")
proto.RegisterType((*DropVirtualChannelSegment)(nil), "milvus.proto.data.DropVirtualChannelSegment")
proto.RegisterType((*DropVirtualChannelResponse)(nil), "milvus.proto.data.DropVirtualChannelResponse")
}
func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
var fileDescriptor_82cd95f524594f49 = []byte{
// 2631 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x5b, 0x6f, 0x1b, 0xc7,
0x15, 0xf6, 0xf2, 0x22, 0x91, 0x87, 0x14, 0x45, 0x8f, 0x1d, 0x99, 0x65, 0x1c, 0x59, 0xde, 0x24,
0xb6, 0xec, 0x38, 0x92, 0x2d, 0x37, 0x68, 0x50, 0x27, 0x0d, 0x2c, 0xcb, 0x56, 0x89, 0x4a, 0xae,
0xba, 0x54, 0xe2, 0xa2, 0x01, 0x4a, 0xac, 0xb8, 0x23, 0x6a, 0x6b, 0xee, 0x2e, 0xbd, 0x33, 0x94,
0xad, 0xbc, 0xc4, 0x48, 0x81, 0x02, 0x2d, 0xda, 0xa6, 0x45, 0x1f, 0x5b, 0xa0, 0x45, 0x9f, 0x0a,
0xf4, 0xa5, 0xe8, 0x63, 0xfb, 0x07, 0x8a, 0xf6, 0xbd, 0x7f, 0xa3, 0x7f, 0xa1, 0x98, 0xcb, 0xce,
0x5e, 0xb8, 0x24, 0x57, 0x92, 0x2f, 0x6f, 0x9c, 0xd9, 0x73, 0x9b, 0x33, 0xe7, 0x7c, 0x73, 0xce,
0x0c, 0xa1, 0x6e, 0x99, 0xd4, 0xec, 0x74, 0x3d, 0xcf, 0xb7, 0x56, 0x06, 0xbe, 0x47, 0x3d, 0x74,
0xd6, 0xb1, 0xfb, 0x87, 0x43, 0x22, 0x46, 0x2b, 0xec, 0x73, 0xb3, 0xda, 0xf5, 0x1c, 0xc7, 0x73,
0xc5, 0x54, 0xb3, 0x66, 0xbb, 0x14, 0xfb, 0xae, 0xd9, 0x97, 0xe3, 0x6a, 0x94, 0xa1, 0x59, 0x25,
0xdd, 0x03, 0xec, 0x98, 0x62, 0xa4, 0x3f, 0x83, 0xea, 0x83, 0xfe, 0x90, 0x1c, 0x18, 0xf8, 0xc9,
0x10, 0x13, 0x8a, 0x6e, 0x42, 0x61, 0xcf, 0x24, 0xb8, 0xa1, 0x2d, 0x69, 0xcb, 0x95, 0xb5, 0x8b,
0x2b, 0x31, 0x5d, 0x52, 0xcb, 0x36, 0xe9, 0xad, 0x9b, 0x04, 0x1b, 0x9c, 0x12, 0x21, 0x28, 0x58,
0x7b, 0xad, 0x8d, 0x46, 0x6e, 0x49, 0x5b, 0xce, 0x1b, 0xfc, 0x37, 0xd2, 0xa1, 0xda, 0xf5, 0xfa,
0x7d, 0xdc, 0xa5, 0xb6, 0xe7, 0xb6, 0x36, 0x1a, 0x05, 0xfe, 0x2d, 0x36, 0xa7, 0xff, 0x41, 0x83,
0x39, 0xa9, 0x9a, 0x0c, 0x3c, 0x97, 0x60, 0x74, 0x1b, 0x66, 0x08, 0x35, 0xe9, 0x90, 0x48, 0xed,
0x6f, 0xa6, 0x6a, 0x6f, 0x73, 0x12, 0x43, 0x92, 0x66, 0x52, 0x9f, 0x1f, 0x55, 0x8f, 0x16, 0x01,
0x08, 0xee, 0x39, 0xd8, 0xa5, 0xad, 0x0d, 0xd2, 0x28, 0x2c, 0xe5, 0x97, 0xf3, 0x46, 0x64, 0x46,
0xff, 0xad, 0x06, 0xf5, 0x76, 0x30, 0x0c, 0xbc, 0x73, 0x1e, 0x8a, 0x5d, 0x6f, 0xe8, 0x52, 0x6e,
0xe0, 0x9c, 0x21, 0x06, 0xe8, 0x32, 0x54, 0xbb, 0x07, 0xa6, 0xeb, 0xe2, 0x7e, 0xc7, 0x35, 0x1d,
0xcc, 0x4d, 0x29, 0x1b, 0x15, 0x39, 0xf7, 0xd0, 0x74, 0x70, 0x26, 0x8b, 0x96, 0xa0, 0x32, 0x30,
0x7d, 0x6a, 0xc7, 0x7c, 0x16, 0x9d, 0xd2, 0xff, 0xa4, 0xc1, 0xc2, 0x5d, 0x42, 0xec, 0x9e, 0x3b,
0x62, 0xd9, 0x02, 0xcc, 0xb8, 0x9e, 0x85, 0x5b, 0x1b, 0xdc, 0xb4, 0xbc, 0x21, 0x47, 0xe8, 0x4d,
0x28, 0x0f, 0x30, 0xf6, 0x3b, 0xbe, 0xd7, 0x0f, 0x0c, 0x2b, 0xb1, 0x09, 0xc3, 0xeb, 0x63, 0xf4,
0x03, 0x38, 0x4b, 0x12, 0x82, 0x48, 0x23, 0xbf, 0x94, 0x5f, 0xae, 0xac, 0xbd, 0xbd, 0x32, 0x12,
0x65, 0x2b, 0x49, 0xa5, 0xc6, 0x28, 0xb7, 0xfe, 0x3c, 0x07, 0xe7, 0x14, 0x9d, 0xb0, 0x95, 0xfd,
0x66, 0x9e, 0x23, 0xb8, 0xa7, 0xcc, 0x13, 0x83, 0x2c, 0x9e, 0x53, 0x2e, 0xcf, 0x47, 0x5d, 0x9e,
0x21, 0xc0, 0x92, 0xfe, 0x2c, 0x8e, 0xf8, 0x13, 0x5d, 0x82, 0x0a, 0x7e, 0x36, 0xb0, 0x7d, 0xdc,
0xa1, 0xb6, 0x83, 0x1b, 0x33, 0x4b, 0xda, 0x72, 0xc1, 0x00, 0x31, 0xb5, 0x6b, 0x3b, 0xd1, 0x88,
0x9c, 0xcd, 0x1c, 0x91, 0xfa, 0x9f, 0x35, 0xb8, 0x30, 0xb2, 0x4b, 0x32, 0xc4, 0x0d, 0xa8, 0xf3,
0x95, 0x87, 0x9e, 0x61, 0xc1, 0xce, 0x1c, 0x7e, 0x65, 0x92, 0xc3, 0x43, 0x72, 0x63, 0x84, 0x3f,
0x62, 0x64, 0x2e, 0xbb, 0x91, 0x8f, 0xe1, 0xc2, 0x26, 0xa6, 0x52, 0x01, 0xfb, 0x86, 0xc9, 0xc9,
0x21, 0x20, 0x9e, 0x4b, 0xb9, 0x91, 0x5c, 0xfa, 0x5b, 0x4e, 0xe5, 0x12, 0x57, 0xd5, 0x72, 0xf7,
0x3d, 0x74, 0x11, 0xca, 0x8a, 0x44, 0x46, 0x45, 0x38, 0x81, 0xbe, 0x05, 0x45, 0x66, 0xa9, 0x08,
0x89, 0xda, 0xda, 0xe5, 0xf4, 0x35, 0x45, 0x64, 0x1a, 0x82, 0x1e, 0xb5, 0xa0, 0x46, 0xa8, 0xe9,
0xd3, 0xce, 0xc0, 0x23, 0x7c, 0x9f, 0x79, 0xe0, 0x54, 0xd6, 0xf4, 0xb8, 0x04, 0x05, 0x91, 0xdb,
0xa4, 0xb7, 0x23, 0x29, 0x8d, 0x39, 0xce, 0x19, 0x0c, 0xd1, 0x7d, 0xa8, 0x62, 0xd7, 0x0a, 0x05,
0x15, 0x32, 0x0b, 0xaa, 0x60, 0xd7, 0x52, 0x62, 0xc2, 0xfd, 0x29, 0x66, 0xdf, 0x9f, 0x5f, 0x6a,
0xd0, 0x18, 0xdd, 0xa0, 0xd3, 0x00, 0xe5, 0x1d, 0xc1, 0x84, 0xc5, 0x06, 0x4d, 0xcc, 0x70, 0xb5,
0x49, 0x86, 0x64, 0xd1, 0x6d, 0x78, 0x23, 0xb4, 0x86, 0x7f, 0x79, 0x69, 0xc1, 0xf2, 0x53, 0x0d,
0x16, 0x92, 0xba, 0x4e, 0xb3, 0xee, 0x6f, 0x42, 0xd1, 0x76, 0xf7, 0xbd, 0x60, 0xd9, 0x8b, 0x13,
0xf2, 0x8c, 0xe9, 0x12, 0xc4, 0xba, 0x03, 0x6f, 0x6e, 0x62, 0xda, 0x72, 0x09, 0xf6, 0xe9, 0xba,
0xed, 0xf6, 0xbd, 0xde, 0x8e, 0x49, 0x0f, 0x4e, 0x91, 0x23, 0xb1, 0x70, 0xcf, 0x25, 0xc2, 0x5d,
0xff, 0x8b, 0x06, 0x17, 0xd3, 0xf5, 0xc9, 0xa5, 0x37, 0xa1, 0xb4, 0x6f, 0xe3, 0xbe, 0xc5, 0x7c,
0xa6, 0x71, 0x9f, 0xa9, 0x31, 0xcb, 0x95, 0x01, 0x23, 0x96, 0x2b, 0xbc, 0x3c, 0x26, 0x40, 0xdb,
0xd4, 0xb7, 0xdd, 0xde, 0x96, 0x4d, 0xa8, 0x21, 0xe8, 0x23, 0xfe, 0xcc, 0x67, 0x8f, 0xcc, 0x5f,
0x68, 0xb0, 0xb8, 0x89, 0xe9, 0x3d, 0x05, 0xb5, 0xec, 0xbb, 0x4d, 0xa8, 0xdd, 0x25, 0x2f, 0xb7,
0x88, 0x48, 0x39, 0x33, 0xf5, 0xaf, 0x35, 0xb8, 0x34, 0xd6, 0x18, 0xe9, 0x3a, 0x09, 0x25, 0x01,
0xd0, 0xa6, 0x43, 0xc9, 0xf7, 0xf0, 0xd1, 0x67, 0x66, 0x7f, 0x88, 0x77, 0x4c, 0xdb, 0x17, 0x50,
0x72, 0x42, 0x60, 0xfd, 0xab, 0x06, 0x6f, 0x6d, 0x62, 0xba, 0x13, 0x1c, 0x33, 0xaf, 0xd1, 0x3b,
0x19, 0x2a, 0x8a, 0x5f, 0x8b, 0xcd, 0x4c, 0xb5, 0xf6, 0xb5, 0xb8, 0x6f, 0x91, 0xe7, 0x41, 0x24,
0x21, 0xef, 0x89, 0x5a, 0x40, 0x3a, 0x4f, 0x7f, 0x9e, 0x87, 0xea, 0x67, 0xb2, 0x3e, 0xe0, 0xc7,
0x48, 0xd2, 0x0f, 0x5a, 0xba, 0x1f, 0x22, 0x25, 0x45, 0x5a, 0x95, 0xb1, 0x09, 0x73, 0x04, 0xe3,
0xc7, 0x27, 0x39, 0x34, 0xaa, 0x8c, 0x51, 0x81, 0xfd, 0x16, 0x9c, 0x1d, 0xba, 0xfb, 0xac, 0xac,
0xc5, 0x96, 0x5c, 0x85, 0xa8, 0x2e, 0xa7, 0x23, 0xcf, 0x28, 0x23, 0xfa, 0x2e, 0xcc, 0x27, 0x65,
0x15, 0x33, 0xc9, 0x4a, 0xb2, 0xa1, 0x16, 0xd4, 0x2d, 0xdf, 0x1b, 0x0c, 0xb0, 0xd5, 0x21, 0x81,
0xa8, 0x99, 0x6c, 0xa2, 0x24, 0x5f, 0x20, 0x4a, 0xff, 0xb9, 0x06, 0x0b, 0x8f, 0x4c, 0xda, 0x3d,
0xd8, 0x70, 0xe4, 0xe6, 0x9c, 0x22, 0xb4, 0x3f, 0x86, 0xf2, 0xa1, 0xdc, 0x88, 0x00, 0xbf, 0x2e,
0xa5, 0x18, 0x14, 0xdd, 0x72, 0x23, 0xe4, 0xd0, 0xff, 0xa5, 0xc1, 0x79, 0xde, 0x44, 0x04, 0xd6,
0xbd, 0xfa, 0x24, 0x9b, 0xd2, 0x48, 0xa0, 0x2b, 0x50, 0x73, 0x4c, 0xff, 0x71, 0x3b, 0xa4, 0x29,
0x72, 0x9a, 0xc4, 0xac, 0xfe, 0x0c, 0x40, 0x8e, 0xb6, 0x49, 0xef, 0x04, 0xf6, 0x7f, 0x08, 0xb3,
0x52, 0xab, 0xcc, 0xb7, 0x69, 0x1b, 0x1b, 0x90, 0xeb, 0xff, 0xd6, 0xa0, 0x16, 0x22, 0x28, 0xcf,
0xaa, 0x1a, 0xe4, 0x54, 0x2e, 0xe5, 0x5a, 0x1b, 0xe8, 0x63, 0x98, 0x11, 0x6d, 0xa3, 0x94, 0xfd,
0x6e, 0x5c, 0xb6, 0x6c, 0x29, 0x23, 0x30, 0xcc, 0x27, 0x0c, 0xc9, 0xc4, 0x7c, 0xa4, 0x50, 0x47,
0x74, 0x18, 0x79, 0x23, 0x32, 0x83, 0x5a, 0x30, 0x1f, 0x2f, 0xda, 0x82, 0x9c, 0x59, 0x1a, 0x87,
0x36, 0x1b, 0x26, 0x35, 0x39, 0xd8, 0xd4, 0x62, 0x35, 0x1b, 0xd1, 0xff, 0x57, 0x84, 0x4a, 0x64,
0x95, 0x23, 0x2b, 0x49, 0x6e, 0x69, 0x6e, 0x3a, 0x6e, 0xe6, 0x47, 0x3b, 0x87, 0x77, 0xa1, 0x66,
0xf3, 0xb3, 0xba, 0x23, 0x43, 0x91, 0x83, 0x6b, 0xd9, 0x98, 0x13, 0xb3, 0x32, 0x2f, 0xd0, 0x22,
0x54, 0xdc, 0xa1, 0xd3, 0xf1, 0xf6, 0x3b, 0xbe, 0xf7, 0x94, 0xc8, 0x16, 0xa4, 0xec, 0x0e, 0x9d,
0xef, 0xef, 0x1b, 0xde, 0x53, 0x12, 0x56, 0xb9, 0x33, 0xc7, 0xac, 0x72, 0x17, 0xa1, 0xe2, 0x98,
0xcf, 0x98, 0xd4, 0x8e, 0x3b, 0x74, 0x78, 0x77, 0x92, 0x37, 0xca, 0x8e, 0xf9, 0xcc, 0xf0, 0x9e,
0x3e, 0x1c, 0x3a, 0x68, 0x19, 0xea, 0x7d, 0x93, 0xd0, 0x4e, 0xb4, 0xbd, 0x29, 0xf1, 0xf6, 0xa6,
0xc6, 0xe6, 0xef, 0x87, 0x2d, 0xce, 0x68, 0xbd, 0x5c, 0x3e, 0x45, 0xbd, 0x6c, 0x39, 0xfd, 0x50,
0x10, 0x64, 0xaf, 0x97, 0x2d, 0xa7, 0xaf, 0xc4, 0x7c, 0x08, 0xb3, 0x7b, 0xbc, 0x02, 0x22, 0x8d,
0xca, 0x58, 0x84, 0x7a, 0xc0, 0x8a, 0x1f, 0x51, 0x28, 0x19, 0x01, 0x39, 0xfa, 0x08, 0xca, 0xfc,
0xe8, 0xe1, 0xbc, 0xd5, 0x4c, 0xbc, 0x21, 0x03, 0x83, 0x22, 0x0b, 0xf7, 0xa9, 0xc9, 0xb9, 0xe7,
0xc6, 0x42, 0xd1, 0x06, 0xa3, 0xd9, 0xf2, 0x7a, 0x02, 0x8a, 0x14, 0x07, 0xba, 0x09, 0xe7, 0xba,
0x3e, 0x36, 0x29, 0xb6, 0xd6, 0x8f, 0xee, 0x79, 0xce, 0xc0, 0xe4, 0xd1, 0xd4, 0xa8, 0x2d, 0x69,
0xcb, 0x25, 0x23, 0xed, 0x13, 0x43, 0x86, 0xae, 0x1a, 0x3d, 0xf0, 0x3d, 0xa7, 0x31, 0x2f, 0x90,
0x21, 0x3e, 0x8b, 0xde, 0x02, 0x08, 0xb0, 0xdb, 0xa4, 0x8d, 0x3a, 0xdf, 0xc6, 0xb2, 0x9c, 0xb9,
0x4b, 0xf5, 0x2f, 0xe1, 0x7c, 0x18, 0x22, 0x91, 0xed, 0x18, 0xdd, 0x59, 0xed, 0xa4, 0x3b, 0x3b,
0xb9, 0x78, 0xfd, 0x7b, 0x01, 0x16, 0xda, 0xe6, 0x21, 0x7e, 0xf9, 0x75, 0x72, 0x26, 0x40, 0xde,
0x82, 0xb3, 0xbc, 0x34, 0x5e, 0x8b, 0xd8, 0x33, 0xe1, 0x08, 0x8e, 0x46, 0xc3, 0x28, 0x23, 0xfa,
0x84, 0xd5, 0x0e, 0xb8, 0xfb, 0x78, 0xc7, 0xb3, 0xc3, 0xe3, 0xf7, 0xad, 0x14, 0x39, 0xf7, 0x14,
0x95, 0x11, 0xe5, 0x40, 0x3b, 0xa3, 0xd8, 0x26, 0x0e, 0xde, 0xab, 0x13, 0x1b, 0xb0, 0xd0, 0xfb,
0x49, 0x88, 0x43, 0x0d, 0x98, 0x95, 0xc7, 0x3b, 0x4f, 0xfc, 0x92, 0x11, 0x0c, 0xd1, 0x0e, 0x9c,
0x13, 0x2b, 0x68, 0xcb, 0xa8, 0x16, 0x8b, 0x2f, 0x65, 0x5a, 0x7c, 0x1a, 0x6b, 0x3c, 0x29, 0xca,
0xc7, 0x4e, 0x8a, 0x06, 0xcc, 0xca, 0x40, 0xe5, 0x68, 0x50, 0x32, 0x82, 0x21, 0x6b, 0x23, 0x20,
0x74, 0xd9, 0x94, 0xdb, 0x80, 0xef, 0x40, 0x49, 0x05, 0x71, 0x2e, 0x73, 0x10, 0x2b, 0x9e, 0x24,
0x0e, 0xe7, 0x13, 0x38, 0xac, 0xff, 0x47, 0x83, 0x6a, 0x74, 0x09, 0x0c, 0xdf, 0x7d, 0xdc, 0xf5,
0x7c, 0xab, 0x83, 0x5d, 0xea, 0xdb, 0x58, 0x74, 0x9c, 0x05, 0x63, 0x4e, 0xcc, 0xde, 0x17, 0x93,
0x8c, 0x8c, 0x41, 0x2b, 0xa1, 0xa6, 0x33, 0xe8, 0xec, 0xb3, 0x0c, 0xce, 0x09, 0x32, 0x35, 0xcb,
0x13, 0xf8, 0x32, 0x54, 0x43, 0x32, 0xea, 0x71, 0xfd, 0x05, 0xa3, 0xa2, 0xe6, 0x76, 0x3d, 0xf4,
0x0e, 0xd4, 0xb8, 0xd7, 0x3a, 0x7d, 0xaf, 0xd7, 0x61, 0xdd, 0x99, 0x3c, 0x50, 0xaa, 0x96, 0x34,
0x8b, 0x6d, 0x47, 0x9c, 0x8a, 0xd8, 0x5f, 0x60, 0x79, 0xa4, 0x28, 0xaa, 0xb6, 0xfd, 0x05, 0xd6,
0xbf, 0xd2, 0x60, 0x8e, 0x9d, 0x8f, 0x0f, 0x3d, 0x0b, 0xef, 0x9e, 0xb0, 0x9a, 0xc8, 0x70, 0x33,
0x77, 0x11, 0xca, 0x6a, 0x05, 0x72, 0x49, 0xe1, 0x04, 0x6b, 0xe3, 0xe7, 0xe4, 0x31, 0xd8, 0x56,
0x37, 0xb5, 0x5c, 0x94, 0xc6, 0x45, 0xf1, 0xdf, 0xe8, 0xdb, 0xf1, 0x6b, 0x9e, 0x77, 0x52, 0xf3,
0x8a, 0x0b, 0xe1, 0x15, 0x67, 0xec, 0x0c, 0xcc, 0xd2, 0x1f, 0x3e, 0x67, 0x1b, 0x2b, 0x5d, 0xc1,
0x37, 0xb6, 0x01, 0xb3, 0xa6, 0x65, 0xf9, 0x98, 0x10, 0x69, 0x47, 0x30, 0x64, 0x5f, 0x0e, 0xb1,
0x4f, 0x82, 0x10, 0xcb, 0x1b, 0xc1, 0x10, 0x7d, 0x04, 0x25, 0x55, 0xa2, 0xe6, 0xd3, 0xca, 0x92,
0xa8, 0x9d, 0xb2, 0x9f, 0x51, 0x1c, 0xfa, 0xd7, 0x39, 0xa8, 0xc9, 0xb4, 0x5e, 0x97, 0xe7, 0xd4,
0xe4, 0x60, 0x5f, 0x87, 0xea, 0x7e, 0x98, 0x96, 0x93, 0xee, 0x2d, 0xa2, 0xd9, 0x1b, 0xe3, 0x99,
0x16, 0xf0, 0xf1, 0x93, 0xb2, 0x70, 0xaa, 0x93, 0xb2, 0x78, 0x5c, 0x50, 0xd0, 0xef, 0x42, 0x25,
0x22, 0x98, 0xc3, 0x99, 0xb8, 0xca, 0x90, 0xbe, 0x08, 0x86, 0xec, 0xcb, 0x5e, 0xc4, 0x09, 0x65,
0x75, 0xd2, 0xb3, 0xba, 0xff, 0xc2, 0x26, 0xa6, 0x06, 0xee, 0x7a, 0x87, 0xd8, 0x3f, 0x3a, 0xfd,
0x2d, 0xd1, 0x9d, 0xc8, 0x1e, 0x67, 0x6c, 0x43, 0x14, 0x03, 0xba, 0x13, 0xda, 0x99, 0x4f, 0x6b,
0x92, 0xa3, 0xd0, 0x2e, 0x77, 0x28, 0x5c, 0xca, 0x6f, 0xc4, 0x7d, 0x57, 0x7c, 0x29, 0x27, 0x3d,
0x3d, 0x5f, 0x48, 0x75, 0xab, 0xff, 0x4e, 0x83, 0x6f, 0x6c, 0x62, 0xfa, 0x20, 0xde, 0x43, 0xbe,
0x6e, 0xab, 0x1c, 0x68, 0xa6, 0x19, 0x75, 0x9a, 0x5d, 0x6f, 0x42, 0x49, 0x75, 0xc3, 0xe2, 0x26,
0x52, 0x8d, 0xf5, 0x9f, 0x69, 0xd0, 0x90, 0x5a, 0xb8, 0x4e, 0x56, 0xb8, 0xf5, 0x31, 0xc5, 0xd6,
0xab, 0x6e, 0xcf, 0xfe, 0xa8, 0x41, 0x3d, 0x0a, 0x82, 0x1c, 0xc7, 0x3e, 0x80, 0x22, 0xef, 0x82,
0xa5, 0x05, 0x53, 0x83, 0x55, 0x50, 0xb3, 0x8c, 0xe2, 0xc5, 0xc4, 0x2e, 0x09, 0x40, 0x4e, 0x0e,
0x43, 0x24, 0xce, 0x1f, 0x1b, 0x89, 0xf5, 0x5f, 0xe5, 0xa0, 0x11, 0xd6, 0xb5, 0xaf, 0x1c, 0xec,
0xc6, 0x54, 0x3d, 0xf9, 0x17, 0x54, 0xf5, 0x14, 0x8e, 0x0d, 0x70, 0xff, 0xcc, 0xb1, 0x86, 0x3a,
0xf0, 0xc7, 0x4e, 0xdf, 0x74, 0xd1, 0x02, 0xcc, 0x0c, 0xfa, 0x66, 0x78, 0x41, 0x25, 0x47, 0xa8,
0x0d, 0x35, 0x12, 0xf3, 0x97, 0xf4, 0xc0, 0x7b, 0x69, 0xfe, 0x1f, 0xe3, 0x62, 0x23, 0x21, 0x82,
0x35, 0x0c, 0xa2, 0xe4, 0xe4, 0x7d, 0x9f, 0x3c, 0x9a, 0xc5, 0x46, 0xb3, 0x96, 0xef, 0x06, 0x20,
0xf6, 0xc1, 0x1b, 0xd2, 0x8e, 0xed, 0x76, 0x08, 0xee, 0x7a, 0xae, 0x45, 0x78, 0xbd, 0x51, 0x34,
0xea, 0xf2, 0x4b, 0xcb, 0x6d, 0x8b, 0x79, 0xf4, 0x01, 0x14, 0xe8, 0xd1, 0x40, 0x54, 0x1a, 0xb5,
0x54, 0x64, 0x0b, 0xed, 0xda, 0x3d, 0x1a, 0x60, 0x83, 0x93, 0xb3, 0x96, 0x9f, 0x89, 0xa2, 0xbe,
0x79, 0x88, 0xfb, 0xc1, 0xd3, 0x5a, 0x38, 0xc3, 0x22, 0x31, 0x68, 0x9d, 0x67, 0xc5, 0x41, 0x2c,
0x87, 0xfa, 0x3f, 0x72, 0x50, 0x0f, 0x45, 0x1a, 0x98, 0x0c, 0xfb, 0x74, 0xac, 0xff, 0x26, 0xb7,
0x0b, 0xd3, 0x8e, 0xc1, 0x4f, 0xa0, 0x22, 0xdb, 0xf8, 0x63, 0x1c, 0x84, 0x20, 0x58, 0xb6, 0x26,
0x84, 0x5e, 0xf1, 0x05, 0x85, 0xde, 0xcc, 0xb1, 0x43, 0xaf, 0x0d, 0x0b, 0x01, 0x68, 0x85, 0x9a,
0xb6, 0x31, 0x35, 0x27, 0x1c, 0xb3, 0x97, 0xa0, 0x22, 0x0e, 0x23, 0x51, 0x78, 0x8a, 0x52, 0x0f,
0xf6, 0x54, 0x13, 0xa4, 0xff, 0x18, 0xce, 0xf3, 0xa4, 0x4f, 0x5e, 0xf7, 0x65, 0xb9, 0x7b, 0xd5,
0x55, 0x21, 0xc9, 0x8a, 0xc6, 0xe0, 0x20, 0x8f, 0xcd, 0xe9, 0x5b, 0xf0, 0x46, 0x42, 0xfe, 0x29,
0x40, 0xfd, 0xfa, 0x2d, 0x38, 0x3b, 0x82, 0x54, 0xa8, 0x06, 0xf0, 0xa9, 0xdb, 0x95, 0x10, 0x5e,
0x3f, 0x83, 0xaa, 0x50, 0x0a, 0x00, 0xbd, 0xae, 0x5d, 0x6f, 0x47, 0xf3, 0x95, 0x05, 0x31, 0xba,
0x00, 0xe7, 0x3e, 0x75, 0x2d, 0xbc, 0x6f, 0xbb, 0xd8, 0x0a, 0x3f, 0xd5, 0xcf, 0xa0, 0x73, 0x30,
0xdf, 0x72, 0x5d, 0xec, 0x47, 0x26, 0x35, 0x36, 0xb9, 0x8d, 0xfd, 0x1e, 0x8e, 0x4c, 0xe6, 0xd6,
0x7e, 0x8f, 0xa0, 0xcc, 0x6a, 0xcf, 0x7b, 0x9e, 0xe7, 0x5b, 0x68, 0x00, 0x88, 0x3f, 0x54, 0x38,
0x03, 0xcf, 0x55, 0x2f, 0x7a, 0xe8, 0xe6, 0x98, 0x36, 0x66, 0x94, 0x54, 0xfa, 0xbc, 0x79, 0x65,
0x0c, 0x47, 0x82, 0x5c, 0x3f, 0x83, 0x1c, 0xae, 0x91, 0x65, 0xfc, 0xae, 0xdd, 0x7d, 0x1c, 0x5c,
0x49, 0x4d, 0xd0, 0x98, 0x20, 0x0d, 0x34, 0x26, 0x1e, 0x0a, 0xe5, 0x40, 0xbc, 0x26, 0x05, 0x3b,
0xa5, 0x9f, 0x41, 0x4f, 0xe0, 0xfc, 0x26, 0xa6, 0xe1, 0x03, 0x42, 0xa0, 0x70, 0x6d, 0xbc, 0xc2,
0x11, 0xe2, 0x63, 0xaa, 0xdc, 0x82, 0x22, 0x3f, 0x9a, 0x51, 0x5a, 0x86, 0x44, 0xff, 0xd6, 0xd2,
0x5c, 0x1a, 0x4f, 0xa0, 0xa4, 0xfd, 0x04, 0xe6, 0x13, 0xcf, 0xf6, 0xe8, 0x5a, 0x0a, 0x5b, 0xfa,
0x1f, 0x30, 0x9a, 0xd7, 0xb3, 0x90, 0x2a, 0x5d, 0x3d, 0xa8, 0xc5, 0x9f, 0x39, 0xd0, 0x72, 0x0a,
0x7f, 0xea, 0x93, 0x6b, 0xf3, 0x5a, 0x06, 0x4a, 0xa5, 0xc8, 0x81, 0x7a, 0xf2, 0x19, 0x19, 0x5d,
0x9f, 0x28, 0x20, 0x1e, 0x6e, 0xef, 0x65, 0xa2, 0x55, 0xea, 0x8e, 0x78, 0x10, 0x8c, 0x3c, 0x63,
0xa2, 0x95, 0x74, 0x31, 0xe3, 0xde, 0x57, 0x9b, 0xab, 0x99, 0xe9, 0x95, 0xea, 0xaf, 0x44, 0x4b,
0x90, 0xf6, 0x14, 0x88, 0x6e, 0xa5, 0x8b, 0x9b, 0xf0, 0x86, 0xd9, 0x5c, 0x3b, 0x0e, 0x8b, 0x32,
0xe2, 0x4b, 0x5e, 0xcb, 0xa7, 0x3c, 0xa7, 0x25, 0xf3, 0x2e, 0x90, 0x37, 0xfe, 0x9d, 0xb0, 0x79,
0xeb, 0x18, 0x1c, 0xca, 0x00, 0x2f, 0xf9, 0x50, 0x1f, 0xa4, 0xe1, 0xea, 0xd4, 0xa8, 0x39, 0x59,
0x0e, 0x7e, 0x0e, 0xf3, 0x89, 0xbb, 0xbf, 0xd4, 0xac, 0x49, 0xbf, 0x1f, 0x6c, 0x4e, 0x02, 0x74,
0x91, 0x92, 0x89, 0xd6, 0x08, 0x8d, 0x89, 0xfe, 0x94, 0xf6, 0xa9, 0x79, 0x3d, 0x0b, 0xa9, 0x5a,
0x08, 0xe1, 0x70, 0x99, 0x68, 0x2f, 0xd0, 0x8d, 0x74, 0x19, 0xe9, 0xad, 0x51, 0xf3, 0xfd, 0x8c,
0xd4, 0x4a, 0x69, 0x07, 0x60, 0x13, 0xd3, 0x6d, 0x4c, 0x7d, 0x16, 0x23, 0x57, 0x52, 0x5d, 0x1e,
0x12, 0x04, 0x6a, 0xae, 0x4e, 0xa5, 0x53, 0x0a, 0x7e, 0x08, 0x28, 0x38, 0xe7, 0x22, 0x37, 0xcf,
0x6f, 0x4f, 0xac, 0xe2, 0x44, 0xc9, 0x35, 0x6d, 0x6f, 0x9e, 0x40, 0x7d, 0xdb, 0x74, 0x87, 0x66,
0x3f, 0x22, 0xf7, 0x46, 0xaa, 0x61, 0x49, 0xb2, 0x31, 0xde, 0x1a, 0x4b, 0xad, 0x16, 0xf3, 0x54,
0x9d, 0xa1, 0xa6, 0x4a, 0x41, 0x9c, 0xc4, 0x96, 0xd0, 0x1b, 0x09, 0xc2, 0x31, 0xd8, 0x32, 0x81,
0x5e, 0x29, 0x7e, 0xae, 0xf1, 0xbf, 0x83, 0x24, 0x08, 0x1e, 0xd9, 0xf4, 0x80, 0x15, 0xf7, 0x24,
0x8b, 0x09, 0x9c, 0xf0, 0x18, 0x26, 0x48, 0x7a, 0x65, 0x82, 0x05, 0x73, 0xb1, 0x1a, 0x09, 0xa5,
0x5d, 0x1f, 0xa7, 0x55, 0x69, 0xcd, 0xe5, 0xe9, 0x84, 0x4a, 0xcb, 0x01, 0xcc, 0x05, 0xf1, 0x2a,
0x9c, 0x7b, 0x6d, 0x9c, 0xa5, 0x21, 0xcd, 0x98, 0x74, 0x4b, 0x27, 0x0d, 0x34, 0xad, 0xfd, 0xb7,
0x00, 0xa5, 0xe0, 0x66, 0xee, 0x35, 0x14, 0x47, 0xaf, 0xa1, 0x5a, 0xf9, 0x1c, 0xe6, 0x13, 0xcf,
0xe6, 0xa9, 0x60, 0x96, 0xfe, 0xb4, 0x3e, 0x2d, 0x1b, 0x1f, 0xc9, 0x3f, 0xd3, 0x2a, 0xe0, 0xba,
0x3a, 0xae, 0xe2, 0x49, 0x62, 0xd6, 0x14, 0xc1, 0x2f, 0x1d, 0xa1, 0x1e, 0x02, 0x44, 0x10, 0x64,
0x72, 0x7f, 0xc9, 0x92, 0x62, 0x8a, 0xc1, 0xeb, 0xb7, 0x7f, 0x74, 0xab, 0x67, 0xd3, 0x83, 0xe1,
0x1e, 0xfb, 0xb2, 0x2a, 0x48, 0xdf, 0xb7, 0x3d, 0xf9, 0x6b, 0x35, 0xd8, 0xd1, 0x55, 0xce, 0xbd,
0xca, 0x14, 0x0c, 0xf6, 0xf6, 0x66, 0xf8, 0xe8, 0xf6, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0xdc,
0xd7, 0x3e, 0x5c, 0x6e, 0x2d, 0x00, 0x00,
// 2758 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xdf, 0x6f, 0x1b, 0xc7,
0xf1, 0xf7, 0xf1, 0x87, 0x44, 0x0e, 0x29, 0x8a, 0x5e, 0x39, 0x32, 0xc3, 0x38, 0xb2, 0x7c, 0x49,
0x1c, 0xc5, 0x71, 0x24, 0x5b, 0xfe, 0x06, 0xdf, 0xa0, 0x4e, 0x1a, 0x58, 0x96, 0x2d, 0x13, 0x95,
0x5c, 0xe5, 0xa8, 0xd8, 0x45, 0x03, 0x94, 0x38, 0xf1, 0x56, 0xd4, 0xd5, 0xbc, 0x3b, 0xfa, 0x6e,
0x29, 0x5b, 0x79, 0x89, 0x91, 0x02, 0x05, 0x5a, 0xb4, 0x4d, 0x8a, 0xbe, 0x16, 0x68, 0xd1, 0xa7,
0x02, 0x7d, 0x29, 0xfa, 0x98, 0xfe, 0x03, 0x45, 0xfb, 0xde, 0xbf, 0xa1, 0x6f, 0xfd, 0x17, 0x8a,
0xfd, 0x71, 0x7b, 0x3f, 0x78, 0x47, 0x1e, 0x25, 0xff, 0x78, 0xe3, 0xee, 0xcd, 0xce, 0xcc, 0xce,
0xce, 0x7c, 0x66, 0x66, 0x97, 0x50, 0x37, 0x74, 0xa2, 0x77, 0xba, 0x8e, 0xe3, 0x1a, 0xab, 0x03,
0xd7, 0x21, 0x0e, 0x3a, 0x6b, 0x99, 0xfd, 0xa3, 0xa1, 0xc7, 0x47, 0xab, 0xf4, 0x73, 0xb3, 0xda,
0x75, 0x2c, 0xcb, 0xb1, 0xf9, 0x54, 0xb3, 0x66, 0xda, 0x04, 0xbb, 0xb6, 0xde, 0x17, 0xe3, 0x6a,
0x78, 0x41, 0xb3, 0xea, 0x75, 0x0f, 0xb1, 0xa5, 0xf3, 0x91, 0xfa, 0x14, 0xaa, 0x77, 0xfb, 0x43,
0xef, 0x50, 0xc3, 0x8f, 0x87, 0xd8, 0x23, 0xe8, 0x1a, 0x14, 0xf6, 0x75, 0x0f, 0x37, 0x94, 0x65,
0x65, 0xa5, 0xb2, 0x7e, 0x61, 0x35, 0x22, 0x4b, 0x48, 0xd9, 0xf1, 0x7a, 0x1b, 0xba, 0x87, 0x35,
0x46, 0x89, 0x10, 0x14, 0x8c, 0xfd, 0xd6, 0x66, 0x23, 0xb7, 0xac, 0xac, 0xe4, 0x35, 0xf6, 0x1b,
0xa9, 0x50, 0xed, 0x3a, 0xfd, 0x3e, 0xee, 0x12, 0xd3, 0xb1, 0x5b, 0x9b, 0x8d, 0x02, 0xfb, 0x16,
0x99, 0x53, 0x7f, 0xaf, 0xc0, 0x9c, 0x10, 0xed, 0x0d, 0x1c, 0xdb, 0xc3, 0xe8, 0x06, 0xcc, 0x78,
0x44, 0x27, 0x43, 0x4f, 0x48, 0x7f, 0x23, 0x51, 0x7a, 0x9b, 0x91, 0x68, 0x82, 0x34, 0x93, 0xf8,
0xfc, 0xa8, 0x78, 0xb4, 0x04, 0xe0, 0xe1, 0x9e, 0x85, 0x6d, 0xd2, 0xda, 0xf4, 0x1a, 0x85, 0xe5,
0xfc, 0x4a, 0x5e, 0x0b, 0xcd, 0xa8, 0xbf, 0x55, 0xa0, 0xde, 0xf6, 0x87, 0xbe, 0x75, 0xce, 0x41,
0xb1, 0xeb, 0x0c, 0x6d, 0xc2, 0x14, 0x9c, 0xd3, 0xf8, 0x00, 0x5d, 0x82, 0x6a, 0xf7, 0x50, 0xb7,
0x6d, 0xdc, 0xef, 0xd8, 0xba, 0x85, 0x99, 0x2a, 0x65, 0xad, 0x22, 0xe6, 0xee, 0xeb, 0x16, 0xce,
0xa4, 0xd1, 0x32, 0x54, 0x06, 0xba, 0x4b, 0xcc, 0x88, 0xcd, 0xc2, 0x53, 0xea, 0x1f, 0x15, 0x58,
0xbc, 0xe5, 0x79, 0x66, 0xcf, 0x1e, 0xd1, 0x6c, 0x11, 0x66, 0x6c, 0xc7, 0xc0, 0xad, 0x4d, 0xa6,
0x5a, 0x5e, 0x13, 0x23, 0xf4, 0x06, 0x94, 0x07, 0x18, 0xbb, 0x1d, 0xd7, 0xe9, 0xfb, 0x8a, 0x95,
0xe8, 0x84, 0xe6, 0xf4, 0x31, 0xfa, 0x0c, 0xce, 0x7a, 0x31, 0x46, 0x5e, 0x23, 0xbf, 0x9c, 0x5f,
0xa9, 0xac, 0xbf, 0xb5, 0x3a, 0xe2, 0x65, 0xab, 0x71, 0xa1, 0xda, 0xe8, 0x6a, 0xf5, 0x59, 0x0e,
0x16, 0x24, 0x1d, 0xd7, 0x95, 0xfe, 0xa6, 0x96, 0xf3, 0x70, 0x4f, 0xaa, 0xc7, 0x07, 0x59, 0x2c,
0x27, 0x4d, 0x9e, 0x0f, 0x9b, 0x3c, 0x83, 0x83, 0xc5, 0xed, 0x59, 0x1c, 0xb1, 0x27, 0xba, 0x08,
0x15, 0xfc, 0x74, 0x60, 0xba, 0xb8, 0x43, 0x4c, 0x0b, 0x37, 0x66, 0x96, 0x95, 0x95, 0x82, 0x06,
0x7c, 0x6a, 0xcf, 0xb4, 0xc2, 0x1e, 0x39, 0x9b, 0xd9, 0x23, 0xd5, 0x3f, 0x29, 0x70, 0x7e, 0xe4,
0x94, 0x84, 0x8b, 0x6b, 0x50, 0x67, 0x3b, 0x0f, 0x2c, 0x43, 0x9d, 0x9d, 0x1a, 0xfc, 0xf2, 0x38,
0x83, 0x07, 0xe4, 0xda, 0xc8, 0xfa, 0x90, 0x92, 0xb9, 0xec, 0x4a, 0x3e, 0x82, 0xf3, 0x5b, 0x98,
0x08, 0x01, 0xf4, 0x1b, 0xf6, 0x4e, 0x0e, 0x01, 0xd1, 0x58, 0xca, 0x8d, 0xc4, 0xd2, 0x5f, 0x73,
0x32, 0x96, 0x98, 0xa8, 0x96, 0x7d, 0xe0, 0xa0, 0x0b, 0x50, 0x96, 0x24, 0xc2, 0x2b, 0x82, 0x09,
0xf4, 0xff, 0x50, 0xa4, 0x9a, 0x72, 0x97, 0xa8, 0xad, 0x5f, 0x4a, 0xde, 0x53, 0x88, 0xa7, 0xc6,
0xe9, 0x51, 0x0b, 0x6a, 0x1e, 0xd1, 0x5d, 0xd2, 0x19, 0x38, 0x1e, 0x3b, 0x67, 0xe6, 0x38, 0x95,
0x75, 0x35, 0xca, 0x41, 0x42, 0xe4, 0x8e, 0xd7, 0xdb, 0x15, 0x94, 0xda, 0x1c, 0x5b, 0xe9, 0x0f,
0xd1, 0x1d, 0xa8, 0x62, 0xdb, 0x08, 0x18, 0x15, 0x32, 0x33, 0xaa, 0x60, 0xdb, 0x90, 0x6c, 0x82,
0xf3, 0x29, 0x66, 0x3f, 0x9f, 0x5f, 0x29, 0xd0, 0x18, 0x3d, 0xa0, 0xd3, 0x00, 0xe5, 0x4d, 0xbe,
0x08, 0xf3, 0x03, 0x1a, 0x1b, 0xe1, 0xf2, 0x90, 0x34, 0xb1, 0x44, 0x35, 0xe1, 0xb5, 0x40, 0x1b,
0xf6, 0xe5, 0x85, 0x39, 0xcb, 0xcf, 0x14, 0x58, 0x8c, 0xcb, 0x3a, 0xcd, 0xbe, 0xff, 0x0f, 0x8a,
0xa6, 0x7d, 0xe0, 0xf8, 0xdb, 0x5e, 0x1a, 0x13, 0x67, 0x54, 0x16, 0x27, 0x56, 0x2d, 0x78, 0x63,
0x0b, 0x93, 0x96, 0xed, 0x61, 0x97, 0x6c, 0x98, 0x76, 0xdf, 0xe9, 0xed, 0xea, 0xe4, 0xf0, 0x14,
0x31, 0x12, 0x71, 0xf7, 0x5c, 0xcc, 0xdd, 0xd5, 0x3f, 0x2b, 0x70, 0x21, 0x59, 0x9e, 0xd8, 0x7a,
0x13, 0x4a, 0x07, 0x26, 0xee, 0x1b, 0xd4, 0x66, 0x0a, 0xb3, 0x99, 0x1c, 0xd3, 0x58, 0x19, 0x50,
0x62, 0xb1, 0xc3, 0x4b, 0x29, 0x0e, 0xda, 0x26, 0xae, 0x69, 0xf7, 0xb6, 0x4d, 0x8f, 0x68, 0x9c,
0x3e, 0x64, 0xcf, 0x7c, 0x76, 0xcf, 0xfc, 0xa5, 0x02, 0x4b, 0x5b, 0x98, 0xdc, 0x96, 0x50, 0x4b,
0xbf, 0x9b, 0x1e, 0x31, 0xbb, 0xde, 0x8b, 0x2d, 0x22, 0x12, 0x72, 0xa6, 0xfa, 0x8d, 0x02, 0x17,
0x53, 0x95, 0x11, 0xa6, 0x13, 0x50, 0xe2, 0x03, 0x6d, 0x32, 0x94, 0xfc, 0x00, 0x1f, 0x3f, 0xd0,
0xfb, 0x43, 0xbc, 0xab, 0x9b, 0x2e, 0x87, 0x92, 0x13, 0x02, 0xeb, 0x5f, 0x14, 0x78, 0x73, 0x0b,
0x93, 0x5d, 0x3f, 0xcd, 0xbc, 0x42, 0xeb, 0x64, 0xa8, 0x28, 0x7e, 0xc3, 0x0f, 0x33, 0x51, 0xdb,
0x57, 0x62, 0xbe, 0x25, 0x16, 0x07, 0xa1, 0x80, 0xbc, 0xcd, 0x6b, 0x01, 0x61, 0x3c, 0xf5, 0x59,
0x1e, 0xaa, 0x0f, 0x44, 0x7d, 0xc0, 0xd2, 0x48, 0xdc, 0x0e, 0x4a, 0xb2, 0x1d, 0x42, 0x25, 0x45,
0x52, 0x95, 0xb1, 0x05, 0x73, 0x1e, 0xc6, 0x8f, 0x4e, 0x92, 0x34, 0xaa, 0x74, 0xa1, 0x04, 0xfb,
0x6d, 0x38, 0x3b, 0xb4, 0x0f, 0x68, 0x59, 0x8b, 0x0d, 0xb1, 0x0b, 0x5e, 0x5d, 0x4e, 0x46, 0x9e,
0xd1, 0x85, 0xe8, 0x1e, 0xcc, 0xc7, 0x79, 0x15, 0x33, 0xf1, 0x8a, 0x2f, 0x43, 0x2d, 0xa8, 0x1b,
0xae, 0x33, 0x18, 0x60, 0xa3, 0xe3, 0xf9, 0xac, 0x66, 0xb2, 0xb1, 0x12, 0xeb, 0x7c, 0x56, 0xea,
0x2f, 0x14, 0x58, 0x7c, 0xa8, 0x93, 0xee, 0xe1, 0xa6, 0x25, 0x0e, 0xe7, 0x14, 0xae, 0xfd, 0x09,
0x94, 0x8f, 0xc4, 0x41, 0xf8, 0xf8, 0x75, 0x31, 0x41, 0xa1, 0xf0, 0x91, 0x6b, 0xc1, 0x0a, 0xf5,
0x1f, 0x0a, 0x9c, 0x63, 0x4d, 0x84, 0xaf, 0xdd, 0xcb, 0x0f, 0xb2, 0x09, 0x8d, 0x04, 0xba, 0x0c,
0x35, 0x4b, 0x77, 0x1f, 0xb5, 0x03, 0x9a, 0x22, 0xa3, 0x89, 0xcd, 0xaa, 0x4f, 0x01, 0xc4, 0x68,
0xc7, 0xeb, 0x9d, 0x40, 0xff, 0x8f, 0x60, 0x56, 0x48, 0x15, 0xf1, 0x36, 0xe9, 0x60, 0x7d, 0x72,
0xf5, 0x9f, 0x0a, 0xd4, 0x02, 0x04, 0x65, 0x51, 0x55, 0x83, 0x9c, 0x8c, 0xa5, 0x5c, 0x6b, 0x13,
0x7d, 0x02, 0x33, 0xbc, 0x6d, 0x14, 0xbc, 0xdf, 0x89, 0xf2, 0x16, 0x2d, 0x65, 0x08, 0x86, 0xd9,
0x84, 0x26, 0x16, 0x51, 0x1b, 0x49, 0xd4, 0xe1, 0x1d, 0x46, 0x5e, 0x0b, 0xcd, 0xa0, 0x16, 0xcc,
0x47, 0x8b, 0x36, 0x3f, 0x66, 0x96, 0xd3, 0xd0, 0x66, 0x53, 0x27, 0x3a, 0x03, 0x9b, 0x5a, 0xa4,
0x66, 0xf3, 0xd4, 0xff, 0x16, 0xa1, 0x12, 0xda, 0xe5, 0xc8, 0x4e, 0xe2, 0x47, 0x9a, 0x9b, 0x8c,
0x9b, 0xf9, 0xd1, 0xce, 0xe1, 0x1d, 0xa8, 0x99, 0x2c, 0x57, 0x77, 0x84, 0x2b, 0x32, 0x70, 0x2d,
0x6b, 0x73, 0x7c, 0x56, 0xc4, 0x05, 0x5a, 0x82, 0x8a, 0x3d, 0xb4, 0x3a, 0xce, 0x41, 0xc7, 0x75,
0x9e, 0x78, 0xa2, 0x05, 0x29, 0xdb, 0x43, 0xeb, 0x87, 0x07, 0x9a, 0xf3, 0xc4, 0x0b, 0xaa, 0xdc,
0x99, 0x29, 0xab, 0xdc, 0x25, 0xa8, 0x58, 0xfa, 0x53, 0xca, 0xb5, 0x63, 0x0f, 0x2d, 0xd6, 0x9d,
0xe4, 0xb5, 0xb2, 0xa5, 0x3f, 0xd5, 0x9c, 0x27, 0xf7, 0x87, 0x16, 0x5a, 0x81, 0x7a, 0x5f, 0xf7,
0x48, 0x27, 0xdc, 0xde, 0x94, 0x58, 0x7b, 0x53, 0xa3, 0xf3, 0x77, 0x82, 0x16, 0x67, 0xb4, 0x5e,
0x2e, 0x9f, 0xa2, 0x5e, 0x36, 0xac, 0x7e, 0xc0, 0x08, 0xb2, 0xd7, 0xcb, 0x86, 0xd5, 0x97, 0x6c,
0x3e, 0x82, 0xd9, 0x7d, 0x56, 0x01, 0x79, 0x8d, 0x4a, 0x2a, 0x42, 0xdd, 0xa5, 0xc5, 0x0f, 0x2f,
0x94, 0x34, 0x9f, 0x1c, 0x7d, 0x0c, 0x65, 0x96, 0x7a, 0xd8, 0xda, 0x6a, 0xa6, 0xb5, 0xc1, 0x02,
0x0a, 0x45, 0x06, 0xee, 0x13, 0x9d, 0xad, 0x9e, 0x4b, 0x85, 0xa2, 0x4d, 0x4a, 0xb3, 0xed, 0xf4,
0x38, 0x14, 0xc9, 0x15, 0xe8, 0x1a, 0x2c, 0x74, 0x5d, 0xac, 0x13, 0x6c, 0x6c, 0x1c, 0xdf, 0x76,
0xac, 0x81, 0xce, 0xbc, 0xa9, 0x51, 0x5b, 0x56, 0x56, 0x4a, 0x5a, 0xd2, 0x27, 0x8a, 0x0c, 0x5d,
0x39, 0xba, 0xeb, 0x3a, 0x56, 0x63, 0x9e, 0x23, 0x43, 0x74, 0x16, 0xbd, 0x09, 0xe0, 0x63, 0xb7,
0x4e, 0x1a, 0x75, 0x76, 0x8c, 0x65, 0x31, 0x73, 0x8b, 0xa8, 0x5f, 0xc1, 0xb9, 0xc0, 0x45, 0x42,
0xc7, 0x31, 0x7a, 0xb2, 0xca, 0x49, 0x4f, 0x76, 0x7c, 0xf1, 0xfa, 0xb7, 0x02, 0x2c, 0xb6, 0xf5,
0x23, 0xfc, 0xe2, 0xeb, 0xe4, 0x4c, 0x80, 0xbc, 0x0d, 0x67, 0x59, 0x69, 0xbc, 0x1e, 0xd2, 0x67,
0x4c, 0x0a, 0x0e, 0x7b, 0xc3, 0xe8, 0x42, 0xf4, 0x29, 0xad, 0x1d, 0x70, 0xf7, 0xd1, 0xae, 0x63,
0x06, 0xe9, 0xf7, 0xcd, 0x04, 0x3e, 0xb7, 0x25, 0x95, 0x16, 0x5e, 0x81, 0x76, 0x47, 0xb1, 0x8d,
0x27, 0xde, 0x77, 0xc7, 0x36, 0x60, 0x81, 0xf5, 0xe3, 0x10, 0x87, 0x1a, 0x30, 0x2b, 0xd2, 0x3b,
0x0b, 0xfc, 0x92, 0xe6, 0x0f, 0xd1, 0x2e, 0x2c, 0xf0, 0x1d, 0xb4, 0x85, 0x57, 0xf3, 0xcd, 0x97,
0x32, 0x6d, 0x3e, 0x69, 0x69, 0x34, 0x28, 0xca, 0x53, 0x07, 0x45, 0x03, 0x66, 0x85, 0xa3, 0x32,
0x34, 0x28, 0x69, 0xfe, 0x90, 0xb6, 0x11, 0x10, 0x98, 0x6c, 0xc2, 0x6d, 0xc0, 0xf7, 0xa1, 0x24,
0x9d, 0x38, 0x97, 0xd9, 0x89, 0xe5, 0x9a, 0x38, 0x0e, 0xe7, 0x63, 0x38, 0xac, 0xfe, 0x4b, 0x81,
0x6a, 0x78, 0x0b, 0x14, 0xdf, 0x5d, 0xdc, 0x75, 0x5c, 0xa3, 0x83, 0x6d, 0xe2, 0x9a, 0x98, 0x77,
0x9c, 0x05, 0x6d, 0x8e, 0xcf, 0xde, 0xe1, 0x93, 0x94, 0x8c, 0x42, 0xab, 0x47, 0x74, 0x6b, 0xd0,
0x39, 0xa0, 0x11, 0x9c, 0xe3, 0x64, 0x72, 0x96, 0x05, 0xf0, 0x25, 0xa8, 0x06, 0x64, 0xc4, 0x61,
0xf2, 0x0b, 0x5a, 0x45, 0xce, 0xed, 0x39, 0xe8, 0x6d, 0xa8, 0x31, 0xab, 0x75, 0xfa, 0x4e, 0xaf,
0x43, 0xbb, 0x33, 0x91, 0x50, 0xaa, 0x86, 0x50, 0x8b, 0x1e, 0x47, 0x94, 0xca, 0x33, 0xbf, 0xc4,
0x22, 0xa5, 0x48, 0xaa, 0xb6, 0xf9, 0x25, 0x56, 0xbf, 0x56, 0x60, 0x8e, 0xe6, 0xc7, 0xfb, 0x8e,
0x81, 0xf7, 0x4e, 0x58, 0x4d, 0x64, 0xb8, 0x99, 0xbb, 0x00, 0x65, 0xb9, 0x03, 0xb1, 0xa5, 0x60,
0x82, 0xb6, 0xf1, 0x73, 0x22, 0x0d, 0xb6, 0xe5, 0x4d, 0x2d, 0x63, 0xa5, 0x30, 0x56, 0xec, 0x37,
0xfa, 0x5e, 0xf4, 0x9a, 0xe7, 0xed, 0xc4, 0xb8, 0x62, 0x4c, 0x58, 0xc5, 0x19, 0xc9, 0x81, 0x59,
0xfa, 0xc3, 0x67, 0xf4, 0x60, 0x85, 0x29, 0xd8, 0xc1, 0x36, 0x60, 0x56, 0x37, 0x0c, 0x17, 0x7b,
0x9e, 0xd0, 0xc3, 0x1f, 0xd2, 0x2f, 0x47, 0xd8, 0xf5, 0x7c, 0x17, 0xcb, 0x6b, 0xfe, 0x10, 0x7d,
0x0c, 0x25, 0x59, 0xa2, 0xe6, 0x93, 0xca, 0x92, 0xb0, 0x9e, 0xa2, 0x9f, 0x91, 0x2b, 0xd4, 0x6f,
0x72, 0x50, 0x13, 0x61, 0xbd, 0x21, 0xf2, 0xd4, 0x78, 0x67, 0xdf, 0x80, 0xea, 0x41, 0x10, 0x96,
0xe3, 0xee, 0x2d, 0xc2, 0xd1, 0x1b, 0x59, 0x33, 0xc9, 0xe1, 0xa3, 0x99, 0xb2, 0x70, 0xaa, 0x4c,
0x59, 0x9c, 0x16, 0x14, 0xd4, 0x5b, 0x50, 0x09, 0x31, 0x66, 0x70, 0xc6, 0xaf, 0x32, 0x84, 0x2d,
0xfc, 0x21, 0xfd, 0xb2, 0x1f, 0x32, 0x42, 0x59, 0x66, 0x7a, 0x5a, 0xf7, 0x9f, 0xdf, 0xc2, 0x44,
0xc3, 0x5d, 0xe7, 0x08, 0xbb, 0xc7, 0xa7, 0xbf, 0x25, 0xba, 0x19, 0x3a, 0xe3, 0x8c, 0x6d, 0x88,
0x5c, 0x80, 0x6e, 0x06, 0x7a, 0xe6, 0x93, 0x9a, 0xe4, 0x30, 0xb4, 0x8b, 0x13, 0x0a, 0xb6, 0xf2,
0x2d, 0xbf, 0xef, 0x8a, 0x6e, 0xe5, 0xa4, 0xd9, 0xf3, 0xb9, 0x54, 0xb7, 0xea, 0xef, 0x14, 0x78,
0x7d, 0x0b, 0x93, 0xbb, 0xd1, 0x1e, 0xf2, 0x55, 0x6b, 0x65, 0x41, 0x33, 0x49, 0xa9, 0xd3, 0x9c,
0x7a, 0x13, 0x4a, 0xb2, 0x1b, 0xe6, 0x37, 0x91, 0x72, 0xac, 0xfe, 0x5c, 0x81, 0x86, 0x90, 0xc2,
0x64, 0xd2, 0xc2, 0xad, 0x8f, 0x09, 0x36, 0x5e, 0x76, 0x7b, 0xf6, 0x07, 0x05, 0xea, 0x61, 0x10,
0x64, 0x38, 0xf6, 0x21, 0x14, 0x59, 0x17, 0x2c, 0x34, 0x98, 0xe8, 0xac, 0x9c, 0x9a, 0x46, 0x14,
0x2b, 0x26, 0xf6, 0x3c, 0x1f, 0xe4, 0xc4, 0x30, 0x40, 0xe2, 0xfc, 0xd4, 0x48, 0xac, 0xfe, 0x3a,
0x07, 0x8d, 0xa0, 0xae, 0x7d, 0xe9, 0x60, 0x97, 0x52, 0xf5, 0xe4, 0x9f, 0x53, 0xd5, 0x53, 0x98,
0x1a, 0xe0, 0xfe, 0x9e, 0xa3, 0x0d, 0xb5, 0x6f, 0x8f, 0xdd, 0xbe, 0x6e, 0xa3, 0x45, 0x98, 0x19,
0xf4, 0xf5, 0xe0, 0x82, 0x4a, 0x8c, 0x50, 0x1b, 0x6a, 0x5e, 0xc4, 0x5e, 0xc2, 0x02, 0xef, 0x27,
0xd9, 0x3f, 0xc5, 0xc4, 0x5a, 0x8c, 0x05, 0x6d, 0x18, 0x78, 0xc9, 0xc9, 0xfa, 0x3e, 0x91, 0x9a,
0xf9, 0x41, 0xd3, 0x96, 0xef, 0x2a, 0x20, 0xfa, 0xc1, 0x19, 0x92, 0x8e, 0x69, 0x77, 0x3c, 0xdc,
0x75, 0x6c, 0xc3, 0x63, 0xf5, 0x46, 0x51, 0xab, 0x8b, 0x2f, 0x2d, 0xbb, 0xcd, 0xe7, 0xd1, 0x87,
0x50, 0x20, 0xc7, 0x03, 0x5e, 0x69, 0xd4, 0x12, 0x91, 0x2d, 0xd0, 0x6b, 0xef, 0x78, 0x80, 0x35,
0x46, 0x4e, 0x5b, 0x7e, 0xca, 0x8a, 0xb8, 0xfa, 0x11, 0xee, 0xfb, 0x4f, 0x6b, 0xc1, 0x0c, 0xf5,
0x44, 0xbf, 0x75, 0x9e, 0xe5, 0x89, 0x58, 0x0c, 0xd5, 0xef, 0x72, 0x50, 0x0f, 0x58, 0x6a, 0xd8,
0x1b, 0xf6, 0x49, 0xaa, 0xfd, 0xc6, 0xb7, 0x0b, 0x93, 0xd2, 0xe0, 0xa7, 0x50, 0x11, 0x6d, 0xfc,
0x14, 0x89, 0x10, 0xf8, 0x92, 0xed, 0x31, 0xae, 0x57, 0x7c, 0x4e, 0xae, 0x37, 0x33, 0xb5, 0xeb,
0xb5, 0x61, 0xd1, 0x07, 0xad, 0x40, 0xd2, 0x0e, 0x26, 0xfa, 0x98, 0x34, 0x7b, 0x11, 0x2a, 0x3c,
0x19, 0xf1, 0xc2, 0x93, 0x97, 0x7a, 0xb0, 0x2f, 0x9b, 0x20, 0xf5, 0x27, 0x70, 0x8e, 0x05, 0x7d,
0xfc, 0xba, 0x2f, 0xcb, 0xdd, 0xab, 0x2a, 0x0b, 0x49, 0x5a, 0x34, 0xfa, 0x89, 0x3c, 0x32, 0xa7,
0x6e, 0xc3, 0x6b, 0x31, 0xfe, 0xa7, 0x00, 0x75, 0xf5, 0x3b, 0x05, 0x5e, 0xdf, 0x74, 0x9d, 0xc1,
0x03, 0xd3, 0x25, 0x43, 0xbd, 0x1f, 0xbd, 0x40, 0x7e, 0x31, 0xa5, 0xf0, 0xbd, 0x50, 0x1e, 0xe1,
0xb0, 0x73, 0x35, 0xe9, 0xcc, 0x46, 0x94, 0x12, 0x47, 0x15, 0xca, 0x3a, 0xff, 0xc9, 0x27, 0x29,
0x2f, 0xe8, 0x26, 0x60, 0x69, 0x96, 0x34, 0x9b, 0xd8, 0x1c, 0xe7, 0x4f, 0xda, 0x1c, 0xa7, 0xb8,
0x7f, 0xe1, 0x39, 0xb9, 0xff, 0xd4, 0xa5, 0x25, 0xba, 0x07, 0xd1, 0x9b, 0x0b, 0x06, 0x3c, 0x27,
0xba, 0xf2, 0xd8, 0x00, 0x08, 0xba, 0x78, 0xf1, 0xfc, 0x9f, 0x85, 0x4d, 0x68, 0x15, 0x3d, 0x2e,
0x89, 0x35, 0xec, 0xfa, 0x2d, 0xd2, 0x74, 0x7e, 0x06, 0xcd, 0x24, 0x37, 0x3d, 0x85, 0xeb, 0x5f,
0xb9, 0x0e, 0x67, 0x47, 0x92, 0x34, 0xaa, 0x01, 0x7c, 0x6e, 0x77, 0x45, 0xf5, 0x52, 0x3f, 0x83,
0xaa, 0x50, 0xf2, 0x6b, 0x99, 0xba, 0x72, 0xa5, 0x1d, 0x4e, 0x55, 0x14, 0xbf, 0xd1, 0x79, 0x58,
0xf8, 0xdc, 0x36, 0xf0, 0x81, 0x69, 0x63, 0x23, 0xf8, 0x54, 0x3f, 0x83, 0x16, 0x60, 0xbe, 0x65,
0xdb, 0xd8, 0x0d, 0x4d, 0x2a, 0x74, 0x72, 0x07, 0xbb, 0x3d, 0x1c, 0x9a, 0xcc, 0xad, 0x7f, 0xbb,
0x00, 0x65, 0xda, 0x76, 0xdd, 0x76, 0x1c, 0xd7, 0x40, 0x03, 0x40, 0xec, 0x8d, 0xce, 0x1a, 0x38,
0xb6, 0x7c, 0xcc, 0x46, 0xd7, 0x52, 0x8c, 0x39, 0x4a, 0x2a, 0x42, 0xb7, 0x79, 0x39, 0x65, 0x45,
0x8c, 0x5c, 0x3d, 0x83, 0x2c, 0x26, 0x91, 0x26, 0xbb, 0x3d, 0xb3, 0xfb, 0xc8, 0xbf, 0x8d, 0x1d,
0x23, 0x31, 0x46, 0xea, 0x4b, 0x8c, 0xbd, 0x91, 0x8b, 0x01, 0x7f, 0x48, 0xf5, 0x4f, 0x4a, 0x3d,
0x83, 0x1e, 0xc3, 0xb9, 0x2d, 0x4c, 0x82, 0xb7, 0x33, 0x5f, 0xe0, 0x7a, 0xba, 0xc0, 0x11, 0xe2,
0x29, 0x45, 0x6e, 0x43, 0x91, 0x55, 0xa5, 0x28, 0x29, 0x3a, 0xc2, 0xff, 0xe8, 0x6a, 0x2e, 0xa7,
0x13, 0x48, 0x6e, 0x3f, 0x85, 0xf9, 0xd8, 0x3f, 0x56, 0xd0, 0x7b, 0x09, 0xcb, 0x92, 0xff, 0x7b,
0xd4, 0xbc, 0x92, 0x85, 0x54, 0xca, 0xea, 0x41, 0x2d, 0xfa, 0xc2, 0x87, 0x56, 0x12, 0xd6, 0x27,
0xfe, 0xdb, 0xa0, 0xf9, 0x5e, 0x06, 0x4a, 0x29, 0xc8, 0x82, 0x7a, 0xfc, 0x1f, 0x14, 0xe8, 0xca,
0x58, 0x06, 0x51, 0x77, 0x7b, 0x3f, 0x13, 0xad, 0x14, 0x77, 0xcc, 0x9c, 0x60, 0xe4, 0x05, 0x1f,
0xad, 0x26, 0xb3, 0x49, 0xfb, 0x6b, 0x41, 0x73, 0x2d, 0x33, 0xbd, 0x14, 0xfd, 0x35, 0xef, 0x86,
0x93, 0x5e, 0xc1, 0xd1, 0xf5, 0x64, 0x76, 0x63, 0x9e, 0xef, 0x9b, 0xeb, 0xd3, 0x2c, 0x91, 0x4a,
0x7c, 0xc5, 0xda, 0xd8, 0x84, 0x97, 0xe4, 0x78, 0xdc, 0xf9, 0xfc, 0xd2, 0x9f, 0xc8, 0x9b, 0xd7,
0xa7, 0x58, 0x21, 0x15, 0x70, 0xe2, 0xff, 0x51, 0xf1, 0xc3, 0x70, 0x6d, 0xa2, 0xd7, 0x9c, 0x2c,
0x06, 0xbf, 0x80, 0xf9, 0xd8, 0xb5, 0x77, 0x62, 0xd4, 0x24, 0x5f, 0x8d, 0x37, 0xc7, 0x01, 0x3a,
0x0f, 0xc9, 0xd8, 0xad, 0x00, 0x4a, 0xf1, 0xfe, 0x84, 0x9b, 0x83, 0xe6, 0x95, 0x2c, 0xa4, 0x72,
0x23, 0x1e, 0x83, 0xcb, 0x58, 0x67, 0x8d, 0xae, 0x26, 0xf3, 0x48, 0xbe, 0x15, 0x68, 0x7e, 0x90,
0x91, 0x5a, 0x0a, 0xed, 0x00, 0x6c, 0x61, 0xb2, 0x83, 0x89, 0x4b, 0x7d, 0xe4, 0x72, 0xa2, 0xc9,
0x03, 0x02, 0x5f, 0xcc, 0xbb, 0x13, 0xe9, 0xa4, 0x80, 0x1f, 0x01, 0xf2, 0xf3, 0x5c, 0xe8, 0xd1,
0xe5, 0xad, 0xb1, 0x0d, 0x0c, 0xef, 0x36, 0x26, 0x9d, 0xcd, 0x63, 0xa8, 0xef, 0xe8, 0x36, 0x4d,
0xda, 0x01, 0xdf, 0xab, 0x89, 0x8a, 0xc5, 0xc9, 0x52, 0xac, 0x95, 0x4a, 0x2d, 0x37, 0xf3, 0x44,
0xe6, 0x50, 0x5d, 0x86, 0x20, 0x8e, 0x63, 0x4b, 0x60, 0x8d, 0x18, 0x61, 0x0a, 0xb6, 0x8c, 0xa1,
0x97, 0x82, 0x9f, 0x29, 0xec, 0x9f, 0x50, 0x31, 0x82, 0x87, 0x26, 0x39, 0xa4, 0x7d, 0xad, 0x97,
0x45, 0x05, 0x46, 0x38, 0x85, 0x0a, 0x82, 0x5e, 0xaa, 0x60, 0xc0, 0x5c, 0xa4, 0x3d, 0x40, 0x49,
0x2f, 0x27, 0x49, 0x0d, 0x4a, 0x73, 0x65, 0x32, 0xa1, 0x94, 0x72, 0x08, 0x73, 0xbe, 0xbf, 0x72,
0xe3, 0xbe, 0x97, 0xa6, 0x69, 0x40, 0x93, 0x12, 0x6e, 0xc9, 0xa4, 0xe1, 0x70, 0x1b, 0x2d, 0xfc,
0x50, 0xb6, 0x8e, 0x61, 0x5c, 0xb8, 0xa5, 0x57, 0x93, 0xea, 0x99, 0xf5, 0x7f, 0x17, 0xa0, 0xe4,
0xdf, 0x84, 0xbf, 0x82, 0x8a, 0xec, 0x15, 0x94, 0x48, 0x5f, 0xc0, 0x7c, 0xec, 0x6f, 0x2a, 0x89,
0x08, 0x9a, 0xfc, 0x57, 0x96, 0x49, 0x10, 0xf0, 0x50, 0xfc, 0x79, 0x5d, 0xa2, 0xe5, 0xbb, 0x69,
0x65, 0x56, 0x1c, 0x28, 0x27, 0x30, 0x7e, 0xe1, 0xb0, 0x78, 0x1f, 0x20, 0x04, 0x5b, 0xe3, 0xef,
0x73, 0x68, 0x24, 0x4e, 0x50, 0x78, 0xe3, 0xc6, 0x8f, 0xaf, 0xf7, 0x4c, 0x72, 0x38, 0xdc, 0xa7,
0x5f, 0xd6, 0x38, 0xe9, 0x07, 0xa6, 0x23, 0x7e, 0xad, 0xf9, 0x27, 0xba, 0xc6, 0x56, 0xaf, 0x51,
0x01, 0x83, 0xfd, 0xfd, 0x19, 0x36, 0xba, 0xf1, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe4, 0x4d,
0xf6, 0xb0, 0xde, 0x30, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -3021,6 +3221,7 @@ type DataCoordClient interface {
GetCompactionStateWithPlans(ctx context.Context, in *milvuspb.GetCompactionPlansRequest, opts ...grpc.CallOption) (*milvuspb.GetCompactionPlansResponse, error)
WatchChannels(ctx context.Context, in *WatchChannelsRequest, opts ...grpc.CallOption) (*WatchChannelsResponse, error)
GetFlushState(ctx context.Context, in *milvuspb.GetFlushStateRequest, opts ...grpc.CallOption) (*milvuspb.GetFlushStateResponse, error)
DropVirtualChannel(ctx context.Context, in *DropVirtualChannelRequest, opts ...grpc.CallOption) (*DropVirtualChannelResponse, error)
}
type dataCoordClient struct {
@ -3220,6 +3421,15 @@ func (c *dataCoordClient) GetFlushState(ctx context.Context, in *milvuspb.GetFlu
return out, nil
}
func (c *dataCoordClient) DropVirtualChannel(ctx context.Context, in *DropVirtualChannelRequest, opts ...grpc.CallOption) (*DropVirtualChannelResponse, error) {
out := new(DropVirtualChannelResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/DropVirtualChannel", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// DataCoordServer is the server API for DataCoord service.
type DataCoordServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
@ -3244,6 +3454,7 @@ type DataCoordServer interface {
GetCompactionStateWithPlans(context.Context, *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error)
WatchChannels(context.Context, *WatchChannelsRequest) (*WatchChannelsResponse, error)
GetFlushState(context.Context, *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)
DropVirtualChannel(context.Context, *DropVirtualChannelRequest) (*DropVirtualChannelResponse, error)
}
// UnimplementedDataCoordServer can be embedded to have forward compatible implementations.
@ -3313,6 +3524,9 @@ func (*UnimplementedDataCoordServer) WatchChannels(ctx context.Context, req *Wat
func (*UnimplementedDataCoordServer) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetFlushState not implemented")
}
func (*UnimplementedDataCoordServer) DropVirtualChannel(ctx context.Context, req *DropVirtualChannelRequest) (*DropVirtualChannelResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method DropVirtualChannel not implemented")
}
func RegisterDataCoordServer(s *grpc.Server, srv DataCoordServer) {
s.RegisterService(&_DataCoord_serviceDesc, srv)
@ -3696,6 +3910,24 @@ func _DataCoord_GetFlushState_Handler(srv interface{}, ctx context.Context, dec
return interceptor(ctx, in, info, handler)
}
func _DataCoord_DropVirtualChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DropVirtualChannelRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DataCoordServer).DropVirtualChannel(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.data.DataCoord/DropVirtualChannel",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DataCoordServer).DropVirtualChannel(ctx, req.(*DropVirtualChannelRequest))
}
return interceptor(ctx, in, info, handler)
}
var _DataCoord_serviceDesc = grpc.ServiceDesc{
ServiceName: "milvus.proto.data.DataCoord",
HandlerType: (*DataCoordServer)(nil),
@ -3784,6 +4016,10 @@ var _DataCoord_serviceDesc = grpc.ServiceDesc{
MethodName: "GetFlushState",
Handler: _DataCoord_GetFlushState_Handler,
},
{
MethodName: "DropVirtualChannel",
Handler: _DataCoord_DropVirtualChannel_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "data_coord.proto",

4
internal/proxy/data_coord_mock_test.go
View File

@ -202,6 +202,10 @@ func (coord *DataCoordMock) GetFlushState(ctx context.Context, req *milvuspb.Get
return &milvuspb.GetFlushStateResponse{}, nil
}
func (coord *DataCoordMock) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
return &datapb.DropVirtualChannelResponse{}, nil
}
func NewDataCoordMock() *DataCoordMock {
return &DataCoordMock{
nodeID: typeutil.UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt()),

13
internal/types/types.go
View File

@ -199,7 +199,7 @@ type DataCoord interface {
// and related message stream positions
//
// ctx is the context to control request deadline and cancellation
// req contains the collection/partition id to query
// req contains the segment binlogs and checkpoint informations.
//
// response status contains the status/error code and failing reason if any
// error is returned only when some communication issue occurs
@ -232,6 +232,17 @@ type DataCoord interface {
WatchChannels(ctx context.Context, req *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error)
// GetFlushState gets the flush state of multiple segments
GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)
// DropVirtualChannel notifies DataCoord a virtual channel is dropped and
// updates related segments binlogs(including insert binlogs, stats logs and delta logs)
// and related message stream positions
//
// ctx is the context to control request deadline and cancellation
// req contains the dropped virtual channel name and related segment information
//
// response status contains the status/error code and failing reason if any
// error is returned only when some communication issue occurs
DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error)
}
// IndexNode is the interface `indexnode` package implements