diff --git a/go.mod b/go.mod index 64a9b5bd78..129304ea1d 100644 --- a/go.mod +++ b/go.mod @@ -49,7 +49,7 @@ require ( go.uber.org/automaxprocs v1.4.0 go.uber.org/zap v1.17.0 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 - golang.org/x/exp v0.0.0-20211216164055-b2b84827b756 + golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c google.golang.org/grpc v1.46.0 google.golang.org/grpc/examples v0.0.0-20220617181431-3e7b97febc7f @@ -139,6 +139,7 @@ require ( github.com/prometheus/procfs v0.6.0 // indirect github.com/quasilyte/go-ruleguard/dsl v0.3.21 // indirect github.com/rs/xid v1.2.1 // indirect + github.com/samber/lo v1.27.0 // indirect github.com/sirupsen/logrus v1.8.1 // indirect github.com/soheilhy/cmux v0.1.5 // indirect github.com/spf13/afero v1.6.0 // indirect diff --git a/go.sum b/go.sum index bb31f83887..97ab85fc7f 100644 --- a/go.sum +++ b/go.sum @@ -605,6 +605,8 @@ github.com/rs/zerolog v1.21.0/go.mod h1:ZPhntP/xmq1nnND05hhpAh2QMhSsA4UN3MGZ6O2J github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w= github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/samber/lo v1.27.0 h1:GOyDWxsblvqYobqsmUuMddPa2/mMzkKyojlXol4+LaQ= +github.com/samber/lo v1.27.0/go.mod h1:it33p9UtPMS7z72fP4gw/EIfQB2eI8ke7GR2wc6+Rhg= github.com/sanity-io/litter v1.2.0/go.mod h1:JF6pZUFgu2Q0sBZ+HSV35P8TVPI1TTzEwyu9FXAw2W4= github.com/santhosh-tekuri/jsonschema/v5 v5.0.0/go.mod h1:FKdcjfQW6rpZSnxxUvEA5H/cDPdvJ/SZJQLWWXWGrZ0= github.com/sbinet/npyio v0.6.0 h1:IyqqQIzRjDym9xnIXsToCKei/qCzxDP+Y74KoMlMgXo= @@ -785,6 +787,8 @@ golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EH golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= golang.org/x/exp v0.0.0-20211216164055-b2b84827b756 h1:/5Bs7sWi0i3rOVO5KnM55OwugpsD4bRW1zywKoZjbkI= golang.org/x/exp v0.0.0-20211216164055-b2b84827b756/go.mod h1:b9TAUYHmRtqA6klRHApnXMnj+OyLce4yF5cZCUbk2ps= +golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 h1:3MTrJm4PyNL9NBqvYDSj3DHl46qQakyfqfWo4jgfaEM= +golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE= golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= diff --git a/internal/datacoord/compaction.go b/internal/datacoord/compaction.go index 7d43beae44..1cc27b1ea1 100644 --- a/internal/datacoord/compaction.go +++ b/internal/datacoord/compaction.go @@ -24,6 +24,7 @@ import ( "time" "github.com/milvus-io/milvus/internal/log" + "github.com/milvus-io/milvus/internal/proto/commonpb" "github.com/milvus-io/milvus/internal/proto/datapb" "github.com/milvus-io/milvus/internal/util/tsoutil" "go.uber.org/zap" @@ -32,9 +33,8 @@ import ( // TODO this num should be determined by resources of datanode, for now, we set to a fixed value for simple // TODO we should split compaction into different priorities, small compaction helps to merge segment, large compaction helps to handle delta and expiration of large segments const ( - maxParallelCompactionTaskNum = 100 - compactionTimeout = 10 * time.Second - compactionExpirationCheckInterval = 60 * time.Second + maxParallelCompactionTaskNum = 100 + rpcCompactionTimeout = 10 * time.Second ) type compactionPlanContext interface { @@ -42,12 +42,10 @@ type compactionPlanContext interface { stop() // execCompactionPlan start to execute plan and return immediately execCompactionPlan(signal *compactionSignal, plan *datapb.CompactionPlan) error - // completeCompaction record the result of a compaction - completeCompaction(result *datapb.CompactionResult) error // getCompaction return compaction task. If planId does not exist, return nil. getCompaction(planID int64) *compactionTask - // expireCompaction set the compaction state to expired - expireCompaction(ts Timestamp) error + // updateCompaction set the compaction state to timeout or completed + updateCompaction(ts Timestamp) error // isFull return true if the task pool is full isFull() bool // get compaction tasks by signal id @@ -59,6 +57,7 @@ type compactionTaskState int8 const ( executing compactionTaskState = iota + 1 completed + failed timeout ) @@ -102,23 +101,26 @@ type compactionPlanHandler struct { wg sync.WaitGroup flushCh chan UniqueID segRefer *SegmentReferenceManager + parallelCh map[int64]chan struct{} } func newCompactionPlanHandler(sessions *SessionManager, cm *ChannelManager, meta *meta, allocator allocator, flush chan UniqueID, segRefer *SegmentReferenceManager) *compactionPlanHandler { return &compactionPlanHandler{ - plans: make(map[int64]*compactionTask), - chManager: cm, - meta: meta, - sessions: sessions, - allocator: allocator, - flushCh: flush, - segRefer: segRefer, + plans: make(map[int64]*compactionTask), + chManager: cm, + meta: meta, + sessions: sessions, + allocator: allocator, + flushCh: flush, + segRefer: segRefer, + parallelCh: make(map[int64]chan struct{}), } } func (c *compactionPlanHandler) start() { - ticker := time.NewTicker(compactionExpirationCheckInterval) + interval := time.Duration(Params.DataCoordCfg.CompactionCheckIntervalInSeconds) * time.Second + ticker := time.NewTicker(interval) c.quit = make(chan struct{}) c.wg.Add(1) @@ -139,7 +141,7 @@ func (c *compactionPlanHandler) start() { continue } cancel() - _ = c.expireCompaction(ts) + _ = c.updateCompaction(ts) } } }() @@ -162,17 +164,40 @@ func (c *compactionPlanHandler) execCompactionPlan(signal *compactionSignal, pla c.setSegmentsCompacting(plan, true) - // FIXME: check response of compaction call and restore segment state if failed - c.sessions.Compaction(nodeID, plan) + go func() { + log.Debug("acquire queue", zap.Int64("nodeID", nodeID), zap.Int64("planID", plan.GetPlanID())) + c.acquireQueue(nodeID) - task := &compactionTask{ - triggerInfo: signal, - plan: plan, - state: executing, - dataNodeID: nodeID, - } - c.plans[plan.PlanID] = task - c.executingTaskNum++ + ts, err := c.allocator.allocTimestamp(context.TODO()) + if err != nil { + log.Warn("Alloc start time for CompactionPlan failed", zap.Int64("planID", plan.GetPlanID())) + return + } + plan.StartTime = ts + + c.mu.Lock() + task := &compactionTask{ + triggerInfo: signal, + plan: plan, + state: executing, + dataNodeID: nodeID, + } + c.plans[plan.PlanID] = task + c.executingTaskNum++ + c.mu.Unlock() + + err = c.sessions.Compaction(nodeID, plan) + if err != nil { + log.Warn("Try to Compaction but DataNode rejected", zap.Any("TargetNodeId", nodeID), zap.Any("planId", plan.GetPlanID())) + c.mu.Lock() + delete(c.plans, plan.PlanID) + c.executingTaskNum-- + c.mu.Unlock() + return + } + + log.Debug("start compaction", zap.Int64("nodeID", nodeID), zap.Int64("planID", plan.GetPlanID())) + }() return nil } @@ -182,11 +207,9 @@ func (c *compactionPlanHandler) setSegmentsCompacting(plan *datapb.CompactionPla } } -// completeCompaction record the result of a compaction +// complete a compaction task +// not threadsafe, only can be used internally func (c *compactionPlanHandler) completeCompaction(result *datapb.CompactionResult) error { - c.mu.Lock() - defer c.mu.Unlock() - planID := result.PlanID if _, ok := c.plans[planID]; !ok { return fmt.Errorf("plan %d is not found", planID) @@ -219,6 +242,8 @@ func (c *compactionPlanHandler) completeCompaction(result *datapb.CompactionResu } // TODO: when to clean task list + nodeID := c.plans[planID].dataNodeID + c.releaseQueue(nodeID) return nil } @@ -241,21 +266,35 @@ func (c *compactionPlanHandler) getCompaction(planID int64) *compactionTask { } // expireCompaction set the compaction state to expired -func (c *compactionPlanHandler) expireCompaction(ts Timestamp) error { +func (c *compactionPlanHandler) updateCompaction(ts Timestamp) error { + planStates := c.sessions.GetCompactionState() + c.mu.Lock() defer c.mu.Unlock() tasks := c.getExecutingCompactions() for _, task := range tasks { - if !c.isTimeout(ts, task.plan.GetStartTime(), task.plan.GetTimeoutInSeconds()) { - continue + stateResult, ok := planStates[task.plan.PlanID] + state := stateResult.GetState() + planID := task.plan.PlanID + + // check wether the state of CompactionPlan is working + if ok { + // check wether the CompactionPlan is timeout + if state == commonpb.CompactionState_Executing && !c.isTimeout(ts, task.plan.GetStartTime(), task.plan.GetTimeoutInSeconds()) { + continue + } + if state == commonpb.CompactionState_Completed { + c.completeCompaction(stateResult.GetResult()) + continue + } + c.plans[planID] = c.plans[planID].shadowClone(setState(timeout)) } + c.plans[planID] = c.plans[planID].shadowClone(setState(failed)) c.setSegmentsCompacting(task.plan, false) - - planID := task.plan.PlanID - c.plans[planID] = c.plans[planID].shadowClone(setState(timeout)) c.executingTaskNum-- + c.releaseQueue(task.dataNodeID) } return nil @@ -267,6 +306,29 @@ func (c *compactionPlanHandler) isTimeout(now Timestamp, start Timestamp, timeou return int32(ts.Sub(startTime).Seconds()) >= timeout } +func (c *compactionPlanHandler) acquireQueue(nodeID int64) { + c.mu.Lock() + _, ok := c.parallelCh[nodeID] + if !ok { + c.parallelCh[nodeID] = make(chan struct{}, calculateParallel()) + } + c.mu.Unlock() + + c.mu.RLock() + ch := c.parallelCh[nodeID] + c.mu.RUnlock() + ch <- struct{}{} +} + +func (c *compactionPlanHandler) releaseQueue(nodeID int64) { + log.Debug("try to release queue", zap.Int64("nodeID", nodeID)) + ch, ok := c.parallelCh[nodeID] + if !ok { + return + } + <-ch +} + // isFull return true if the task pool is full func (c *compactionPlanHandler) isFull() bool { c.mu.RLock() @@ -285,13 +347,17 @@ func (c *compactionPlanHandler) getExecutingCompactions() []*compactionTask { return tasks } -// get compaction tasks by signal id +// get compaction tasks by signal id; if signalID == 0 return all tasks func (c *compactionPlanHandler) getCompactionTasksBySignalID(signalID int64) []*compactionTask { c.mu.RLock() defer c.mu.RUnlock() var tasks []*compactionTask for _, t := range c.plans { + if signalID == 0 { + tasks = append(tasks, t) + continue + } if t.triggerInfo.id != signalID { continue } @@ -313,3 +379,13 @@ func setResult(result *datapb.CompactionResult) compactionTaskOpt { task.result = result } } + +// 0.5*min(8, NumCPU/2) +func calculateParallel() int { + return 2 + //cores := runtime.NumCPU() + //if cores < 16 { + //return 4 + //} + //return cores / 2 +} diff --git a/internal/datacoord/compaction_test.go b/internal/datacoord/compaction_test.go index ef8b762ef7..70db964c83 100644 --- a/internal/datacoord/compaction_test.go +++ b/internal/datacoord/compaction_test.go @@ -22,14 +22,15 @@ import ( "time" memkv "github.com/milvus-io/milvus/internal/kv/mem" + "github.com/milvus-io/milvus/internal/log" "github.com/milvus-io/milvus/internal/metastore/kv/datacoord" + "github.com/milvus-io/milvus/internal/proto/commonpb" "github.com/milvus-io/milvus/internal/proto/datapb" "github.com/milvus-io/milvus/internal/util/tsoutil" "github.com/stretchr/testify/assert" + "go.uber.org/zap" ) -// TODO not completed - func Test_compactionPlanHandler_execCompactionPlan(t *testing.T) { ch := make(chan interface{}, 1) type fields struct { @@ -81,9 +82,11 @@ func Test_compactionPlanHandler_execCompactionPlan(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { c := &compactionPlanHandler{ - plans: tt.fields.plans, - sessions: tt.fields.sessions, - chManager: tt.fields.chManager, + plans: tt.fields.plans, + sessions: tt.fields.sessions, + chManager: tt.fields.chManager, + parallelCh: make(map[int64]chan struct{}), + allocator: newMockAllocator(), } err := c.execCompactionPlan(tt.args.signal, tt.args.plan) assert.Equal(t, tt.err, err) @@ -92,11 +95,69 @@ func Test_compactionPlanHandler_execCompactionPlan(t *testing.T) { task := c.getCompaction(tt.args.plan.PlanID) assert.Equal(t, tt.args.plan, task.plan) assert.Equal(t, tt.args.signal, task.triggerInfo) + assert.Equal(t, 1, c.executingTaskNum) } }) } } +func Test_compactionPlanHandler_execWithParallels(t *testing.T) { + Params.DataCoordCfg.CompactionCheckIntervalInSeconds = 1 + c := &compactionPlanHandler{ + plans: map[int64]*compactionTask{}, + sessions: &SessionManager{ + sessions: struct { + sync.RWMutex + data map[int64]*Session + }{ + data: map[int64]*Session{ + 1: {client: &mockDataNodeClient{ch: make(chan interface{}, 1)}}, + }, + }, + }, + chManager: &ChannelManager{ + store: &ChannelStore{ + channelsInfo: map[int64]*NodeChannelInfo{ + 1: {NodeID: 1, Channels: []*channel{{Name: "ch1"}}}, + }, + }, + }, + parallelCh: make(map[int64]chan struct{}), + allocator: newMockAllocator(), + } + + signal := &compactionSignal{id: 100} + plan1 := &datapb.CompactionPlan{PlanID: 1, Channel: "ch1", Type: datapb.CompactionType_MergeCompaction} + plan2 := &datapb.CompactionPlan{PlanID: 2, Channel: "ch1", Type: datapb.CompactionType_MergeCompaction} + plan3 := &datapb.CompactionPlan{PlanID: 3, Channel: "ch1", Type: datapb.CompactionType_MergeCompaction} + + c.parallelCh[1] = make(chan struct{}, 2) + + go func() { + c.execCompactionPlan(signal, plan1) + c.execCompactionPlan(signal, plan2) + c.execCompactionPlan(signal, plan3) + }() + + <-c.parallelCh[1] + <-c.parallelCh[1] + <-c.parallelCh[1] + + tasks := c.getCompactionTasksBySignalID(0) + max, min := uint64(0), uint64(0) + for _, v := range tasks { + if max < v.plan.GetStartTime() { + max = v.plan.GetStartTime() + } + if min > v.plan.GetStartTime() { + min = v.plan.GetStartTime() + } + } + + log.Debug("start time", zap.Uint64("min", min), zap.Uint64("max", max)) + assert.Less(t, uint64(2), max-min) +} + func Test_compactionPlanHandler_completeCompaction(t *testing.T) { type fields struct { plans map[int64]*compactionTask @@ -378,7 +439,7 @@ func Test_compactionPlanHandler_getCompaction(t *testing.T) { } } -func Test_compactionPlanHandler_expireCompaction(t *testing.T) { +func Test_compactionPlanHandler_updateCompaction(t *testing.T) { type fields struct { plans map[int64]*compactionTask sessions *SessionManager @@ -398,11 +459,12 @@ func Test_compactionPlanHandler_expireCompaction(t *testing.T) { unexpired []int64 }{ { - "test expire compaction task", + "test update compaction task", fields{ plans: map[int64]*compactionTask{ 1: { - state: executing, + state: executing, + dataNodeID: 1, plan: &datapb.CompactionPlan{ PlanID: 1, StartTime: tsoutil.ComposeTS(ts.UnixNano()/int64(time.Millisecond), 0), @@ -413,13 +475,32 @@ func Test_compactionPlanHandler_expireCompaction(t *testing.T) { }, }, 2: { - state: executing, + state: executing, + dataNodeID: 2, plan: &datapb.CompactionPlan{ PlanID: 2, StartTime: tsoutil.ComposeTS(ts.UnixNano()/int64(time.Millisecond), 0), TimeoutInSeconds: 1, }, }, + 3: { + state: completed, + dataNodeID: 2, + plan: &datapb.CompactionPlan{ + PlanID: 3, + StartTime: tsoutil.ComposeTS(ts.UnixNano()/int64(time.Millisecond), 0), + TimeoutInSeconds: 1, + }, + }, + 4: { + state: executing, + dataNodeID: 2, + plan: &datapb.CompactionPlan{ + PlanID: 4, + StartTime: tsoutil.ComposeTS(ts.UnixNano()/int64(time.Millisecond), 0) - 200*1000, + TimeoutInSeconds: 1, + }, + }, }, meta: &meta{ segments: &SegmentsInfo{ @@ -428,11 +509,27 @@ func Test_compactionPlanHandler_expireCompaction(t *testing.T) { }, }, }, + sessions: &SessionManager{ + sessions: struct { + sync.RWMutex + data map[int64]*Session + }{ + data: map[int64]*Session{ + 1: {client: &mockDataNodeClient{ + compactionStateResp: &datapb.CompactionStateResponse{ + Results: []*datapb.CompactionStateResult{ + {PlanID: 1, State: commonpb.CompactionState_Executing}, + }, + }, + }}, + }, + }, + }, }, args{ts: tsoutil.ComposeTS(ts.Add(5*time.Second).UnixNano()/int64(time.Millisecond), 0)}, false, - []int64{2}, - []int64{1}, + []int64{2, 4}, + []int64{1, 3}, }, } for _, tt := range tests { @@ -443,17 +540,17 @@ func Test_compactionPlanHandler_expireCompaction(t *testing.T) { meta: tt.fields.meta, } - err := c.expireCompaction(tt.args.ts) + err := c.updateCompaction(tt.args.ts) assert.Equal(t, tt.wantErr, err != nil) for _, id := range tt.expired { task := c.getCompaction(id) - assert.Equal(t, timeout, task.state) + assert.Equal(t, failed, task.state) } for _, id := range tt.unexpired { task := c.getCompaction(id) - assert.NotEqual(t, timeout, task.state) + assert.NotEqual(t, failed, task.state) } }) } @@ -484,13 +581,14 @@ func Test_newCompactionPlanHandler(t *testing.T) { &SegmentReferenceManager{segmentsLock: map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock{}}, }, &compactionPlanHandler{ - plans: map[int64]*compactionTask{}, - sessions: &SessionManager{}, - chManager: &ChannelManager{}, - meta: &meta{}, - allocator: newMockAllocator(), - flushCh: nil, - segRefer: &SegmentReferenceManager{segmentsLock: map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock{}}, + plans: map[int64]*compactionTask{}, + sessions: &SessionManager{}, + chManager: &ChannelManager{}, + meta: &meta{}, + allocator: newMockAllocator(), + flushCh: nil, + segRefer: &SegmentReferenceManager{segmentsLock: map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock{}}, + parallelCh: make(map[int64]chan struct{}), }, }, } @@ -529,7 +627,7 @@ func Test_getCompactionTasksBySignalID(t *testing.T) { }, 3: { triggerInfo: &compactionSignal{id: 1}, - state: timeout, + state: failed, }, }, }, @@ -545,7 +643,7 @@ func Test_getCompactionTasksBySignalID(t *testing.T) { }, { triggerInfo: &compactionSignal{id: 1}, - state: timeout, + state: failed, }, }, }, diff --git a/internal/datacoord/compaction_trigger_test.go b/internal/datacoord/compaction_trigger_test.go index 17e1ef9ed5..7614dd32ef 100644 --- a/internal/datacoord/compaction_trigger_test.go +++ b/internal/datacoord/compaction_trigger_test.go @@ -49,7 +49,7 @@ func (h *spyCompactionHandler) getCompaction(planID int64) *compactionTask { } // expireCompaction set the compaction state to expired -func (h *spyCompactionHandler) expireCompaction(ts Timestamp) error { +func (h *spyCompactionHandler) updateCompaction(ts Timestamp) error { panic("not implemented") // TODO: Implement } diff --git a/internal/datacoord/mock_test.go b/internal/datacoord/mock_test.go index 720b8ba58d..ed790088fc 100644 --- a/internal/datacoord/mock_test.go +++ b/internal/datacoord/mock_test.go @@ -118,9 +118,11 @@ func newTestSchema() *schemapb.CollectionSchema { } type mockDataNodeClient struct { - id int64 - state internalpb.StateCode - ch chan interface{} + id int64 + state internalpb.StateCode + ch chan interface{} + compactionStateResp *datapb.CompactionStateResponse + compactionResp *commonpb.Status } func newMockDataNodeClient(id int64, ch chan interface{}) (*mockDataNodeClient, error) { @@ -221,10 +223,21 @@ func (c *mockDataNodeClient) GetMetrics(ctx context.Context, req *milvuspb.GetMe func (c *mockDataNodeClient) Compaction(ctx context.Context, req *datapb.CompactionPlan) (*commonpb.Status, error) { if c.ch != nil { c.ch <- struct{}{} + if c.compactionResp != nil { + return c.compactionResp, nil + } + return &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil + } + if c.compactionResp != nil { + return c.compactionResp, nil } return &commonpb.Status{ErrorCode: commonpb.ErrorCode_UnexpectedError, Reason: "not implemented"}, nil } +func (c *mockDataNodeClient) GetCompactionState(ctx context.Context, req *datapb.CompactionStateRequest) (*datapb.CompactionStateResponse, error) { + return c.compactionStateResp, nil +} + func (c *mockDataNodeClient) Import(ctx context.Context, in *datapb.ImportTaskRequest) (*commonpb.Status, error) { return &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil } @@ -556,15 +569,15 @@ func (h *mockCompactionHandler) execCompactionPlan(signal *compactionSignal, pla panic("not implemented") } -// completeCompaction record the result of a compaction -func (h *mockCompactionHandler) completeCompaction(result *datapb.CompactionResult) error { - if f, ok := h.methods["completeCompaction"]; ok { - if ff, ok := f.(func(result *datapb.CompactionResult) error); ok { - return ff(result) - } - } - panic("not implemented") -} +// // completeCompaction record the result of a compaction +// func (h *mockCompactionHandler) completeCompaction(result *datapb.CompactionResult) error { +// if f, ok := h.methods["completeCompaction"]; ok { +// if ff, ok := f.(func(result *datapb.CompactionResult) error); ok { +// return ff(result) +// } +// } +// panic("not implemented") +// } // getCompaction return compaction task. If planId does not exist, return nil. func (h *mockCompactionHandler) getCompaction(planID int64) *compactionTask { @@ -577,7 +590,7 @@ func (h *mockCompactionHandler) getCompaction(planID int64) *compactionTask { } // expireCompaction set the compaction state to expired -func (h *mockCompactionHandler) expireCompaction(ts Timestamp) error { +func (h *mockCompactionHandler) updateCompaction(ts Timestamp) error { if f, ok := h.methods["expireCompaction"]; ok { if ff, ok := f.(func(ts Timestamp) error); ok { return ff(ts) diff --git a/internal/datacoord/server_test.go b/internal/datacoord/server_test.go index a4c06f2b6f..ab16a0bf29 100644 --- a/internal/datacoord/server_test.go +++ b/internal/datacoord/server_test.go @@ -2105,6 +2105,10 @@ func TestGetCompactionState(t *testing.T) { {state: executing}, {state: completed}, {state: completed}, + {state: failed, plan: &datapb.CompactionPlan{PlanID: 1}}, + {state: timeout, plan: &datapb.CompactionPlan{PlanID: 2}}, + {state: timeout}, + {state: timeout}, {state: timeout}, } }, @@ -2117,7 +2121,8 @@ func TestGetCompactionState(t *testing.T) { assert.Equal(t, commonpb.CompactionState_Executing, resp.GetState()) assert.EqualValues(t, 3, resp.GetExecutingPlanNo()) assert.EqualValues(t, 2, resp.GetCompletedPlanNo()) - assert.EqualValues(t, 1, resp.GetTimeoutPlanNo()) + assert.EqualValues(t, 1, resp.GetFailedPlanNo()) + assert.EqualValues(t, 4, resp.GetTimeoutPlanNo()) }) t.Run("with closed server", func(t *testing.T) { @@ -2131,50 +2136,6 @@ func TestGetCompactionState(t *testing.T) { }) } -func TestCompleteCompaction(t *testing.T) { - Params.DataCoordCfg.EnableCompaction = true - t.Run("test complete compaction successfully", func(t *testing.T) { - svr := &Server{} - svr.isServing = ServerStateHealthy - - svr.compactionHandler = &mockCompactionHandler{ - methods: map[string]interface{}{ - "completeCompaction": func(result *datapb.CompactionResult) error { - return nil - }, - }, - } - status, err := svr.CompleteCompaction(context.TODO(), &datapb.CompactionResult{}) - assert.Nil(t, err) - assert.Equal(t, commonpb.ErrorCode_Success, status.ErrorCode) - }) - - t.Run("test complete compaction failure", func(t *testing.T) { - svr := &Server{} - svr.isServing = ServerStateHealthy - svr.compactionHandler = &mockCompactionHandler{ - methods: map[string]interface{}{ - "completeCompaction": func(result *datapb.CompactionResult) error { - return errors.New("mock error") - }, - }, - } - status, err := svr.CompleteCompaction(context.TODO(), &datapb.CompactionResult{}) - assert.Nil(t, err) - assert.Equal(t, commonpb.ErrorCode_UnexpectedError, status.ErrorCode) - }) - - t.Run("with closed server", func(t *testing.T) { - svr := &Server{} - svr.isServing = ServerStateStopped - - resp, err := svr.CompleteCompaction(context.Background(), &datapb.CompactionResult{}) - assert.Nil(t, err) - assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode()) - assert.Equal(t, msgDataCoordIsUnhealthy(Params.DataCoordCfg.GetNodeID()), resp.GetReason()) - }) -} - func TestManualCompaction(t *testing.T) { Params.DataCoordCfg.EnableCompaction = true t.Run("test manual compaction successfully", func(t *testing.T) { diff --git a/internal/datacoord/services.go b/internal/datacoord/services.go index 3c83c26dc5..da739fde36 100644 --- a/internal/datacoord/services.go +++ b/internal/datacoord/services.go @@ -35,6 +35,7 @@ import ( "github.com/milvus-io/milvus/internal/util/retry" "github.com/milvus-io/milvus/internal/util/trace" "github.com/milvus-io/milvus/internal/util/typeutil" + "github.com/samber/lo" "go.uber.org/zap" ) @@ -816,38 +817,6 @@ func (s *Server) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest }, nil } -// CompleteCompaction completes a compaction with the result -func (s *Server) CompleteCompaction(ctx context.Context, req *datapb.CompactionResult) (*commonpb.Status, error) { - log.Info("receive complete compaction request", zap.Int64("planID", req.PlanID), zap.Int64("segmentID", req.GetSegmentID())) - - resp := &commonpb.Status{ - ErrorCode: commonpb.ErrorCode_UnexpectedError, - } - - if s.isClosed() { - log.Warn("failed to complete compaction", zap.Int64("planID", req.PlanID), - zap.Error(errDataCoordIsUnhealthy(Params.DataCoordCfg.GetNodeID()))) - - resp.Reason = msgDataCoordIsUnhealthy(Params.DataCoordCfg.GetNodeID()) - return resp, nil - } - - if !Params.DataCoordCfg.EnableCompaction { - resp.Reason = "compaction disabled" - return resp, nil - } - - if err := s.compactionHandler.completeCompaction(req); err != nil { - log.Error("failed to complete compaction", zap.Int64("planID", req.PlanID), zap.Error(err)) - resp.Reason = err.Error() - return resp, nil - } - - log.Info("success to complete compaction", zap.Int64("planID", req.PlanID)) - resp.ErrorCode = commonpb.ErrorCode_Success - return resp, nil -} - // ManualCompaction triggers a compaction for a collection func (s *Server) ManualCompaction(ctx context.Context, req *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) { log.Info("received manual compaction", zap.Int64("collectionID", req.GetCollectionID())) @@ -912,15 +881,22 @@ func (s *Server) GetCompactionState(ctx context.Context, req *milvuspb.GetCompac } tasks := s.compactionHandler.getCompactionTasksBySignalID(req.GetCompactionID()) - state, executingCnt, completedCnt, timeoutCnt := getCompactionState(tasks) + state, executingCnt, completedCnt, failedCnt, timeoutCnt := getCompactionState(tasks) resp.State = state resp.ExecutingPlanNo = int64(executingCnt) resp.CompletedPlanNo = int64(completedCnt) resp.TimeoutPlanNo = int64(timeoutCnt) + resp.FailedPlanNo = int64(failedCnt) resp.Status.ErrorCode = commonpb.ErrorCode_Success log.Info("success to get compaction state", zap.Any("state", state), zap.Int("executing", executingCnt), - zap.Int("completed", completedCnt), zap.Int("timeout", timeoutCnt)) + zap.Int("completed", completedCnt), zap.Int("failed", failedCnt), zap.Int("timeout", timeoutCnt), + zap.Int64s("plans", lo.Map(tasks, func(t *compactionTask, _ int) int64 { + if t.plan == nil { + return -1 + } + return t.plan.PlanID + }))) return resp, nil } @@ -948,11 +924,17 @@ func (s *Server) GetCompactionStateWithPlans(ctx context.Context, req *milvuspb. resp.MergeInfos = append(resp.MergeInfos, getCompactionMergeInfo(task)) } - state, _, _, _ := getCompactionState(tasks) + state, _, _, _, _ := getCompactionState(tasks) resp.Status.ErrorCode = commonpb.ErrorCode_Success resp.State = state - log.Info("success to get state with plans", zap.Any("state", state), zap.Any("merge infos", resp.MergeInfos)) + log.Info("success to get state with plans", zap.Any("state", state), zap.Any("merge infos", resp.MergeInfos), + zap.Int64s("plans", lo.Map(tasks, func(t *compactionTask, _ int) int64 { + if t.plan == nil { + return -1 + } + return t.plan.PlanID + }))) return resp, nil } @@ -974,13 +956,19 @@ func getCompactionMergeInfo(task *compactionTask) *milvuspb.CompactionMergeInfo } } -func getCompactionState(tasks []*compactionTask) (state commonpb.CompactionState, executingCnt, completedCnt, timeoutCnt int) { +func getCompactionState(tasks []*compactionTask) (state commonpb.CompactionState, executingCnt, completedCnt, failedCnt, timeoutCnt int) { + if len(tasks) == 0 { + state = commonpb.CompactionState_Executing + return + } for _, t := range tasks { switch t.state { case executing: executingCnt++ case completed: completedCnt++ + case failed: + failedCnt++ case timeout: timeoutCnt++ } diff --git a/internal/datacoord/session_manager.go b/internal/datacoord/session_manager.go index 86c53c8719..74d2031279 100644 --- a/internal/datacoord/session_manager.go +++ b/internal/datacoord/session_manager.go @@ -141,27 +141,24 @@ func (c *SessionManager) execFlush(ctx context.Context, nodeID int64, req *datap } } -// Compaction is a grpc interface. It will send request to DataNode with provided `nodeID` asynchronously. -func (c *SessionManager) Compaction(nodeID int64, plan *datapb.CompactionPlan) { - go c.execCompaction(nodeID, plan) -} - -func (c *SessionManager) execCompaction(nodeID int64, plan *datapb.CompactionPlan) { - ctx, cancel := context.WithTimeout(context.Background(), compactionTimeout) +// Compaction is a grpc interface. It will send request to DataNode with provided `nodeID` synchronously. +func (c *SessionManager) Compaction(nodeID int64, plan *datapb.CompactionPlan) error { + ctx, cancel := context.WithTimeout(context.Background(), rpcCompactionTimeout) defer cancel() cli, err := c.getClient(ctx, nodeID) if err != nil { log.Warn("failed to get client", zap.Int64("nodeID", nodeID), zap.Error(err)) - return + return err } resp, err := cli.Compaction(ctx, plan) if err := VerifyResponse(resp, err); err != nil { log.Warn("failed to execute compaction", zap.Int64("node", nodeID), zap.Error(err), zap.Int64("planID", plan.GetPlanID())) - return + return err } log.Info("success to execute compaction", zap.Int64("node", nodeID), zap.Any("planID", plan.GetPlanID())) + return nil } // Import is a grpc interface. It will send request to DataNode with provided `nodeID` asynchronously. @@ -216,6 +213,57 @@ func (c *SessionManager) execReCollectSegmentStats(ctx context.Context, nodeID i } } +func (c *SessionManager) GetCompactionState() map[int64]*datapb.CompactionStateResult { + wg := sync.WaitGroup{} + ctx := context.Background() + c.sessions.RLock() + wg.Add(len(c.sessions.data)) + c.sessions.RUnlock() + + plans := sync.Map{} + c.sessions.RLock() + for nodeID, s := range c.sessions.data { + go func(nodeID int64, s *Session) { + defer wg.Done() + cli, err := s.GetOrCreateClient(ctx) + if err != nil { + log.Info("Cannot Create Client", zap.Int64("NodeID", nodeID)) + return + } + ctx, cancel := context.WithTimeout(ctx, rpcCompactionTimeout) + defer cancel() + resp, err := cli.GetCompactionState(ctx, &datapb.CompactionStateRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_GetSystemConfigs, + SourceID: Params.DataCoordCfg.GetNodeID(), + }, + }) + if err != nil { + log.Info("Get State failed", zap.Error(err)) + return + } + + if resp.GetStatus().GetErrorCode() != commonpb.ErrorCode_Success { + log.Info("Get State failed", zap.String("Reason", resp.GetStatus().GetReason())) + return + } + for _, rst := range resp.GetResults() { + plans.Store(rst.PlanID, rst) + } + }(nodeID, s) + } + c.sessions.RUnlock() + wg.Wait() + + rst := make(map[int64]*datapb.CompactionStateResult) + plans.Range(func(key, value any) bool { + rst[key.(int64)] = value.(*datapb.CompactionStateResult) + return true + }) + + return rst +} + // AddSegment calls DataNode with ID == `nodeID` to put the segment into this node. func (c *SessionManager) AddSegment(ctx context.Context, nodeID int64, req *datapb.AddSegmentRequest) { go c.execAddSegment(ctx, nodeID, req) diff --git a/internal/datanode/compaction_executor.go b/internal/datanode/compaction_executor.go index f48608fd3f..89d821fc5a 100644 --- a/internal/datanode/compaction_executor.go +++ b/internal/datanode/compaction_executor.go @@ -29,30 +29,17 @@ const ( maxTaskNum = 1024 ) -var maxParallelCompactionNum = calculateParallel() - type compactionExecutor struct { - parallelCh chan struct{} - executing sync.Map // planID to compactor - taskCh chan compactor - dropped sync.Map // vchannel dropped -} - -// 0.5*min(8, NumCPU/2) -func calculateParallel() int { - return 2 - //cores := runtime.NumCPU() - //if cores < 16 { - //return 4 - //} - //return cores / 2 + executing sync.Map // planID to compactor + completed sync.Map // planID to CompactionResult + taskCh chan compactor + dropped sync.Map // vchannel dropped } func newCompactionExecutor() *compactionExecutor { return &compactionExecutor{ - parallelCh: make(chan struct{}, maxParallelCompactionNum), - executing: sync.Map{}, - taskCh: make(chan compactor, maxTaskNum), + executing: sync.Map{}, + taskCh: make(chan compactor, maxTaskNum), } } @@ -88,20 +75,20 @@ func (c *compactionExecutor) start(ctx context.Context) { } func (c *compactionExecutor) executeTask(task compactor) { - c.parallelCh <- struct{}{} defer func() { c.toCompleteState(task) - <-c.parallelCh }() log.Info("start to execute compaction", zap.Int64("planID", task.getPlanID())) - err := task.compact() + result, err := task.compact() if err != nil { log.Warn("compaction task failed", zap.Int64("planID", task.getPlanID()), zap.Error(err), ) + } else { + c.completed.Store(task.getPlanID(), result) } log.Info("end to execute compaction", zap.Int64("planID", task.getPlanID())) diff --git a/internal/datanode/compaction_executor_test.go b/internal/datanode/compaction_executor_test.go index 1782c5e836..668919d720 100644 --- a/internal/datanode/compaction_executor_test.go +++ b/internal/datanode/compaction_executor_test.go @@ -21,6 +21,7 @@ import ( "sync" "testing" + "github.com/milvus-io/milvus/internal/proto/datapb" "github.com/stretchr/testify/assert" ) @@ -142,15 +143,15 @@ func (mc *mockCompactor) complete() { mc.wg.Done() } -func (mc *mockCompactor) compact() error { +func (mc *mockCompactor) compact() (*datapb.CompactionResult, error) { if !mc.isvalid { - return errStart + return nil, errStart } if mc.alwaysWorking { <-mc.ctx.Done() - return mc.ctx.Err() + return nil, mc.ctx.Err() } - return nil + return nil, nil } func (mc *mockCompactor) getPlanID() UniqueID { diff --git a/internal/datanode/compactor.go b/internal/datanode/compactor.go index d54b8de65c..f5d1a0c439 100644 --- a/internal/datanode/compactor.go +++ b/internal/datanode/compactor.go @@ -27,12 +27,10 @@ import ( "github.com/milvus-io/milvus/internal/log" "github.com/milvus-io/milvus/internal/metrics" - "github.com/milvus-io/milvus/internal/proto/commonpb" "github.com/milvus-io/milvus/internal/proto/datapb" "github.com/milvus-io/milvus/internal/proto/etcdpb" "github.com/milvus-io/milvus/internal/proto/schemapb" "github.com/milvus-io/milvus/internal/storage" - "github.com/milvus-io/milvus/internal/types" "github.com/milvus-io/milvus/internal/util/funcutil" "github.com/milvus-io/milvus/internal/util/timerecord" "github.com/milvus-io/milvus/internal/util/tsoutil" @@ -55,7 +53,7 @@ type iterator = storage.Iterator type compactor interface { start() complete() - compact() error + compact() (*datapb.CompactionResult, error) stop() getPlanID() UniqueID getCollection() UniqueID @@ -73,7 +71,6 @@ type compactionTask struct { flushManager allocatorInterface - dc types.DataCoord plan *datapb.CompactionPlan ctx context.Context @@ -93,7 +90,6 @@ func newCompactionTask( replica Replica, fm flushManager, alloc allocatorInterface, - dc types.DataCoord, plan *datapb.CompactionPlan) *compactionTask { ctx1, cancel := context.WithCancel(ctx) @@ -106,7 +102,6 @@ func newCompactionTask( Replica: replica, flushManager: fm, allocatorInterface: alloc, - dc: dc, plan: plan, tr: timerecord.NewTimeRecorder("compactionTask"), } @@ -312,11 +307,11 @@ func (t *compactionTask) merge(mergeItr iterator, delta map[interface{}]Timestam return iDatas, numRows, nil } -func (t *compactionTask) compact() error { +func (t *compactionTask) compact() (*datapb.CompactionResult, error) { compactStart := time.Now() if ok := funcutil.CheckCtxValid(t.ctx); !ok { log.Error("compact wrong, task context done or timeout") - return errContext + return nil, errContext } ctxTimeout, cancelAll := context.WithTimeout(t.ctx, time.Duration(t.plan.GetTimeoutInSeconds())*time.Second) @@ -328,17 +323,17 @@ func (t *compactionTask) compact() error { case t.plan.GetType() == datapb.CompactionType_UndefinedCompaction: log.Error("compact wrong, compaction type undefined") - return errCompactionTypeUndifined + return nil, errCompactionTypeUndifined case len(t.plan.GetSegmentBinlogs()) < 1: log.Error("compact wrong, there's no segments in segment binlogs") - return errIllegalCompactionPlan + return nil, errIllegalCompactionPlan case t.plan.GetType() == datapb.CompactionType_MergeCompaction || t.plan.GetType() == datapb.CompactionType_MixCompaction: targetSegID, err = t.allocID() if err != nil { log.Error("compact wrong", zap.Error(err)) - return err + return nil, err } case t.plan.GetType() == datapb.CompactionType_InnerCompaction: @@ -354,7 +349,7 @@ func (t *compactionTask) compact() error { collID, partID, meta, err := t.getSegmentMeta(segIDs[0]) if err != nil { log.Error("compact wrong", zap.Int64("planID", t.plan.GetPlanID()), zap.Error(err)) - return err + return nil, err } // Inject to stop flush @@ -407,7 +402,7 @@ func (t *compactionTask) compact() error { // Unable to deal with all empty segments cases, so return error if binlogNum == 0 { log.Error("compact wrong, all segments' binlogs are empty", zap.Int64("planID", t.plan.GetPlanID())) - return errIllegalCompactionPlan + return nil, errIllegalCompactionPlan } for idx := 0; idx < binlogNum; idx++ { @@ -466,27 +461,27 @@ func (t *compactionTask) compact() error { if err != nil { log.Error("compaction IO wrong", zap.Int64("planID", t.plan.GetPlanID()), zap.Error(err)) - return err + return nil, err } mergeItr := storage.NewMergeIterator(iItr) deltaPk2Ts, deltaBuf, err := t.mergeDeltalogs(dblobs, t.plan.GetTimetravel()) if err != nil { - return err + return nil, err } iDatas, numRows, err := t.merge(mergeItr, deltaPk2Ts, meta.GetSchema(), t.GetCurrentTime()) if err != nil { log.Error("compact wrong", zap.Int64("planID", t.plan.GetPlanID()), zap.Error(err)) - return err + return nil, err } uploadStart := time.Now() segPaths, err := t.upload(ctxTimeout, targetSegID, partID, iDatas, deltaBuf.delData, meta) if err != nil { log.Error("compact wrong", zap.Int64("planID", t.plan.GetPlanID()), zap.Error(err)) - return err + return nil, err } uploadEnd := time.Now() @@ -512,21 +507,21 @@ func (t *compactionTask) compact() error { NumOfRows: numRows, } - rpcStart := time.Now() - status, err := t.dc.CompleteCompaction(ctxTimeout, pack) - if err != nil { - log.Error("complete compaction rpc wrong", zap.Int64("planID", t.plan.GetPlanID()), zap.Error(err)) - return err - } - if status.ErrorCode != commonpb.ErrorCode_Success { - log.Error("complete compaction wrong", zap.Int64("planID", t.plan.GetPlanID()), zap.String("reason", status.GetReason())) - return fmt.Errorf("complete comapction wrong: %s", status.GetReason()) - } - rpcEnd := time.Now() - defer func() { - log.Debug("rpc elapse in ms", zap.Int64("planID", t.plan.GetPlanID()), zap.Float64("elapse", nano2Milli(rpcEnd.Sub(rpcStart)))) - }() - + // rpcStart := time.Now() + // status, err := t.dc.CompleteCompaction(ctxTimeout, pack) + // if err != nil { + // log.Error("complete compaction rpc wrong", zap.Int64("planID", t.plan.GetPlanID()), zap.Error(err)) + // return err + // } + // if status.ErrorCode != commonpb.ErrorCode_Success { + // log.Error("complete compaction wrong", zap.Int64("planID", t.plan.GetPlanID()), zap.String("reason", status.GetReason())) + // return fmt.Errorf("complete comapction wrong: %s", status.GetReason()) + // } + // rpcEnd := time.Now() + // defer func() { + // log.Debug("rpc elapse in ms", zap.Int64("planID", t.plan.GetPlanID()), zap.Float64("elapse", nano2Milli(rpcEnd.Sub(rpcStart)))) + // }() + // // Compaction I: update pk range. // Compaction II: remove the segments and add a new flushed segment with pk range. if t.hasSegment(targetSegID, true) { @@ -540,7 +535,7 @@ func (t *compactionTask) compact() error { err = t.mergeFlushedSegments(targetSegID, collID, partID, t.plan.GetPlanID(), segIDs, t.plan.GetChannel(), numRows) if err != nil { log.Error("compact wrong", zap.Int64("planID", t.plan.GetPlanID()), zap.Error(err)) - return err + return nil, err } } @@ -562,7 +557,7 @@ func (t *compactionTask) compact() error { log.Info("overall elapse in ms", zap.Int64("planID", t.plan.GetPlanID()), zap.Float64("elapse", nano2Milli(time.Since(compactStart)))) metrics.DataNodeCompactionLatency.WithLabelValues(fmt.Sprint(Params.DataNodeCfg.GetNodeID())).Observe(float64(t.tr.ElapseSpan().Milliseconds())) - return nil + return pack, nil } // TODO copy maybe expensive, but this seems to be the only convinent way. diff --git a/internal/datanode/compactor_test.go b/internal/datanode/compactor_test.go index fc4e3f41d9..69d9092b24 100644 --- a/internal/datanode/compactor_test.go +++ b/internal/datanode/compactor_test.go @@ -436,18 +436,18 @@ func TestCompactorInterfaceMethods(t *testing.T) { } emptyTask.plan = plan - err := emptyTask.compact() + _, err := emptyTask.compact() assert.Error(t, err) plan.Type = datapb.CompactionType_InnerCompaction plan.SegmentBinlogs = emptySegmentBinlogs - err = emptyTask.compact() + _, err = emptyTask.compact() assert.Error(t, err) plan.Type = datapb.CompactionType_MergeCompaction emptyTask.allocatorInterface = invalidAlloc plan.SegmentBinlogs = notEmptySegmentBinlogs - err = emptyTask.compact() + _, err = emptyTask.compact() assert.Error(t, err) emptyTask.stop() @@ -490,7 +490,6 @@ func TestCompactorInterfaceMethods(t *testing.T) { rc := &RootCoordFactory{ pkType: c.pkType, } - dc := &DataCoordFactory{} mockfm := &mockFlushManager{} mockbIO := &binlogIO{cm, alloc} replica, err := newReplica(context.TODO(), rc, cm, c.colID) @@ -527,12 +526,12 @@ func TestCompactorInterfaceMethods(t *testing.T) { ctx, cancel := context.WithCancel(context.TODO()) cancel() - canceledTask := newCompactionTask(ctx, mockbIO, mockbIO, replica, mockfm, alloc, dc, plan) - err = canceledTask.compact() + canceledTask := newCompactionTask(ctx, mockbIO, mockbIO, replica, mockfm, alloc, plan) + _, err = canceledTask.compact() assert.Error(t, err) - task := newCompactionTask(context.TODO(), mockbIO, mockbIO, replica, mockfm, alloc, dc, plan) - err = task.compact() + task := newCompactionTask(context.TODO(), mockbIO, mockbIO, replica, mockfm, alloc, plan) + _, err = task.compact() assert.NoError(t, err) updates, err := replica.getSegmentStatisticsUpdates(c.segID) @@ -558,7 +557,7 @@ func TestCompactorInterfaceMethods(t *testing.T) { require.NoError(t, err) plan.PlanID++ - err = task.compact() + _, err = task.compact() assert.NoError(t, err) // The segment should be removed assert.False(t, replica.hasSegment(c.segID, true)) @@ -578,7 +577,7 @@ func TestCompactorInterfaceMethods(t *testing.T) { }, } plan.SegmentBinlogs = segmentBinlogsWithEmptySegment - err = task.compact() + _, err = task.compact() assert.Error(t, err) plan.SegmentBinlogs = segBinlogs @@ -591,7 +590,7 @@ func TestCompactorInterfaceMethods(t *testing.T) { plan.PlanID++ plan.Timetravel = Timestamp(10000) - err = task.compact() + _, err = task.compact() assert.NoError(t, err) updates, err = replica.getSegmentStatisticsUpdates(c.segID) @@ -607,7 +606,7 @@ func TestCompactorInterfaceMethods(t *testing.T) { plan.PlanID++ mockfm.sleepSeconds = plan.TimeoutInSeconds + int32(1) - err = task.compact() + _, err = task.compact() assert.Error(t, err) } }) @@ -654,7 +653,6 @@ func TestCompactorInterfaceMethods(t *testing.T) { rc := &RootCoordFactory{ pkType: c.pkType, } - dc := &DataCoordFactory{} mockfm := &mockFlushManager{} mockKv := memkv.NewMemoryKV() mockbIO := &binlogIO{cm, alloc} @@ -712,8 +710,8 @@ func TestCompactorInterfaceMethods(t *testing.T) { } alloc.random = false // generated ID = 19530 - task := newCompactionTask(context.TODO(), mockbIO, mockbIO, replica, mockfm, alloc, dc, plan) - err = task.compact() + task := newCompactionTask(context.TODO(), mockbIO, mockbIO, replica, mockfm, alloc, plan) + _, err = task.compact() assert.NoError(t, err) assert.False(t, replica.hasSegment(c.segID1, true)) @@ -737,7 +735,7 @@ func TestCompactorInterfaceMethods(t *testing.T) { require.True(t, replica.hasSegment(c.segID2, true)) require.False(t, replica.hasSegment(19530, true)) - err = task.compact() + _, err = task.compact() assert.NoError(t, err) assert.False(t, replica.hasSegment(c.segID1, true)) @@ -761,7 +759,7 @@ func TestCompactorInterfaceMethods(t *testing.T) { require.True(t, replica.hasSegment(c.segID2, true)) require.False(t, replica.hasSegment(19530, true)) - err = task.compact() + _, err = task.compact() assert.NoError(t, err) assert.False(t, replica.hasSegment(c.segID1, true)) @@ -783,7 +781,6 @@ func TestCompactorInterfaceMethods(t *testing.T) { rc := &RootCoordFactory{ pkType: schemapb.DataType_Int64, } - dc := &DataCoordFactory{} mockfm := &mockFlushManager{} mockbIO := &binlogIO{cm, alloc} replica, err := newReplica(context.TODO(), rc, cm, collID) @@ -845,8 +842,8 @@ func TestCompactorInterfaceMethods(t *testing.T) { } alloc.random = false // generated ID = 19530 - task := newCompactionTask(context.TODO(), mockbIO, mockbIO, replica, mockfm, alloc, dc, plan) - err = task.compact() + task := newCompactionTask(context.TODO(), mockbIO, mockbIO, replica, mockfm, alloc, plan) + _, err = task.compact() assert.NoError(t, err) assert.False(t, replica.hasSegment(segID1, true)) diff --git a/internal/datanode/data_node.go b/internal/datanode/data_node.go index 0f1486f963..caee2dddc0 100644 --- a/internal/datanode/data_node.go +++ b/internal/datanode/data_node.go @@ -809,7 +809,6 @@ func (node *DataNode) Compaction(ctx context.Context, req *datapb.CompactionPlan ds.replica, ds.flushManager, ds.idAllocator, - node.dataCoord, req, ) @@ -820,6 +819,42 @@ func (node *DataNode) Compaction(ctx context.Context, req *datapb.CompactionPlan }, nil } +// GetCompactionState called by DataCoord +// return status of all compaction plans +func (node *DataNode) GetCompactionState(ctx context.Context, req *datapb.CompactionStateRequest) (*datapb.CompactionStateResponse, error) { + log.Info("DataNode.GetCompactionState") + if !node.isHealthy() { + return &datapb.CompactionStateResponse{ + Status: &commonpb.Status{ + ErrorCode: commonpb.ErrorCode_UnexpectedError, + Reason: "DataNode is unhealthy", + }, + }, nil + } + results := make([]*datapb.CompactionStateResult, 0) + node.compactionExecutor.executing.Range(func(k, v any) bool { + results = append(results, &datapb.CompactionStateResult{ + State: commonpb.CompactionState_Executing, + PlanID: k.(UniqueID), + }) + return true + }) + node.compactionExecutor.completed.Range(func(k, v any) bool { + results = append(results, &datapb.CompactionStateResult{ + State: commonpb.CompactionState_Completed, + PlanID: k.(UniqueID), + Result: v.(*datapb.CompactionResult), + }) + node.compactionExecutor.completed.Delete(k) + return true + }) + log.Debug("Compaction results", zap.Any("results", results)) + return &datapb.CompactionStateResponse{ + Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, + Results: results, + }, nil +} + // Import data files(json, numpy, etc.) on MinIO/S3 storage, read and parse them into sealed segments func (node *DataNode) Import(ctx context.Context, req *datapb.ImportTaskRequest) (*commonpb.Status, error) { log.Info("DataNode receive import request", diff --git a/internal/datanode/data_node_test.go b/internal/datanode/data_node_test.go index 778e81dfd5..f20e88ee73 100644 --- a/internal/datanode/data_node_test.go +++ b/internal/datanode/data_node_test.go @@ -149,6 +149,41 @@ func TestDataNode(t *testing.T) { assert.Equal(t, commonpb.ErrorCode_Success, stat.Status.ErrorCode) }) + t.Run("Test GetCompactionState", func(t *testing.T) { + node.compactionExecutor.executing.Store(int64(3), 0) + node.compactionExecutor.executing.Store(int64(2), 0) + node.compactionExecutor.completed.Store(int64(1), &datapb.CompactionResult{ + PlanID: 1, + SegmentID: 10, + }) + stat, err := node.GetCompactionState(node.ctx, nil) + assert.NoError(t, err) + + assert.Equal(t, 3, len(stat.GetResults())) + + cnt := 0 + for _, v := range stat.GetResults() { + if v.GetState() == commonpb.CompactionState_Completed { + cnt++ + } + } + assert.Equal(t, 1, cnt) + + cnt = 0 + node.compactionExecutor.completed.Range(func(k, v any) bool { + cnt++ + return true + }) + assert.Equal(t, 0, cnt) + }) + + t.Run("Test GetCompactionState unhealthy", func(t *testing.T) { + node.UpdateStateCode(internalpb.StateCode_Abnormal) + resp, _ := node.GetCompactionState(ctx, nil) + assert.Equal(t, "DataNode is unhealthy", resp.GetStatus().GetReason()) + node.UpdateStateCode(internalpb.StateCode_Healthy) + }) + t.Run("Test FlushSegments", func(t *testing.T) { dmChannelName := "fake-by-dev-rootcoord-dml-channel-test-FlushSegments" diff --git a/internal/distributed/datacoord/client/client.go b/internal/distributed/datacoord/client/client.go index 1324961ab7..76666ceb4d 100644 --- a/internal/distributed/datacoord/client/client.go +++ b/internal/distributed/datacoord/client/client.go @@ -25,6 +25,7 @@ import ( "github.com/milvus-io/milvus/internal/proto/datapb" "github.com/milvus-io/milvus/internal/proto/internalpb" "github.com/milvus-io/milvus/internal/proto/milvuspb" + "github.com/milvus-io/milvus/internal/types" "github.com/milvus-io/milvus/internal/util/funcutil" "github.com/milvus-io/milvus/internal/util/grpcclient" "github.com/milvus-io/milvus/internal/util/paramtable" @@ -38,6 +39,8 @@ import ( // ClientParams is the parameters of client singleton var ClientParams paramtable.GrpcClientConfig +var _ types.DataCoord = (*Client)(nil) + // Client is the datacoord grpc client type Client struct { grpcClient grpcclient.GrpcClient @@ -412,20 +415,6 @@ func (c *Client) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest return ret.(*milvuspb.GetMetricsResponse), err } -// CompleteCompaction completes a compaction with the result -func (c *Client) CompleteCompaction(ctx context.Context, req *datapb.CompactionResult) (*commonpb.Status, error) { - ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) { - if !funcutil.CheckCtxValid(ctx) { - return nil, ctx.Err() - } - return client.(datapb.DataCoordClient).CompleteCompaction(ctx, req) - }) - if err != nil || ret == nil { - return nil, err - } - return ret.(*commonpb.Status), err -} - // ManualCompaction triggers a compaction for a collection func (c *Client) ManualCompaction(ctx context.Context, req *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) { ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) { diff --git a/internal/distributed/datacoord/client/client_test.go b/internal/distributed/datacoord/client/client_test.go index 4200610140..164b9a824d 100644 --- a/internal/distributed/datacoord/client/client_test.go +++ b/internal/distributed/datacoord/client/client_test.go @@ -103,9 +103,6 @@ func Test_NewClient(t *testing.T) { r15, err := client.GetMetrics(ctx, nil) retCheck(retNotNil, r15, err) - r16, err := client.CompleteCompaction(ctx, nil) - retCheck(retNotNil, r16, err) - r17, err := client.GetCompactionState(ctx, nil) retCheck(retNotNil, r17, err) diff --git a/internal/distributed/datacoord/service.go b/internal/distributed/datacoord/service.go index bb5c762b9f..274e083633 100644 --- a/internal/distributed/datacoord/service.go +++ b/internal/distributed/datacoord/service.go @@ -301,11 +301,6 @@ func (s *Server) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest return s.dataCoord.GetMetrics(ctx, req) } -// CompleteCompaction completes a compaction with the result -func (s *Server) CompleteCompaction(ctx context.Context, req *datapb.CompactionResult) (*commonpb.Status, error) { - return s.dataCoord.CompleteCompaction(ctx, req) -} - // ManualCompaction triggers a compaction for a collection func (s *Server) ManualCompaction(ctx context.Context, req *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) { return s.dataCoord.ManualCompaction(ctx, req) diff --git a/internal/distributed/datacoord/service_test.go b/internal/distributed/datacoord/service_test.go index 23f43f3973..44a22f9ebb 100644 --- a/internal/distributed/datacoord/service_test.go +++ b/internal/distributed/datacoord/service_test.go @@ -382,15 +382,6 @@ func Test_NewServer(t *testing.T) { assert.NotNil(t, resp) }) - t.Run("CompleteCompaction", func(t *testing.T) { - server.dataCoord = &MockDataCoord{ - status: &commonpb.Status{}, - } - resp, err := server.CompleteCompaction(ctx, nil) - assert.Nil(t, err) - assert.NotNil(t, resp) - }) - t.Run("ManualCompaction", func(t *testing.T) { server.dataCoord = &MockDataCoord{ manualCompactionResp: &milvuspb.ManualCompactionResponse{}, diff --git a/internal/distributed/datanode/client/client.go b/internal/distributed/datanode/client/client.go index 6b71c4bb2b..c7928bb183 100644 --- a/internal/distributed/datanode/client/client.go +++ b/internal/distributed/datanode/client/client.go @@ -205,6 +205,19 @@ func (c *Client) Compaction(ctx context.Context, req *datapb.CompactionPlan) (*c return ret.(*commonpb.Status), err } +func (c *Client) GetCompactionState(ctx context.Context, req *datapb.CompactionStateRequest) (*datapb.CompactionStateResponse, error) { + ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) { + if !funcutil.CheckCtxValid(ctx) { + return nil, ctx.Err() + } + return client.(datapb.DataNodeClient).GetCompactionState(ctx, req) + }) + if err != nil || ret == nil { + return nil, err + } + return ret.(*datapb.CompactionStateResponse), err +} + // Import data files(json, numpy, etc.) on MinIO/S3 storage, read and parse them into sealed segments func (c *Client) Import(ctx context.Context, req *datapb.ImportTaskRequest) (*commonpb.Status, error) { ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) { diff --git a/internal/distributed/datanode/client/client_test.go b/internal/distributed/datanode/client/client_test.go index eff0dd03dd..850509c3e9 100644 --- a/internal/distributed/datanode/client/client_test.go +++ b/internal/distributed/datanode/client/client_test.go @@ -88,6 +88,9 @@ func Test_NewClient(t *testing.T) { r10, err := client.ShowConfigurations(ctx, nil) retCheck(retNotNil, r10, err) + + r11, err := client.GetCompactionState(ctx, nil) + retCheck(retNotNil, r11, err) } client.grpcClient = &mock.GRPCClientBase{ diff --git a/internal/distributed/datanode/service.go b/internal/distributed/datanode/service.go index 74ad31b998..b6cc3befa7 100644 --- a/internal/distributed/datanode/service.go +++ b/internal/distributed/datanode/service.go @@ -365,6 +365,11 @@ func (s *Server) Compaction(ctx context.Context, request *datapb.CompactionPlan) return s.datanode.Compaction(ctx, request) } +// GetCompactionState gets the Compaction tasks state of DataNode +func (s *Server) GetCompactionState(ctx context.Context, request *datapb.CompactionStateRequest) (*datapb.CompactionStateResponse, error) { + return s.datanode.GetCompactionState(ctx, request) +} + func (s *Server) Import(ctx context.Context, request *datapb.ImportTaskRequest) (*commonpb.Status, error) { return s.datanode.Import(ctx, request) } diff --git a/internal/distributed/datanode/service_test.go b/internal/distributed/datanode/service_test.go index 6cb802a3a9..4a7471bfca 100644 --- a/internal/distributed/datanode/service_test.go +++ b/internal/distributed/datanode/service_test.go @@ -36,18 +36,19 @@ import ( type MockDataNode struct { nodeID typeutil.UniqueID - stateCode internalpb.StateCode - states *internalpb.ComponentStates - status *commonpb.Status - err error - initErr error - startErr error - stopErr error - regErr error - strResp *milvuspb.StringResponse - configResp *internalpb.ShowConfigurationsResponse - metricResp *milvuspb.GetMetricsResponse - resendResp *datapb.ResendSegmentStatsResponse + stateCode internalpb.StateCode + states *internalpb.ComponentStates + status *commonpb.Status + err error + initErr error + startErr error + stopErr error + regErr error + strResp *milvuspb.StringResponse + configResp *internalpb.ShowConfigurationsResponse + metricResp *milvuspb.GetMetricsResponse + resendResp *datapb.ResendSegmentStatsResponse + compactionResp *datapb.CompactionStateResponse } func (m *MockDataNode) Init() error { @@ -114,6 +115,10 @@ func (m *MockDataNode) Compaction(ctx context.Context, req *datapb.CompactionPla return m.status, m.err } +func (m *MockDataNode) GetCompactionState(ctx context.Context, req *datapb.CompactionStateRequest) (*datapb.CompactionStateResponse, error) { + return m.compactionResp, m.err +} + func (m *MockDataNode) SetEtcdClient(client *clientv3.Client) { } diff --git a/internal/proto/common.proto b/internal/proto/common.proto index dc85462832..ee0a3eade8 100644 --- a/internal/proto/common.proto +++ b/internal/proto/common.proto @@ -317,4 +317,4 @@ message PrivilegeExt { extend google.protobuf.MessageOptions { PrivilegeExt privilege_ext_obj = 1001; -} \ No newline at end of file +} diff --git a/internal/proto/data_coord.proto b/internal/proto/data_coord.proto index a5a361d503..9c20047269 100644 --- a/internal/proto/data_coord.proto +++ b/internal/proto/data_coord.proto @@ -37,7 +37,6 @@ service DataCoord { rpc ShowConfigurations(internal.ShowConfigurationsRequest) returns (internal.ShowConfigurationsResponse){} // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy rpc GetMetrics(milvus.GetMetricsRequest) returns (milvus.GetMetricsResponse) {} - rpc CompleteCompaction(CompactionResult) returns (common.Status) {} rpc ManualCompaction(milvus.ManualCompactionRequest) returns (milvus.ManualCompactionResponse) {} rpc GetCompactionState(milvus.GetCompactionStateRequest) returns (milvus.GetCompactionStateResponse) {} rpc GetCompactionStateWithPlans(milvus.GetCompactionPlansRequest) returns (milvus.GetCompactionPlansResponse) {} @@ -59,7 +58,7 @@ service DataCoord { service DataNode { rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {} - rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){} + rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns (milvus.StringResponse) {} rpc WatchDmChannels(WatchDmChannelsRequest) returns (common.Status) {} rpc FlushSegments(FlushSegmentsRequest) returns(common.Status) {} @@ -67,7 +66,9 @@ service DataNode { rpc ShowConfigurations(internal.ShowConfigurationsRequest) returns (internal.ShowConfigurationsResponse){} // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy rpc GetMetrics(milvus.GetMetricsRequest) returns (milvus.GetMetricsResponse) {} + rpc Compaction(CompactionPlan) returns (common.Status) {} + rpc GetCompactionState(CompactionStateRequest) returns (CompactionStateResponse) {} // https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load rpc Import(ImportTaskRequest) returns(common.Status) {} @@ -393,6 +394,10 @@ enum CompactionType { MixCompaction = 3; } +message CompactionStateRequest { + common.MsgBase base = 1; +} + message CompactionSegmentBinlogs { int64 segmentID = 1; repeated FieldBinlog fieldBinlogs = 2; @@ -420,6 +425,17 @@ message CompactionResult { repeated FieldBinlog deltalogs = 6; } +message CompactionStateResult { + int64 planID = 1; + common.CompactionState state = 2; + CompactionResult result = 3; +} + +message CompactionStateResponse { + common.Status status = 1; + repeated CompactionStateResult results = 2; +} + // Deprecated message SegmentFieldBinlogMeta { int64 fieldID = 1; diff --git a/internal/proto/datapb/data_coord.pb.go b/internal/proto/datapb/data_coord.pb.go index 7ea8f657ac..0fdc5ec39a 100644 --- a/internal/proto/datapb/data_coord.pb.go +++ b/internal/proto/datapb/data_coord.pb.go @@ -2791,6 +2791,45 @@ func (m *ChannelWatchInfo) GetTimeoutTs() int64 { return 0 } +type CompactionStateRequest struct { + Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CompactionStateRequest) Reset() { *m = CompactionStateRequest{} } +func (m *CompactionStateRequest) String() string { return proto.CompactTextString(m) } +func (*CompactionStateRequest) ProtoMessage() {} +func (*CompactionStateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{44} +} + +func (m *CompactionStateRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CompactionStateRequest.Unmarshal(m, b) +} +func (m *CompactionStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CompactionStateRequest.Marshal(b, m, deterministic) +} +func (m *CompactionStateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CompactionStateRequest.Merge(m, src) +} +func (m *CompactionStateRequest) XXX_Size() int { + return xxx_messageInfo_CompactionStateRequest.Size(m) +} +func (m *CompactionStateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CompactionStateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_CompactionStateRequest proto.InternalMessageInfo + +func (m *CompactionStateRequest) GetBase() *commonpb.MsgBase { + if m != nil { + return m.Base + } + return nil +} + type CompactionSegmentBinlogs struct { SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"` FieldBinlogs []*FieldBinlog `protobuf:"bytes,2,rep,name=fieldBinlogs,proto3" json:"fieldBinlogs,omitempty"` @@ -2806,7 +2845,7 @@ func (m *CompactionSegmentBinlogs) Reset() { *m = CompactionSegmentBinlo func (m *CompactionSegmentBinlogs) String() string { return proto.CompactTextString(m) } func (*CompactionSegmentBinlogs) ProtoMessage() {} func (*CompactionSegmentBinlogs) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{44} + return fileDescriptor_82cd95f524594f49, []int{45} } func (m *CompactionSegmentBinlogs) XXX_Unmarshal(b []byte) error { @@ -2879,7 +2918,7 @@ func (m *CompactionPlan) Reset() { *m = CompactionPlan{} } func (m *CompactionPlan) String() string { return proto.CompactTextString(m) } func (*CompactionPlan) ProtoMessage() {} func (*CompactionPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{45} + return fileDescriptor_82cd95f524594f49, []int{46} } func (m *CompactionPlan) XXX_Unmarshal(b []byte) error { @@ -2965,7 +3004,7 @@ func (m *CompactionResult) Reset() { *m = CompactionResult{} } func (m *CompactionResult) String() string { return proto.CompactTextString(m) } func (*CompactionResult) ProtoMessage() {} func (*CompactionResult) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{46} + return fileDescriptor_82cd95f524594f49, []int{47} } func (m *CompactionResult) XXX_Unmarshal(b []byte) error { @@ -3028,6 +3067,108 @@ func (m *CompactionResult) GetDeltalogs() []*FieldBinlog { return nil } +type CompactionStateResult struct { + PlanID int64 `protobuf:"varint,1,opt,name=planID,proto3" json:"planID,omitempty"` + State commonpb.CompactionState `protobuf:"varint,2,opt,name=state,proto3,enum=milvus.proto.common.CompactionState" json:"state,omitempty"` + Result *CompactionResult `protobuf:"bytes,3,opt,name=result,proto3" json:"result,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CompactionStateResult) Reset() { *m = CompactionStateResult{} } +func (m *CompactionStateResult) String() string { return proto.CompactTextString(m) } +func (*CompactionStateResult) ProtoMessage() {} +func (*CompactionStateResult) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{48} +} + +func (m *CompactionStateResult) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CompactionStateResult.Unmarshal(m, b) +} +func (m *CompactionStateResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CompactionStateResult.Marshal(b, m, deterministic) +} +func (m *CompactionStateResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_CompactionStateResult.Merge(m, src) +} +func (m *CompactionStateResult) XXX_Size() int { + return xxx_messageInfo_CompactionStateResult.Size(m) +} +func (m *CompactionStateResult) XXX_DiscardUnknown() { + xxx_messageInfo_CompactionStateResult.DiscardUnknown(m) +} + +var xxx_messageInfo_CompactionStateResult proto.InternalMessageInfo + +func (m *CompactionStateResult) GetPlanID() int64 { + if m != nil { + return m.PlanID + } + return 0 +} + +func (m *CompactionStateResult) GetState() commonpb.CompactionState { + if m != nil { + return m.State + } + return commonpb.CompactionState_UndefiedState +} + +func (m *CompactionStateResult) GetResult() *CompactionResult { + if m != nil { + return m.Result + } + return nil +} + +type CompactionStateResponse struct { + Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + Results []*CompactionStateResult `protobuf:"bytes,2,rep,name=results,proto3" json:"results,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CompactionStateResponse) Reset() { *m = CompactionStateResponse{} } +func (m *CompactionStateResponse) String() string { return proto.CompactTextString(m) } +func (*CompactionStateResponse) ProtoMessage() {} +func (*CompactionStateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{49} +} + +func (m *CompactionStateResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CompactionStateResponse.Unmarshal(m, b) +} +func (m *CompactionStateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CompactionStateResponse.Marshal(b, m, deterministic) +} +func (m *CompactionStateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CompactionStateResponse.Merge(m, src) +} +func (m *CompactionStateResponse) XXX_Size() int { + return xxx_messageInfo_CompactionStateResponse.Size(m) +} +func (m *CompactionStateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CompactionStateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_CompactionStateResponse proto.InternalMessageInfo + +func (m *CompactionStateResponse) GetStatus() *commonpb.Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *CompactionStateResponse) GetResults() []*CompactionStateResult { + if m != nil { + return m.Results + } + return nil +} + // Deprecated type SegmentFieldBinlogMeta struct { FieldID int64 `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"` @@ -3041,7 +3182,7 @@ 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{47} + return fileDescriptor_82cd95f524594f49, []int{50} } func (m *SegmentFieldBinlogMeta) XXX_Unmarshal(b []byte) error { @@ -3089,7 +3230,7 @@ func (m *WatchChannelsRequest) Reset() { *m = WatchChannelsRequest{} } func (m *WatchChannelsRequest) String() string { return proto.CompactTextString(m) } func (*WatchChannelsRequest) ProtoMessage() {} func (*WatchChannelsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{48} + return fileDescriptor_82cd95f524594f49, []int{51} } func (m *WatchChannelsRequest) XXX_Unmarshal(b []byte) error { @@ -3142,7 +3283,7 @@ func (m *WatchChannelsResponse) Reset() { *m = WatchChannelsResponse{} } func (m *WatchChannelsResponse) String() string { return proto.CompactTextString(m) } func (*WatchChannelsResponse) ProtoMessage() {} func (*WatchChannelsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{49} + return fileDescriptor_82cd95f524594f49, []int{52} } func (m *WatchChannelsResponse) XXX_Unmarshal(b []byte) error { @@ -3183,7 +3324,7 @@ func (m *SetSegmentStateRequest) Reset() { *m = SetSegmentStateRequest{} func (m *SetSegmentStateRequest) String() string { return proto.CompactTextString(m) } func (*SetSegmentStateRequest) ProtoMessage() {} func (*SetSegmentStateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{50} + return fileDescriptor_82cd95f524594f49, []int{53} } func (m *SetSegmentStateRequest) XXX_Unmarshal(b []byte) error { @@ -3236,7 +3377,7 @@ func (m *SetSegmentStateResponse) Reset() { *m = SetSegmentStateResponse func (m *SetSegmentStateResponse) String() string { return proto.CompactTextString(m) } func (*SetSegmentStateResponse) ProtoMessage() {} func (*SetSegmentStateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{51} + return fileDescriptor_82cd95f524594f49, []int{54} } func (m *SetSegmentStateResponse) XXX_Unmarshal(b []byte) error { @@ -3277,7 +3418,7 @@ func (m *DropVirtualChannelRequest) Reset() { *m = DropVirtualChannelReq func (m *DropVirtualChannelRequest) String() string { return proto.CompactTextString(m) } func (*DropVirtualChannelRequest) ProtoMessage() {} func (*DropVirtualChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{52} + return fileDescriptor_82cd95f524594f49, []int{55} } func (m *DropVirtualChannelRequest) XXX_Unmarshal(b []byte) error { @@ -3337,7 +3478,7 @@ func (m *DropVirtualChannelSegment) Reset() { *m = DropVirtualChannelSeg func (m *DropVirtualChannelSegment) String() string { return proto.CompactTextString(m) } func (*DropVirtualChannelSegment) ProtoMessage() {} func (*DropVirtualChannelSegment) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{53} + return fileDescriptor_82cd95f524594f49, []int{56} } func (m *DropVirtualChannelSegment) XXX_Unmarshal(b []byte) error { @@ -3425,7 +3566,7 @@ func (m *DropVirtualChannelResponse) Reset() { *m = DropVirtualChannelRe func (m *DropVirtualChannelResponse) String() string { return proto.CompactTextString(m) } func (*DropVirtualChannelResponse) ProtoMessage() {} func (*DropVirtualChannelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{54} + return fileDescriptor_82cd95f524594f49, []int{57} } func (m *DropVirtualChannelResponse) XXX_Unmarshal(b []byte) error { @@ -3471,7 +3612,7 @@ func (m *ImportTask) Reset() { *m = ImportTask{} } func (m *ImportTask) String() string { return proto.CompactTextString(m) } func (*ImportTask) ProtoMessage() {} func (*ImportTask) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{55} + return fileDescriptor_82cd95f524594f49, []int{58} } func (m *ImportTask) XXX_Unmarshal(b []byte) error { @@ -3563,7 +3704,7 @@ func (m *ImportTaskState) Reset() { *m = ImportTaskState{} } func (m *ImportTaskState) String() string { return proto.CompactTextString(m) } func (*ImportTaskState) ProtoMessage() {} func (*ImportTaskState) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{56} + return fileDescriptor_82cd95f524594f49, []int{59} } func (m *ImportTaskState) XXX_Unmarshal(b []byte) error { @@ -3642,7 +3783,7 @@ func (m *ImportTaskInfo) Reset() { *m = ImportTaskInfo{} } func (m *ImportTaskInfo) String() string { return proto.CompactTextString(m) } func (*ImportTaskInfo) ProtoMessage() {} func (*ImportTaskInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{57} + return fileDescriptor_82cd95f524594f49, []int{60} } func (m *ImportTaskInfo) XXX_Unmarshal(b []byte) error { @@ -3767,7 +3908,7 @@ func (m *ImportTaskResponse) Reset() { *m = ImportTaskResponse{} } func (m *ImportTaskResponse) String() string { return proto.CompactTextString(m) } func (*ImportTaskResponse) ProtoMessage() {} func (*ImportTaskResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{58} + return fileDescriptor_82cd95f524594f49, []int{61} } func (m *ImportTaskResponse) XXX_Unmarshal(b []byte) error { @@ -3815,7 +3956,7 @@ func (m *ImportTaskRequest) Reset() { *m = ImportTaskRequest{} } func (m *ImportTaskRequest) String() string { return proto.CompactTextString(m) } func (*ImportTaskRequest) ProtoMessage() {} func (*ImportTaskRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{59} + return fileDescriptor_82cd95f524594f49, []int{62} } func (m *ImportTaskRequest) XXX_Unmarshal(b []byte) error { @@ -3869,7 +4010,7 @@ func (m *UpdateSegmentStatisticsRequest) Reset() { *m = UpdateSegmentSta func (m *UpdateSegmentStatisticsRequest) String() string { return proto.CompactTextString(m) } func (*UpdateSegmentStatisticsRequest) ProtoMessage() {} func (*UpdateSegmentStatisticsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{60} + return fileDescriptor_82cd95f524594f49, []int{63} } func (m *UpdateSegmentStatisticsRequest) XXX_Unmarshal(b []byte) error { @@ -3915,7 +4056,7 @@ func (m *ResendSegmentStatsRequest) Reset() { *m = ResendSegmentStatsReq func (m *ResendSegmentStatsRequest) String() string { return proto.CompactTextString(m) } func (*ResendSegmentStatsRequest) ProtoMessage() {} func (*ResendSegmentStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{61} + return fileDescriptor_82cd95f524594f49, []int{64} } func (m *ResendSegmentStatsRequest) XXX_Unmarshal(b []byte) error { @@ -3955,7 +4096,7 @@ func (m *ResendSegmentStatsResponse) Reset() { *m = ResendSegmentStatsRe func (m *ResendSegmentStatsResponse) String() string { return proto.CompactTextString(m) } func (*ResendSegmentStatsResponse) ProtoMessage() {} func (*ResendSegmentStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{62} + return fileDescriptor_82cd95f524594f49, []int{65} } func (m *ResendSegmentStatsResponse) XXX_Unmarshal(b []byte) error { @@ -4006,7 +4147,7 @@ func (m *AddSegmentRequest) Reset() { *m = AddSegmentRequest{} } func (m *AddSegmentRequest) String() string { return proto.CompactTextString(m) } func (*AddSegmentRequest) ProtoMessage() {} func (*AddSegmentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{63} + return fileDescriptor_82cd95f524594f49, []int{66} } func (m *AddSegmentRequest) XXX_Unmarshal(b []byte) error { @@ -4082,7 +4223,7 @@ func (m *SegmentReferenceLock) Reset() { *m = SegmentReferenceLock{} } func (m *SegmentReferenceLock) String() string { return proto.CompactTextString(m) } func (*SegmentReferenceLock) ProtoMessage() {} func (*SegmentReferenceLock) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{64} + return fileDescriptor_82cd95f524594f49, []int{67} } func (m *SegmentReferenceLock) XXX_Unmarshal(b []byte) error { @@ -4171,9 +4312,12 @@ func init() { proto.RegisterType((*GetFlushedSegmentsResponse)(nil), "milvus.proto.data.GetFlushedSegmentsResponse") proto.RegisterType((*SegmentFlushCompletedMsg)(nil), "milvus.proto.data.SegmentFlushCompletedMsg") proto.RegisterType((*ChannelWatchInfo)(nil), "milvus.proto.data.ChannelWatchInfo") + proto.RegisterType((*CompactionStateRequest)(nil), "milvus.proto.data.CompactionStateRequest") proto.RegisterType((*CompactionSegmentBinlogs)(nil), "milvus.proto.data.CompactionSegmentBinlogs") proto.RegisterType((*CompactionPlan)(nil), "milvus.proto.data.CompactionPlan") proto.RegisterType((*CompactionResult)(nil), "milvus.proto.data.CompactionResult") + proto.RegisterType((*CompactionStateResult)(nil), "milvus.proto.data.CompactionStateResult") + proto.RegisterType((*CompactionStateResponse)(nil), "milvus.proto.data.CompactionStateResponse") proto.RegisterType((*SegmentFieldBinlogMeta)(nil), "milvus.proto.data.SegmentFieldBinlogMeta") proto.RegisterType((*WatchChannelsRequest)(nil), "milvus.proto.data.WatchChannelsRequest") proto.RegisterType((*WatchChannelsResponse)(nil), "milvus.proto.data.WatchChannelsResponse") @@ -4197,243 +4341,248 @@ func init() { func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) } var fileDescriptor_82cd95f524594f49 = []byte{ - // 3776 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x3b, 0xdd, 0x6f, 0x1c, 0x57, - 0xf5, 0x99, 0xfd, 0xf2, 0xee, 0xd9, 0x0f, 0xaf, 0x6f, 0x52, 0x67, 0xb3, 0x49, 0x9c, 0x64, 0xd2, - 0xa4, 0x69, 0x9a, 0x26, 0xad, 0xf3, 0xab, 0x5a, 0xfd, 0xfa, 0xa5, 0x38, 0x4e, 0x9c, 0x15, 0x76, - 0x70, 0xc6, 0x4e, 0x83, 0x28, 0xd2, 0x6a, 0xbc, 0x73, 0xbd, 0x9e, 0x7a, 0x67, 0x66, 0x33, 0x33, - 0x1b, 0xc7, 0xe5, 0xa1, 0x15, 0x95, 0x90, 0x8a, 0x10, 0x45, 0x42, 0x48, 0x20, 0x81, 0x84, 0x78, - 0x02, 0x24, 0x24, 0xa4, 0x8a, 0x07, 0x40, 0x7d, 0xaf, 0xe0, 0x01, 0xf1, 0xc6, 0x7f, 0x00, 0xe2, - 0x81, 0xbf, 0x01, 0xdd, 0x8f, 0xb9, 0xf3, 0xbd, 0x3b, 0x5e, 0x27, 0x0d, 0xe2, 0x6d, 0xef, 0x99, - 0x73, 0xef, 0x3d, 0xf7, 0x7c, 0x9f, 0x73, 0xef, 0x42, 0x53, 0x53, 0x5d, 0xb5, 0xdb, 0xb3, 0x2c, - 0x5b, 0xbb, 0x3a, 0xb4, 0x2d, 0xd7, 0x42, 0x73, 0x86, 0x3e, 0x78, 0x34, 0x72, 0xd8, 0xe8, 0x2a, - 0xf9, 0xdc, 0xae, 0xf5, 0x2c, 0xc3, 0xb0, 0x4c, 0x06, 0x6a, 0x37, 0x74, 0xd3, 0xc5, 0xb6, 0xa9, - 0x0e, 0xf8, 0xb8, 0x16, 0x9c, 0xd0, 0xae, 0x39, 0xbd, 0x1d, 0x6c, 0xa8, 0x6c, 0x24, 0xcf, 0x40, - 0xf1, 0x96, 0x31, 0x74, 0xf7, 0xe5, 0x9f, 0x48, 0x50, 0xbb, 0x3d, 0x18, 0x39, 0x3b, 0x0a, 0x7e, - 0x38, 0xc2, 0x8e, 0x8b, 0x5e, 0x81, 0xc2, 0x96, 0xea, 0xe0, 0x96, 0x74, 0x56, 0xba, 0x54, 0x5d, - 0x3c, 0x75, 0x35, 0xb4, 0x2b, 0xdf, 0x6f, 0xcd, 0xe9, 0x2f, 0xa9, 0x0e, 0x56, 0x28, 0x26, 0x42, - 0x50, 0xd0, 0xb6, 0x3a, 0xcb, 0xad, 0xdc, 0x59, 0xe9, 0x52, 0x5e, 0xa1, 0xbf, 0xd1, 0x02, 0x80, - 0x83, 0xfb, 0x06, 0x36, 0xdd, 0xce, 0xb2, 0xd3, 0xca, 0x9f, 0xcd, 0x5f, 0xca, 0x2b, 0x01, 0x08, - 0x92, 0xa1, 0xd6, 0xb3, 0x06, 0x03, 0xdc, 0x73, 0x75, 0xcb, 0xec, 0x2c, 0xb7, 0x0a, 0x74, 0x6e, - 0x08, 0x26, 0xff, 0x4c, 0x82, 0x3a, 0x27, 0xcd, 0x19, 0x5a, 0xa6, 0x83, 0xd1, 0x75, 0x28, 0x39, - 0xae, 0xea, 0x8e, 0x1c, 0x4e, 0xdd, 0xc9, 0x44, 0xea, 0x36, 0x28, 0x8a, 0xc2, 0x51, 0x13, 0xc9, - 0x8b, 0x6e, 0x9f, 0x8f, 0x6f, 0x1f, 0x39, 0x42, 0x21, 0x7a, 0x04, 0xf9, 0x6f, 0x12, 0x34, 0x37, - 0xbc, 0xa1, 0xc7, 0xbd, 0x63, 0x50, 0xec, 0x59, 0x23, 0xd3, 0xa5, 0x04, 0xd6, 0x15, 0x36, 0x40, - 0xe7, 0xa0, 0xd6, 0xdb, 0x51, 0x4d, 0x13, 0x0f, 0xba, 0xa6, 0x6a, 0x60, 0x4a, 0x4a, 0x45, 0xa9, - 0x72, 0xd8, 0x5d, 0xd5, 0xc0, 0x99, 0x28, 0x3a, 0x0b, 0xd5, 0xa1, 0x6a, 0xbb, 0x7a, 0x88, 0x67, - 0x41, 0x10, 0x6a, 0x43, 0x59, 0x77, 0x3a, 0xc6, 0xd0, 0xb2, 0xdd, 0x56, 0xf1, 0xac, 0x74, 0xa9, - 0xac, 0x88, 0x31, 0xd9, 0x41, 0xa7, 0xbf, 0x36, 0x55, 0x67, 0xb7, 0xb3, 0xdc, 0x2a, 0xb1, 0x1d, - 0x82, 0x30, 0xf9, 0x17, 0x12, 0xcc, 0xdf, 0x70, 0x1c, 0xbd, 0x6f, 0xc6, 0x4e, 0x36, 0x0f, 0x25, - 0xd3, 0xd2, 0x70, 0x67, 0x99, 0x1e, 0x2d, 0xaf, 0xf0, 0x11, 0x3a, 0x09, 0x95, 0x21, 0xc6, 0x76, - 0xd7, 0xb6, 0x06, 0xde, 0xc1, 0xca, 0x04, 0xa0, 0x58, 0x03, 0x8c, 0xee, 0xc1, 0x9c, 0x13, 0x59, - 0x88, 0x69, 0x43, 0x75, 0xf1, 0xfc, 0xd5, 0x98, 0x3e, 0x5f, 0x8d, 0x6e, 0xaa, 0xc4, 0x67, 0xcb, - 0x1f, 0xe7, 0xe0, 0xa8, 0xc0, 0x63, 0xb4, 0x92, 0xdf, 0x84, 0xf3, 0x0e, 0xee, 0x0b, 0xf2, 0xd8, - 0x20, 0x0b, 0xe7, 0x85, 0xc8, 0xf2, 0x41, 0x91, 0x65, 0x50, 0xd0, 0xa8, 0x3c, 0x8a, 0x71, 0x79, - 0x9c, 0x81, 0x2a, 0x7e, 0x3c, 0xd4, 0x6d, 0xdc, 0x75, 0x75, 0x03, 0x53, 0x96, 0x17, 0x14, 0x60, - 0xa0, 0x4d, 0xdd, 0x08, 0x6a, 0xf4, 0x4c, 0x66, 0x8d, 0x96, 0x7f, 0x29, 0xc1, 0xf1, 0x98, 0x94, - 0xb8, 0x89, 0x28, 0xd0, 0xa4, 0x27, 0xf7, 0x39, 0x43, 0x8c, 0x85, 0x30, 0xfc, 0xe2, 0x38, 0x86, - 0xfb, 0xe8, 0x4a, 0x6c, 0x7e, 0x80, 0xc8, 0x5c, 0x76, 0x22, 0x77, 0xe1, 0xf8, 0x0a, 0x76, 0xf9, - 0x06, 0xe4, 0x1b, 0x76, 0xa6, 0x77, 0x31, 0x61, 0x5b, 0xcc, 0xc5, 0x6c, 0xf1, 0x77, 0x39, 0x61, - 0x8b, 0x74, 0xab, 0x8e, 0xb9, 0x6d, 0xa1, 0x53, 0x50, 0x11, 0x28, 0x5c, 0x2b, 0x7c, 0x00, 0x7a, - 0x1d, 0x8a, 0x84, 0x52, 0xa6, 0x12, 0x8d, 0xc5, 0x73, 0xc9, 0x67, 0x0a, 0xac, 0xa9, 0x30, 0x7c, - 0xd4, 0x81, 0x86, 0xe3, 0xaa, 0xb6, 0xdb, 0x1d, 0x5a, 0x0e, 0x95, 0x33, 0x55, 0x9c, 0xea, 0xa2, - 0x1c, 0x5e, 0x41, 0x38, 0xe3, 0x35, 0xa7, 0xbf, 0xce, 0x31, 0x95, 0x3a, 0x9d, 0xe9, 0x0d, 0xd1, - 0x2d, 0xa8, 0x61, 0x53, 0xf3, 0x17, 0x2a, 0x64, 0x5e, 0xa8, 0x8a, 0x4d, 0x4d, 0x2c, 0xe3, 0xcb, - 0xa7, 0x98, 0x5d, 0x3e, 0xdf, 0x97, 0xa0, 0x15, 0x17, 0xd0, 0x61, 0x1c, 0xed, 0x9b, 0x6c, 0x12, - 0x66, 0x02, 0x1a, 0x6b, 0xe1, 0x42, 0x48, 0x0a, 0x9f, 0x22, 0xff, 0x58, 0x82, 0xe7, 0x7c, 0x72, - 0xe8, 0xa7, 0xa7, 0xa5, 0x2d, 0xe8, 0x32, 0x34, 0x75, 0xb3, 0x37, 0x18, 0x69, 0xf8, 0xbe, 0x79, - 0x07, 0xab, 0x03, 0x77, 0x67, 0x9f, 0xca, 0xb0, 0xac, 0xc4, 0xe0, 0xf2, 0x27, 0x12, 0xcc, 0x47, - 0xe9, 0x3a, 0x0c, 0x93, 0xfe, 0x0f, 0x8a, 0xba, 0xb9, 0x6d, 0x79, 0x3c, 0x5a, 0x18, 0x63, 0x94, - 0x64, 0x2f, 0x86, 0x2c, 0x1b, 0x70, 0x72, 0x05, 0xbb, 0x1d, 0xd3, 0xc1, 0xb6, 0xbb, 0xa4, 0x9b, - 0x03, 0xab, 0xbf, 0xae, 0xba, 0x3b, 0x87, 0x30, 0xa8, 0x90, 0x6d, 0xe4, 0x22, 0xb6, 0x21, 0xff, - 0x4a, 0x82, 0x53, 0xc9, 0xfb, 0xf1, 0xa3, 0xb7, 0xa1, 0xbc, 0xad, 0xe3, 0x81, 0x46, 0xf8, 0x2b, - 0x51, 0xfe, 0x8a, 0x31, 0x31, 0xac, 0x21, 0x41, 0xe6, 0x27, 0x3c, 0x97, 0xa2, 0xcd, 0x1b, 0xae, - 0xad, 0x9b, 0xfd, 0x55, 0xdd, 0x71, 0x15, 0x86, 0x1f, 0xe0, 0x67, 0x3e, 0xbb, 0x1a, 0x7f, 0x4f, - 0x82, 0x85, 0x15, 0xec, 0xde, 0x14, 0x7e, 0x99, 0x7c, 0xd7, 0x1d, 0x57, 0xef, 0x39, 0x4f, 0x36, - 0xa3, 0xc9, 0x10, 0xa0, 0xe5, 0xcf, 0x24, 0x38, 0x93, 0x4a, 0x0c, 0x67, 0x1d, 0xf7, 0x3b, 0x9e, - 0x57, 0x4e, 0xf6, 0x3b, 0x5f, 0xc3, 0xfb, 0xef, 0xa9, 0x83, 0x11, 0x5e, 0x57, 0x75, 0x9b, 0xf9, - 0x9d, 0x29, 0xbd, 0xf0, 0x6f, 0x25, 0x38, 0xbd, 0x82, 0xdd, 0x75, 0x2f, 0x26, 0x3d, 0x43, 0xee, - 0x10, 0x9c, 0x40, 0x6c, 0xf4, 0x52, 0xaa, 0x10, 0x4c, 0xfe, 0x01, 0x13, 0x67, 0x22, 0xbd, 0xcf, - 0x84, 0x81, 0x0b, 0xd4, 0x12, 0x02, 0x26, 0x79, 0x93, 0xa5, 0x0e, 0x9c, 0x7d, 0xf2, 0xcf, 0x25, - 0x38, 0x71, 0xa3, 0xf7, 0x70, 0xa4, 0xdb, 0x98, 0x23, 0xad, 0x5a, 0xbd, 0xdd, 0xe9, 0x99, 0xeb, - 0xa7, 0x59, 0xb9, 0x50, 0x9a, 0x35, 0x29, 0xa1, 0x9e, 0x87, 0x92, 0xcb, 0xf2, 0x3a, 0x96, 0xa9, - 0xf0, 0x11, 0xa5, 0x4f, 0xc1, 0x03, 0xac, 0x3a, 0xff, 0x9d, 0xf4, 0x7d, 0x56, 0x80, 0xda, 0x7b, - 0x3c, 0x1d, 0xa3, 0x51, 0x3b, 0xaa, 0x49, 0x52, 0x72, 0xe2, 0x15, 0xc8, 0xe0, 0x92, 0x92, 0xba, - 0x15, 0xa8, 0x3b, 0x18, 0xef, 0x4e, 0x13, 0xa3, 0x6b, 0x64, 0xa2, 0x88, 0xad, 0xab, 0x30, 0x37, - 0x32, 0xb7, 0x49, 0x15, 0x82, 0x35, 0xce, 0x40, 0xa6, 0xb9, 0x93, 0x7d, 0x77, 0x7c, 0x22, 0xba, - 0x03, 0xb3, 0xd1, 0xb5, 0x8a, 0x99, 0xd6, 0x8a, 0x4e, 0x43, 0x1d, 0x68, 0x6a, 0xb6, 0x35, 0x1c, - 0x62, 0xad, 0xeb, 0x78, 0x4b, 0x95, 0xb2, 0x2d, 0xc5, 0xe7, 0x89, 0xa5, 0x5e, 0x81, 0xa3, 0x51, - 0x4a, 0x3b, 0x1a, 0x49, 0x48, 0x89, 0x0c, 0x93, 0x3e, 0xa1, 0x2b, 0x30, 0x17, 0xc7, 0x2f, 0x53, - 0xfc, 0xf8, 0x07, 0xf4, 0x32, 0xa0, 0x08, 0xa9, 0x04, 0xbd, 0xc2, 0xd0, 0xc3, 0xc4, 0x74, 0x34, - 0x47, 0xfe, 0x54, 0x82, 0xf9, 0x07, 0xaa, 0xdb, 0xdb, 0x59, 0x36, 0xb8, 0xad, 0x1d, 0xc2, 0x57, - 0xbd, 0x0d, 0x95, 0x47, 0x5c, 0x2f, 0xbc, 0x80, 0x74, 0x26, 0x81, 0x3f, 0x41, 0x0d, 0x54, 0xfc, - 0x19, 0xf2, 0x97, 0x12, 0x1c, 0xa3, 0x25, 0xa8, 0xc7, 0xac, 0xaf, 0xde, 0x6b, 0x4e, 0x28, 0x43, - 0xd1, 0x45, 0x68, 0x18, 0xaa, 0xbd, 0xbb, 0xe1, 0xe3, 0x14, 0x29, 0x4e, 0x04, 0x2a, 0x3f, 0x06, - 0xe0, 0xa3, 0x35, 0xa7, 0x3f, 0x05, 0xfd, 0x6f, 0xc0, 0x0c, 0xdf, 0x95, 0xbb, 0xcf, 0x49, 0x7a, - 0xe6, 0xa1, 0xcb, 0x7f, 0x96, 0xa0, 0xe1, 0x87, 0x44, 0x6a, 0xe4, 0x0d, 0xc8, 0x09, 0xd3, 0xce, - 0x75, 0x96, 0xd1, 0xdb, 0x50, 0x62, 0xed, 0x09, 0xbe, 0xf6, 0x85, 0xf0, 0xda, 0xbc, 0x75, 0x11, - 0x88, 0xab, 0x14, 0xa0, 0xf0, 0x49, 0x84, 0x47, 0x22, 0x8a, 0x08, 0xe7, 0xe3, 0x43, 0x50, 0x07, - 0x66, 0xc3, 0x29, 0xbb, 0x67, 0xc2, 0x67, 0xd3, 0x82, 0xc7, 0xb2, 0xea, 0xaa, 0x34, 0x76, 0x34, - 0x42, 0x19, 0xbb, 0x23, 0xff, 0xbb, 0x08, 0xd5, 0xc0, 0x29, 0x63, 0x27, 0x89, 0x8a, 0x34, 0x37, - 0xb9, 0x6e, 0xcc, 0xc7, 0xeb, 0xc6, 0x0b, 0xd0, 0xd0, 0x69, 0xf2, 0xd5, 0xe5, 0xaa, 0x48, 0xbd, - 0x66, 0x45, 0xa9, 0x33, 0x28, 0xb7, 0x0b, 0xb4, 0x00, 0x55, 0x73, 0x64, 0x74, 0xad, 0xed, 0xae, - 0x6d, 0xed, 0x39, 0xbc, 0x00, 0xad, 0x98, 0x23, 0xe3, 0xeb, 0xdb, 0x8a, 0xb5, 0xe7, 0xf8, 0x35, - 0x4e, 0xe9, 0x80, 0x35, 0xce, 0x02, 0x54, 0x0d, 0xf5, 0x31, 0x59, 0xb5, 0x6b, 0x8e, 0x0c, 0x5a, - 0x9b, 0xe6, 0x95, 0x8a, 0xa1, 0x3e, 0x56, 0xac, 0xbd, 0xbb, 0x23, 0x03, 0x5d, 0x82, 0xe6, 0x40, - 0x75, 0xdc, 0x6e, 0xb0, 0xb8, 0x2d, 0xd3, 0xe2, 0xb6, 0x41, 0xe0, 0xb7, 0xfc, 0x02, 0x37, 0x5e, - 0x2d, 0x55, 0x0e, 0x51, 0x2d, 0x69, 0xc6, 0xc0, 0x5f, 0x08, 0xb2, 0x57, 0x4b, 0x9a, 0x31, 0x10, - 0xcb, 0xbc, 0x01, 0x33, 0x5b, 0x34, 0xa5, 0x75, 0x5a, 0xd5, 0x54, 0x87, 0x79, 0x9b, 0x64, 0xb3, - 0x2c, 0xf3, 0x55, 0x3c, 0x74, 0xf4, 0x16, 0x54, 0x68, 0x26, 0x41, 0xe7, 0xd6, 0x32, 0xcd, 0xf5, - 0x27, 0x90, 0xd9, 0x1a, 0x1e, 0xb8, 0x2a, 0x9d, 0x5d, 0xcf, 0x36, 0x5b, 0x4c, 0x20, 0x4e, 0xba, - 0x67, 0x63, 0xd5, 0xc5, 0xda, 0xd2, 0xfe, 0x4d, 0xcb, 0x18, 0xaa, 0x54, 0x99, 0x5a, 0x0d, 0x5a, - 0xb6, 0x24, 0x7d, 0x22, 0x8e, 0xa1, 0x27, 0x46, 0xb7, 0x6d, 0xcb, 0x68, 0xcd, 0x32, 0xc7, 0x10, - 0x86, 0xa2, 0xd3, 0x00, 0x9e, 0x7b, 0x56, 0xdd, 0x56, 0x93, 0x4a, 0xb1, 0xc2, 0x21, 0x37, 0x5c, - 0xf9, 0x23, 0x38, 0xe6, 0x6b, 0x48, 0x40, 0x1a, 0x71, 0xc1, 0x4a, 0xd3, 0x0a, 0x76, 0x7c, 0x31, - 0xf2, 0xd7, 0x02, 0xcc, 0x6f, 0xa8, 0x8f, 0xf0, 0xd3, 0xaf, 0x7b, 0x32, 0xf9, 0xe3, 0x55, 0x98, - 0xa3, 0xa5, 0xce, 0x62, 0x80, 0x9e, 0x31, 0x09, 0x41, 0x50, 0x9c, 0xf1, 0x89, 0xe8, 0x5d, 0x92, - 0xc9, 0xe0, 0xde, 0xee, 0xba, 0xa5, 0xfb, 0xc9, 0xc0, 0xe9, 0x84, 0x75, 0x6e, 0x0a, 0x2c, 0x25, - 0x38, 0x03, 0xad, 0xc7, 0x5d, 0x1b, 0x4b, 0x03, 0x5e, 0x18, 0x5b, 0x7d, 0xfb, 0xdc, 0x8f, 0x7a, - 0x38, 0xd4, 0x82, 0x19, 0x1e, 0xc3, 0xa9, 0xdd, 0x97, 0x15, 0x6f, 0x88, 0xd6, 0xe1, 0x28, 0x3b, - 0xc1, 0x06, 0x57, 0x6a, 0x76, 0xf8, 0x72, 0xa6, 0xc3, 0x27, 0x4d, 0x0d, 0xdb, 0x44, 0xe5, 0xa0, - 0x36, 0xd1, 0x82, 0x19, 0xae, 0xa7, 0xd4, 0x17, 0x94, 0x15, 0x6f, 0x48, 0xc4, 0xcc, 0xfa, 0x9a, - 0xba, 0xd9, 0x6f, 0x55, 0xe9, 0x37, 0x1f, 0x40, 0x6a, 0x46, 0xf0, 0xf9, 0x39, 0xa1, 0x4f, 0xf4, - 0x0e, 0x94, 0x85, 0x86, 0xe7, 0x32, 0x6b, 0xb8, 0x98, 0x13, 0xf5, 0xd1, 0xf9, 0x88, 0x8f, 0x96, - 0xff, 0x22, 0x41, 0x6d, 0x99, 0x1c, 0x69, 0xd5, 0xea, 0xd3, 0x88, 0x72, 0x01, 0x1a, 0x36, 0xee, - 0x59, 0xb6, 0xd6, 0xc5, 0xa6, 0x6b, 0xeb, 0x98, 0xb5, 0x17, 0x0a, 0x4a, 0x9d, 0x41, 0x6f, 0x31, - 0x20, 0x41, 0x23, 0x6e, 0xd7, 0x71, 0x55, 0x63, 0xd8, 0xdd, 0x26, 0xe6, 0x9d, 0x63, 0x68, 0x02, - 0x4a, 0xad, 0xfb, 0x1c, 0xd4, 0x7c, 0x34, 0xd7, 0xa2, 0xfb, 0x17, 0x94, 0xaa, 0x80, 0x6d, 0x5a, - 0xe8, 0x79, 0x68, 0x50, 0x9e, 0x76, 0x07, 0x56, 0xbf, 0x4b, 0x4a, 0x71, 0x1e, 0x6c, 0x6a, 0x1a, - 0x27, 0x8b, 0xc8, 0x2a, 0x8c, 0xe5, 0xe8, 0x1f, 0x62, 0x1e, 0x6e, 0x04, 0xd6, 0x86, 0xfe, 0x21, - 0x26, 0xb1, 0xbe, 0x4e, 0x62, 0xe7, 0x5d, 0x4b, 0xc3, 0x9b, 0x53, 0x66, 0x1a, 0x19, 0x7a, 0xb6, - 0xa7, 0xa0, 0x22, 0x4e, 0xc0, 0x8f, 0xe4, 0x03, 0xd0, 0x6d, 0x68, 0x78, 0x39, 0x71, 0x97, 0x95, - 0x8a, 0x85, 0xd4, 0xcc, 0x2f, 0x10, 0xfd, 0x1c, 0xa5, 0xee, 0x4d, 0xa3, 0x43, 0xf9, 0x36, 0xd4, - 0x82, 0x9f, 0xc9, 0xae, 0x1b, 0x51, 0x45, 0x11, 0x00, 0xa2, 0x8d, 0x77, 0x47, 0x06, 0x91, 0x29, - 0x77, 0x2c, 0xde, 0x50, 0xfe, 0x44, 0x82, 0x3a, 0x0f, 0xd9, 0x1b, 0xe2, 0x4e, 0x82, 0x1e, 0x4d, - 0xa2, 0x47, 0xa3, 0xbf, 0xd1, 0xff, 0x87, 0x1b, 0x92, 0xcf, 0x27, 0x3a, 0x01, 0xba, 0x08, 0xcd, - 0x8e, 0x43, 0xf1, 0x3a, 0x4b, 0x73, 0xe2, 0x63, 0xa2, 0x68, 0x5c, 0x34, 0x54, 0xd1, 0x5a, 0x30, - 0xa3, 0x6a, 0x9a, 0x8d, 0x1d, 0x87, 0xd3, 0xe1, 0x0d, 0xc9, 0x97, 0x47, 0xd8, 0x76, 0x3c, 0x95, - 0xcf, 0x2b, 0xde, 0x10, 0xbd, 0x05, 0x65, 0x91, 0x4e, 0xe7, 0x93, 0x52, 0xa8, 0x20, 0x9d, 0xbc, - 0x94, 0x16, 0x33, 0xe4, 0xdf, 0xe7, 0xa0, 0xc1, 0x19, 0xb6, 0xc4, 0x63, 0xea, 0x78, 0xe3, 0x5b, - 0x82, 0xda, 0xb6, 0x6f, 0xfb, 0xe3, 0x9a, 0x66, 0x41, 0x17, 0x11, 0x9a, 0x33, 0xc9, 0x00, 0xc3, - 0x51, 0xbd, 0x70, 0xa8, 0xa8, 0x5e, 0x3c, 0xa8, 0x07, 0x8b, 0xe7, 0x79, 0xa5, 0x84, 0x3c, 0x4f, - 0xfe, 0x16, 0x54, 0x03, 0x0b, 0x50, 0x0f, 0xcd, 0xba, 0x6d, 0x9c, 0x63, 0xde, 0x10, 0x5d, 0xf7, - 0x73, 0x1b, 0xc6, 0xaa, 0x13, 0x09, 0xb4, 0x44, 0xd2, 0x1a, 0xf9, 0xd7, 0x12, 0x94, 0xf8, 0xca, - 0x67, 0xa0, 0xca, 0x9d, 0x0e, 0xcd, 0xfb, 0xd8, 0xea, 0xc0, 0x41, 0x24, 0xf1, 0x7b, 0x72, 0x5e, - 0xe7, 0x04, 0x94, 0x23, 0xfe, 0x66, 0x86, 0x87, 0x05, 0xef, 0x53, 0xc0, 0xc9, 0x90, 0x4f, 0xd4, - 0xbf, 0x7c, 0x29, 0xd1, 0x6b, 0x05, 0x05, 0xf7, 0xac, 0x47, 0xd8, 0xde, 0x3f, 0x7c, 0x3f, 0xf6, - 0xcd, 0x80, 0x42, 0x67, 0xac, 0x0f, 0xc5, 0x04, 0xf4, 0xa6, 0xcf, 0xee, 0x7c, 0x52, 0x33, 0x2a, - 0xe8, 0x61, 0xb8, 0x3a, 0xfa, 0x6c, 0xff, 0x21, 0xeb, 0x2c, 0x87, 0x8f, 0x32, 0x6d, 0x5e, 0xf3, - 0x44, 0xca, 0x0e, 0xf9, 0x47, 0x12, 0x9c, 0x58, 0xc1, 0xee, 0xed, 0x70, 0xaf, 0xe1, 0x59, 0x53, - 0x65, 0x40, 0x3b, 0x89, 0xa8, 0xc3, 0x48, 0xbd, 0x0d, 0x65, 0xd1, 0x35, 0x61, 0xf7, 0x03, 0x62, - 0x2c, 0x7f, 0x57, 0x82, 0x16, 0xdf, 0x85, 0xee, 0x49, 0x52, 0xea, 0x01, 0x76, 0xb1, 0xf6, 0x55, - 0xd7, 0xcd, 0x5f, 0x48, 0xd0, 0x0c, 0x7a, 0x7c, 0xea, 0xb4, 0x5f, 0x83, 0x22, 0x6d, 0x4f, 0x70, - 0x0a, 0x26, 0x2a, 0x2b, 0xc3, 0x26, 0x2e, 0x83, 0xa6, 0x79, 0x9b, 0x22, 0x38, 0xf1, 0xa1, 0x1f, - 0x76, 0xf2, 0x07, 0x0f, 0x3b, 0x3c, 0x0c, 0x5b, 0x23, 0xb2, 0x2e, 0xeb, 0xeb, 0xf9, 0x00, 0xf9, - 0xf3, 0x1c, 0xb4, 0xfc, 0x7a, 0xe4, 0x2b, 0xf7, 0xfb, 0x29, 0xd9, 0x6a, 0xfe, 0x09, 0x65, 0xab, - 0x85, 0xc3, 0xfb, 0xfa, 0x62, 0x92, 0xaf, 0xff, 0x53, 0x0e, 0x1a, 0x3e, 0xd7, 0xd6, 0x07, 0xaa, - 0x89, 0xe6, 0xa1, 0x34, 0x1c, 0xa8, 0x7e, 0x33, 0x94, 0x8f, 0xd0, 0x86, 0xc8, 0x73, 0xc2, 0x7c, - 0x7a, 0x29, 0x49, 0x86, 0x29, 0x82, 0x50, 0x22, 0x4b, 0x90, 0x72, 0x90, 0x15, 0x14, 0xb4, 0xa8, - 0xe7, 0xb9, 0x15, 0x53, 0x16, 0x52, 0xcf, 0x5f, 0x01, 0xc4, 0x25, 0xdc, 0xd5, 0xcd, 0xae, 0x83, - 0x7b, 0x96, 0xa9, 0x31, 0xd9, 0x17, 0x95, 0x26, 0xff, 0xd2, 0x31, 0x37, 0x18, 0x1c, 0xbd, 0x06, - 0x05, 0x77, 0x7f, 0xc8, 0xbc, 0x78, 0x23, 0xd1, 0x3b, 0xfa, 0x74, 0x6d, 0xee, 0x0f, 0xb1, 0x42, - 0xd1, 0xd1, 0x02, 0x00, 0x59, 0xca, 0xb5, 0xd5, 0x47, 0x3c, 0x24, 0x16, 0x94, 0x00, 0x84, 0x68, - 0xb3, 0xc7, 0xc3, 0x19, 0x16, 0x3a, 0xf8, 0x50, 0xfe, 0x43, 0x0e, 0x9a, 0xfe, 0x92, 0x0a, 0x76, - 0x46, 0x03, 0x37, 0x95, 0x7f, 0xe3, 0x8b, 0xc1, 0x49, 0x79, 0xc3, 0xbb, 0x50, 0xe5, 0xf2, 0x3c, - 0x80, 0x3e, 0x00, 0x9b, 0xb2, 0x3a, 0x46, 0x41, 0x8b, 0x4f, 0x48, 0x41, 0x4b, 0x07, 0x54, 0x50, - 0x79, 0x03, 0xe6, 0x3d, 0xbf, 0xe7, 0x23, 0xac, 0x61, 0x57, 0x1d, 0x93, 0x70, 0x9c, 0x81, 0x2a, - 0x8b, 0x67, 0x2c, 0x90, 0xb3, 0x54, 0x1d, 0xb6, 0x44, 0x85, 0x4b, 0x92, 0x8b, 0x63, 0xd4, 0x71, - 0x44, 0x7b, 0xb9, 0x59, 0xfa, 0xfc, 0xb2, 0xa8, 0x04, 0x48, 0xd6, 0xcf, 0xd4, 0xbb, 0xa2, 0x84, - 0x60, 0x49, 0xbd, 0xbd, 0xfc, 0x94, 0xbd, 0xbd, 0x55, 0x78, 0x2e, 0x42, 0xea, 0x21, 0x62, 0x0c, - 0x39, 0xf9, 0xfc, 0x46, 0xf8, 0x82, 0x7d, 0xfa, 0x48, 0x7a, 0x5a, 0x74, 0x81, 0xbb, 0xba, 0x16, - 0xd5, 0x55, 0x0d, 0xbd, 0x03, 0x15, 0x13, 0xef, 0x75, 0x83, 0x8e, 0x3c, 0x43, 0xb3, 0xaf, 0x6c, - 0xe2, 0x3d, 0xfa, 0x4b, 0xbe, 0x0b, 0xc7, 0x63, 0xa4, 0x1e, 0xe6, 0xec, 0x7f, 0x94, 0xe0, 0xc4, - 0xb2, 0x6d, 0x0d, 0xdf, 0xd3, 0x6d, 0x77, 0xa4, 0x0e, 0xc2, 0x77, 0x66, 0x4f, 0xa7, 0x24, 0xbc, - 0x13, 0x08, 0xe9, 0x4c, 0x01, 0xae, 0x24, 0xa8, 0x7e, 0x9c, 0x28, 0x7e, 0xe8, 0x40, 0x02, 0xf0, - 0x8f, 0x7c, 0x12, 0xf1, 0x1c, 0x6f, 0x42, 0xe0, 0xca, 0x92, 0xf1, 0x24, 0x76, 0x90, 0xf2, 0xd3, - 0x76, 0x90, 0x52, 0xbc, 0x48, 0xe1, 0x09, 0x79, 0x91, 0x03, 0x97, 0x34, 0x77, 0x20, 0xdc, 0xdd, - 0xa3, 0xee, 0x7b, 0xaa, 0xb6, 0xe0, 0x12, 0x80, 0xdf, 0xe9, 0xe2, 0xef, 0xa3, 0xb2, 0x2c, 0x13, - 0x98, 0x45, 0xa4, 0x25, 0x3c, 0x36, 0xed, 0x50, 0x87, 0x7a, 0x2f, 0xf7, 0xa0, 0x9d, 0xa4, 0xa5, - 0x87, 0xd1, 0xfc, 0xcf, 0x73, 0x00, 0x1d, 0xf1, 0xa4, 0x6e, 0xba, 0xec, 0xf4, 0x3c, 0xd4, 0x7d, - 0x85, 0xf1, 0xed, 0x3d, 0xa8, 0x45, 0x1a, 0x31, 0x09, 0x91, 0x24, 0x13, 0x9c, 0x58, 0xe2, 0xac, - 0xd1, 0x75, 0x02, 0x56, 0xc3, 0x94, 0x22, 0xea, 0x3f, 0x4f, 0x42, 0xc5, 0xb6, 0xf6, 0xba, 0xc4, - 0xcc, 0x34, 0xef, 0xcd, 0xa0, 0x6d, 0xed, 0x11, 0xe3, 0xd3, 0xd0, 0x71, 0x98, 0x71, 0x55, 0x67, - 0x97, 0xac, 0x5f, 0x0a, 0x5c, 0xdb, 0x6a, 0xe8, 0x18, 0x14, 0xb7, 0xf5, 0x01, 0x66, 0xb7, 0x84, - 0x15, 0x85, 0x0d, 0xd0, 0xeb, 0xde, 0xe3, 0x96, 0x72, 0xe6, 0xab, 0x79, 0xf6, 0xbe, 0xe5, 0x4b, - 0x09, 0x66, 0x7d, 0xae, 0x51, 0x07, 0x44, 0x7c, 0x1a, 0xf5, 0x67, 0x37, 0x2d, 0x8d, 0xb9, 0x8a, - 0x46, 0x8a, 0x4b, 0x67, 0x13, 0x99, 0xd7, 0xf2, 0xa7, 0x8c, 0xcb, 0xf1, 0xc9, 0xb9, 0xc8, 0xa1, - 0x75, 0xcd, 0xbb, 0x2d, 0x2a, 0xd9, 0xd6, 0x5e, 0x47, 0x13, 0xdc, 0x60, 0x0f, 0x02, 0x59, 0x46, - 0x4b, 0xb8, 0x71, 0x93, 0xbe, 0x09, 0x3c, 0x0f, 0x75, 0x6c, 0xdb, 0x96, 0xdd, 0x35, 0xb0, 0xe3, - 0xa8, 0x7d, 0xcc, 0x13, 0xb8, 0x1a, 0x05, 0xae, 0x31, 0x98, 0xfc, 0x45, 0x1e, 0x1a, 0xfe, 0x51, - 0xbc, 0x3b, 0x22, 0x5d, 0xf3, 0xee, 0x88, 0x74, 0x22, 0x3a, 0xb0, 0x99, 0x2b, 0x14, 0xc2, 0x5d, - 0xca, 0xb5, 0x24, 0xa5, 0xc2, 0xa1, 0x1d, 0x8d, 0xc4, 0x55, 0x62, 0x64, 0xa6, 0xa5, 0x61, 0x5f, - 0xb8, 0xe0, 0x81, 0xb8, 0x6c, 0x43, 0x3a, 0x52, 0xc8, 0xa0, 0x23, 0xc5, 0x0c, 0x3a, 0x52, 0x4a, - 0xd0, 0x91, 0x79, 0x28, 0x6d, 0x8d, 0x7a, 0xbb, 0xd8, 0xe5, 0xe9, 0x16, 0x1f, 0x85, 0x75, 0xa7, - 0x1c, 0xd1, 0x1d, 0xa1, 0x22, 0x95, 0xa0, 0x8a, 0x9c, 0x84, 0x0a, 0xbb, 0xac, 0xe8, 0xba, 0x0e, - 0xed, 0xda, 0xe6, 0x95, 0x32, 0x03, 0x6c, 0x3a, 0xe8, 0x0d, 0xaf, 0x16, 0xa9, 0x26, 0x19, 0x3b, - 0xf5, 0x3a, 0x11, 0x2d, 0xf1, 0x2a, 0x91, 0x0b, 0xd0, 0xa0, 0x0f, 0xa6, 0x1f, 0x8e, 0xb0, 0xbd, - 0xaf, 0x6e, 0x0d, 0x70, 0xab, 0x46, 0xc9, 0xa9, 0x13, 0xe8, 0x3d, 0x0f, 0x48, 0x18, 0x42, 0xd1, - 0x74, 0x53, 0xc3, 0x8f, 0xb1, 0xd6, 0xaa, 0x53, 0x24, 0xca, 0xea, 0x0e, 0x03, 0xc9, 0x1f, 0x00, - 0xf2, 0xf7, 0x38, 0x5c, 0x95, 0x19, 0x11, 0x62, 0x2e, 0x2a, 0x44, 0xf9, 0x37, 0x12, 0xcc, 0x05, - 0x37, 0x9b, 0x36, 0x3c, 0xbe, 0x03, 0x55, 0xd6, 0xdd, 0xee, 0x12, 0xf3, 0xe4, 0x75, 0xe6, 0xe9, - 0xb1, 0xdc, 0x53, 0xc0, 0x7f, 0xf8, 0x4b, 0x94, 0x60, 0xcf, 0xb2, 0x77, 0x75, 0xb3, 0xdf, 0x25, - 0x94, 0x79, 0x46, 0x51, 0xe3, 0xc0, 0xbb, 0x04, 0x26, 0x7f, 0x2a, 0xc1, 0xc2, 0xfd, 0xa1, 0xa6, - 0xba, 0x38, 0x90, 0x27, 0x1c, 0xf6, 0x2d, 0xd1, 0x6b, 0xde, 0x63, 0x9e, 0x5c, 0xb6, 0x0e, 0x2d, - 0xc3, 0x96, 0xd7, 0xe0, 0x84, 0x82, 0x1d, 0x6c, 0x6a, 0xa1, 0x8f, 0xd3, 0x52, 0x21, 0x0f, 0xa1, - 0x9d, 0xb4, 0xdc, 0x61, 0x64, 0xcf, 0x12, 0xb6, 0xae, 0x4d, 0x96, 0x75, 0xb9, 0xff, 0x21, 0x79, - 0x02, 0xdd, 0xc7, 0x95, 0xff, 0x29, 0xc1, 0xdc, 0x0d, 0xcd, 0xdb, 0xef, 0xa9, 0xe5, 0x85, 0xd1, - 0xbc, 0x29, 0x1f, 0xcf, 0x9b, 0x9e, 0x94, 0x23, 0xe1, 0x2e, 0xd5, 0x1c, 0x19, 0x5e, 0xa8, 0xb0, - 0xe9, 0x5d, 0xb1, 0xbc, 0x2d, 0x2e, 0x10, 0x15, 0xbc, 0x8d, 0x6d, 0x6c, 0xf6, 0xf0, 0xaa, 0xd5, - 0xdb, 0x0d, 0xbc, 0x08, 0x92, 0x82, 0x2f, 0x82, 0xa6, 0x7d, 0x61, 0x74, 0xf9, 0xa7, 0x12, 0xcc, - 0xc5, 0x3a, 0x15, 0xa8, 0x01, 0x70, 0xdf, 0xec, 0xf1, 0x16, 0x4e, 0xf3, 0x08, 0xaa, 0x41, 0xd9, - 0x6b, 0xe8, 0x34, 0x25, 0x54, 0x85, 0x99, 0x4d, 0x8b, 0x62, 0x37, 0x73, 0xa8, 0x09, 0x35, 0x36, - 0x71, 0xd4, 0xeb, 0x61, 0xc7, 0x69, 0xe6, 0x05, 0xe4, 0xb6, 0xaa, 0x0f, 0x46, 0x36, 0x6e, 0x16, - 0x50, 0x1d, 0x2a, 0x9b, 0x16, 0x7f, 0x4f, 0xd5, 0x2c, 0x22, 0x04, 0x0d, 0xef, 0x71, 0x15, 0x9f, - 0x54, 0x0a, 0xc0, 0xbc, 0x69, 0x33, 0x97, 0xb7, 0x83, 0x35, 0x3d, 0x29, 0x74, 0xd1, 0x71, 0x38, - 0x7a, 0xdf, 0xd4, 0xf0, 0xb6, 0x6e, 0x62, 0xcd, 0xff, 0xd4, 0x3c, 0x82, 0x8e, 0xc2, 0x6c, 0xc7, - 0x34, 0xb1, 0x1d, 0x00, 0x4a, 0x04, 0xb8, 0x86, 0xed, 0x3e, 0x0e, 0x00, 0x73, 0x68, 0x0e, 0xea, - 0x6b, 0xfa, 0xe3, 0x00, 0x28, 0xbf, 0xf8, 0xf7, 0x16, 0x54, 0x48, 0x79, 0x73, 0xd3, 0xb2, 0x6c, - 0x0d, 0x0d, 0x01, 0xd1, 0xd7, 0x88, 0xc6, 0xd0, 0x32, 0xc5, 0x1b, 0x5f, 0xf4, 0x4a, 0x4a, 0x0a, - 0x15, 0x47, 0xe5, 0x6a, 0xd9, 0xbe, 0x98, 0x32, 0x23, 0x82, 0x2e, 0x1f, 0x41, 0x06, 0xdd, 0x71, - 0x53, 0x37, 0xf0, 0xa6, 0xde, 0xdb, 0xf5, 0x9e, 0x29, 0x8c, 0xd9, 0x31, 0x82, 0xea, 0xed, 0x18, - 0x79, 0x3a, 0xcc, 0x07, 0xec, 0xc9, 0xa8, 0x67, 0x97, 0xf2, 0x11, 0xf4, 0x10, 0x8e, 0xad, 0xe0, - 0x80, 0x1f, 0xf2, 0x36, 0x5c, 0x4c, 0xdf, 0x30, 0x86, 0x7c, 0xc0, 0x2d, 0x57, 0xa1, 0x48, 0xbb, - 0x82, 0x28, 0xc9, 0x55, 0x05, 0xff, 0x48, 0xd3, 0x3e, 0x9b, 0x8e, 0x20, 0x56, 0xfb, 0x00, 0x66, - 0x23, 0x0f, 0xf9, 0xd1, 0x8b, 0x09, 0xd3, 0x92, 0xff, 0x92, 0xd1, 0xbe, 0x9c, 0x05, 0x55, 0xec, - 0xd5, 0x87, 0x46, 0xf8, 0x25, 0x23, 0xba, 0x94, 0x30, 0x3f, 0xf1, 0x0d, 0x76, 0xfb, 0xc5, 0x0c, - 0x98, 0x62, 0x23, 0x03, 0x9a, 0xd1, 0x87, 0xe5, 0xe8, 0xf2, 0xd8, 0x05, 0xc2, 0xea, 0xf6, 0x52, - 0x26, 0x5c, 0xb1, 0xdd, 0x3e, 0x55, 0x82, 0xd8, 0x5b, 0x65, 0x74, 0x35, 0x79, 0x99, 0xb4, 0x47, - 0xd4, 0xed, 0x6b, 0x99, 0xf1, 0xc5, 0xd6, 0xdf, 0x61, 0xb7, 0x11, 0x49, 0xef, 0x7d, 0xd1, 0xab, - 0xc9, 0xcb, 0x8d, 0x79, 0xa8, 0xdc, 0x5e, 0x3c, 0xc8, 0x14, 0x41, 0xc4, 0x47, 0xf4, 0x1a, 0x21, - 0xe1, 0xc5, 0x6c, 0xd4, 0xee, 0xbc, 0xf5, 0xd2, 0x1f, 0x03, 0xb7, 0x5f, 0x3d, 0xc0, 0x0c, 0x41, - 0x80, 0x15, 0x7d, 0xb9, 0xef, 0x99, 0xe1, 0xb5, 0x89, 0x5a, 0x33, 0x9d, 0x0d, 0xbe, 0x0f, 0xb3, - 0x91, 0x07, 0x21, 0x89, 0x56, 0x93, 0xfc, 0x68, 0xa4, 0x3d, 0x2e, 0x7c, 0x33, 0x93, 0x8c, 0xdc, - 0xca, 0xa0, 0x14, 0xed, 0x4f, 0xb8, 0xb9, 0x69, 0x5f, 0xce, 0x82, 0x2a, 0x0e, 0xe2, 0x50, 0x77, - 0x19, 0xb9, 0xd9, 0x40, 0x57, 0x92, 0xd7, 0x48, 0xbe, 0x95, 0x69, 0xbf, 0x9c, 0x11, 0x5b, 0x6c, - 0xfa, 0x6d, 0x40, 0x1b, 0x3b, 0xa4, 0xa4, 0x31, 0xb7, 0xf5, 0xfe, 0xc8, 0x56, 0xd9, 0xab, 0x8f, - 0x34, 0x1f, 0x1d, 0x47, 0x4d, 0xd1, 0x95, 0xb1, 0x33, 0xc4, 0xe6, 0x5d, 0x80, 0x15, 0xec, 0xae, - 0x61, 0xd7, 0x26, 0x0a, 0x7a, 0x31, 0x51, 0xde, 0x3e, 0x82, 0xb7, 0xd5, 0x0b, 0x13, 0xf1, 0xc4, - 0x06, 0xdf, 0x00, 0xe4, 0xc5, 0xf7, 0xc0, 0x5b, 0xa8, 0xf3, 0x63, 0x3b, 0xcf, 0xac, 0x4d, 0x3c, - 0x49, 0x31, 0x1e, 0x42, 0x73, 0x4d, 0x35, 0x47, 0xea, 0x20, 0xb0, 0xee, 0x95, 0x44, 0xc2, 0xa2, - 0x68, 0x29, 0xa2, 0x4a, 0xc5, 0x16, 0x87, 0xd9, 0x13, 0x01, 0x5c, 0x15, 0xf6, 0x8f, 0xa3, 0x8e, - 0xcd, 0xe7, 0x46, 0x04, 0x31, 0xc5, 0xb1, 0x8d, 0xc1, 0x17, 0x1b, 0x7f, 0x2c, 0xd1, 0x3f, 0x9c, - 0x44, 0x10, 0x1e, 0xe8, 0xee, 0xce, 0xfa, 0x40, 0x35, 0x9d, 0x2c, 0x24, 0x50, 0xc4, 0x03, 0x90, - 0xc0, 0xf1, 0x05, 0x09, 0x1a, 0xd4, 0x43, 0xcd, 0x58, 0x94, 0xf4, 0xa0, 0x29, 0xa9, 0xb3, 0xdc, - 0xbe, 0x34, 0x19, 0x51, 0xec, 0xb2, 0x03, 0x75, 0xcf, 0x58, 0x18, 0x73, 0x5f, 0x4c, 0xa3, 0xd4, - 0xc7, 0x49, 0xb1, 0xf5, 0x64, 0xd4, 0xa0, 0xad, 0xc7, 0x7b, 0x4d, 0x28, 0x5b, 0x8f, 0x72, 0x9c, - 0xad, 0xa7, 0x37, 0xb0, 0x98, 0x33, 0x8b, 0xf4, 0x75, 0x93, 0x3d, 0x65, 0x62, 0x9b, 0x3a, 0xd1, - 0x99, 0xa5, 0xb4, 0x89, 0xe5, 0x23, 0xe8, 0x01, 0x94, 0xf8, 0x3f, 0x4d, 0x9f, 0x1f, 0x5f, 0x79, - 0xf2, 0xd5, 0x2f, 0x4c, 0xc0, 0x12, 0x0b, 0xef, 0xc2, 0xf1, 0x94, 0xba, 0x33, 0x31, 0xc8, 0x8e, - 0xaf, 0x51, 0x27, 0x59, 0xb9, 0x0a, 0x28, 0xfe, 0x77, 0x8e, 0x44, 0x31, 0xa5, 0xfe, 0xeb, 0x23, - 0xc3, 0x16, 0xf1, 0x7f, 0x64, 0x24, 0x6e, 0x91, 0xfa, 0xc7, 0x8d, 0x49, 0x5b, 0xdc, 0x03, 0xf0, - 0xab, 0xcb, 0x44, 0x79, 0xc4, 0x8a, 0xcf, 0x09, 0x4b, 0x2e, 0xfe, 0x6b, 0x06, 0xca, 0xde, 0xf3, - 0xa1, 0x67, 0x50, 0x59, 0x3c, 0x83, 0x54, 0xff, 0x7d, 0x98, 0x8d, 0xfc, 0x0f, 0x21, 0xd1, 0x78, - 0x92, 0xff, 0xab, 0x30, 0x49, 0x42, 0x0f, 0xf8, 0x7f, 0xdb, 0x45, 0xd4, 0x7f, 0x21, 0xad, 0x5c, - 0x88, 0x06, 0xfc, 0x09, 0x0b, 0xff, 0x6f, 0x87, 0xf7, 0xbb, 0x00, 0x81, 0xf0, 0x3b, 0xfe, 0x42, - 0x99, 0x44, 0x94, 0x49, 0xdc, 0x5a, 0x3b, 0xa0, 0xd3, 0x9a, 0xb0, 0x9c, 0x43, 0x4c, 0x3b, 0xda, - 0x48, 0x4a, 0x31, 0xed, 0x94, 0xf6, 0x55, 0xa2, 0x93, 0x4f, 0xef, 0x4e, 0x3d, 0x15, 0x63, 0x5f, - 0xba, 0xfe, 0xcd, 0x57, 0xfb, 0xba, 0xbb, 0x33, 0xda, 0x22, 0x5f, 0xae, 0x31, 0xd4, 0x97, 0x75, - 0x8b, 0xff, 0xba, 0xe6, 0x29, 0xc3, 0x35, 0x3a, 0xfb, 0x1a, 0xd9, 0x63, 0xb8, 0xb5, 0x55, 0xa2, - 0xa3, 0xeb, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xf9, 0x60, 0xe6, 0x31, 0xbb, 0x42, 0x00, 0x00, + // 3847 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x3c, 0x5b, 0x6f, 0x1b, 0x47, + 0x77, 0x5e, 0xde, 0x44, 0x1e, 0x5e, 0x44, 0x8d, 0x1d, 0x89, 0xa6, 0x6d, 0xd9, 0x5e, 0xc7, 0x8e, + 0xed, 0x38, 0x76, 0x22, 0x37, 0x48, 0x50, 0xe7, 0x02, 0xcb, 0xb2, 0x65, 0xb6, 0x92, 0x2b, 0xaf, + 0xe4, 0x18, 0x68, 0x0a, 0x10, 0x2b, 0xee, 0x88, 0xda, 0x88, 0xbb, 0x4b, 0xef, 0x2e, 0x2d, 0x2b, + 0x7d, 0x48, 0xd0, 0x00, 0x05, 0x52, 0x14, 0x4d, 0xd1, 0xa2, 0x40, 0x0b, 0xb4, 0x40, 0xd1, 0xa7, + 0xb4, 0x40, 0x81, 0x02, 0x41, 0x1f, 0xda, 0x22, 0xef, 0x41, 0xfb, 0x50, 0xf4, 0xb1, 0xbf, 0xa0, + 0x7d, 0xfa, 0x7e, 0xc2, 0x87, 0x0f, 0x73, 0xd9, 0xd9, 0x3b, 0xb9, 0x22, 0xed, 0xf8, 0xc3, 0xf7, + 0xa6, 0x39, 0x7b, 0xce, 0xcc, 0x99, 0x33, 0xe7, 0x3e, 0x43, 0x41, 0x53, 0x53, 0x5d, 0xb5, 0xdb, + 0xb3, 0x2c, 0x5b, 0xbb, 0x39, 0xb4, 0x2d, 0xd7, 0x42, 0x0b, 0x86, 0x3e, 0x78, 0x3e, 0x72, 0xd8, + 0xe8, 0x26, 0xf9, 0xdc, 0xae, 0xf5, 0x2c, 0xc3, 0xb0, 0x4c, 0x06, 0x6a, 0x37, 0x74, 0xd3, 0xc5, + 0xb6, 0xa9, 0x0e, 0xf8, 0xb8, 0x16, 0x24, 0x68, 0xd7, 0x9c, 0xde, 0x3e, 0x36, 0x54, 0x36, 0x92, + 0xe7, 0xa0, 0x78, 0xdf, 0x18, 0xba, 0x47, 0xf2, 0x5f, 0x4b, 0x50, 0x7b, 0x30, 0x18, 0x39, 0xfb, + 0x0a, 0x7e, 0x36, 0xc2, 0x8e, 0x8b, 0xde, 0x85, 0xc2, 0xae, 0xea, 0xe0, 0x96, 0x74, 0x41, 0xba, + 0x5a, 0x5d, 0x39, 0x7b, 0x33, 0xb4, 0x2a, 0x5f, 0x6f, 0xd3, 0xe9, 0xaf, 0xaa, 0x0e, 0x56, 0x28, + 0x26, 0x42, 0x50, 0xd0, 0x76, 0x3b, 0x6b, 0xad, 0xdc, 0x05, 0xe9, 0x6a, 0x5e, 0xa1, 0x7f, 0xa3, + 0x65, 0x00, 0x07, 0xf7, 0x0d, 0x6c, 0xba, 0x9d, 0x35, 0xa7, 0x95, 0xbf, 0x90, 0xbf, 0x9a, 0x57, + 0x02, 0x10, 0x24, 0x43, 0xad, 0x67, 0x0d, 0x06, 0xb8, 0xe7, 0xea, 0x96, 0xd9, 0x59, 0x6b, 0x15, + 0x28, 0x6d, 0x08, 0x26, 0xff, 0xad, 0x04, 0x75, 0xce, 0x9a, 0x33, 0xb4, 0x4c, 0x07, 0xa3, 0xdb, + 0x50, 0x72, 0x5c, 0xd5, 0x1d, 0x39, 0x9c, 0xbb, 0x33, 0x89, 0xdc, 0x6d, 0x53, 0x14, 0x85, 0xa3, + 0x26, 0xb2, 0x17, 0x5d, 0x3e, 0x1f, 0x5f, 0x3e, 0xb2, 0x85, 0x42, 0x74, 0x0b, 0xf2, 0xff, 0x48, + 0xd0, 0xdc, 0xf6, 0x86, 0x9e, 0xf4, 0x4e, 0x41, 0xb1, 0x67, 0x8d, 0x4c, 0x97, 0x32, 0x58, 0x57, + 0xd8, 0x00, 0x5d, 0x84, 0x5a, 0x6f, 0x5f, 0x35, 0x4d, 0x3c, 0xe8, 0x9a, 0xaa, 0x81, 0x29, 0x2b, + 0x15, 0xa5, 0xca, 0x61, 0x8f, 0x54, 0x03, 0x67, 0xe2, 0xe8, 0x02, 0x54, 0x87, 0xaa, 0xed, 0xea, + 0x21, 0x99, 0x05, 0x41, 0xa8, 0x0d, 0x65, 0xdd, 0xe9, 0x18, 0x43, 0xcb, 0x76, 0x5b, 0xc5, 0x0b, + 0xd2, 0xd5, 0xb2, 0x22, 0xc6, 0x64, 0x05, 0x9d, 0xfe, 0xb5, 0xa3, 0x3a, 0x07, 0x9d, 0xb5, 0x56, + 0x89, 0xad, 0x10, 0x84, 0xc9, 0x7f, 0x2f, 0xc1, 0xe2, 0x5d, 0xc7, 0xd1, 0xfb, 0x66, 0x6c, 0x67, + 0x8b, 0x50, 0x32, 0x2d, 0x0d, 0x77, 0xd6, 0xe8, 0xd6, 0xf2, 0x0a, 0x1f, 0xa1, 0x33, 0x50, 0x19, + 0x62, 0x6c, 0x77, 0x6d, 0x6b, 0xe0, 0x6d, 0xac, 0x4c, 0x00, 0x8a, 0x35, 0xc0, 0xe8, 0x31, 0x2c, + 0x38, 0x91, 0x89, 0x98, 0x36, 0x54, 0x57, 0x2e, 0xdd, 0x8c, 0xe9, 0xf3, 0xcd, 0xe8, 0xa2, 0x4a, + 0x9c, 0x5a, 0xfe, 0x3a, 0x07, 0x27, 0x05, 0x1e, 0xe3, 0x95, 0xfc, 0x4d, 0x24, 0xef, 0xe0, 0xbe, + 0x60, 0x8f, 0x0d, 0xb2, 0x48, 0x5e, 0x1c, 0x59, 0x3e, 0x78, 0x64, 0x19, 0x14, 0x34, 0x7a, 0x1e, + 0xc5, 0xf8, 0x79, 0x9c, 0x87, 0x2a, 0x7e, 0x31, 0xd4, 0x6d, 0xdc, 0x75, 0x75, 0x03, 0x53, 0x91, + 0x17, 0x14, 0x60, 0xa0, 0x1d, 0xdd, 0x08, 0x6a, 0xf4, 0x5c, 0x66, 0x8d, 0x96, 0xff, 0x41, 0x82, + 0xa5, 0xd8, 0x29, 0x71, 0x13, 0x51, 0xa0, 0x49, 0x77, 0xee, 0x4b, 0x86, 0x18, 0x0b, 0x11, 0xf8, + 0x95, 0x71, 0x02, 0xf7, 0xd1, 0x95, 0x18, 0x7d, 0x80, 0xc9, 0x5c, 0x76, 0x26, 0x0f, 0x60, 0x69, + 0x1d, 0xbb, 0x7c, 0x01, 0xf2, 0x0d, 0x3b, 0xd3, 0xbb, 0x98, 0xb0, 0x2d, 0xe6, 0x62, 0xb6, 0xf8, + 0x2f, 0x39, 0x61, 0x8b, 0x74, 0xa9, 0x8e, 0xb9, 0x67, 0xa1, 0xb3, 0x50, 0x11, 0x28, 0x5c, 0x2b, + 0x7c, 0x00, 0xfa, 0x00, 0x8a, 0x84, 0x53, 0xa6, 0x12, 0x8d, 0x95, 0x8b, 0xc9, 0x7b, 0x0a, 0xcc, + 0xa9, 0x30, 0x7c, 0xd4, 0x81, 0x86, 0xe3, 0xaa, 0xb6, 0xdb, 0x1d, 0x5a, 0x0e, 0x3d, 0x67, 0xaa, + 0x38, 0xd5, 0x15, 0x39, 0x3c, 0x83, 0x70, 0xc6, 0x9b, 0x4e, 0x7f, 0x8b, 0x63, 0x2a, 0x75, 0x4a, + 0xe9, 0x0d, 0xd1, 0x7d, 0xa8, 0x61, 0x53, 0xf3, 0x27, 0x2a, 0x64, 0x9e, 0xa8, 0x8a, 0x4d, 0x4d, + 0x4c, 0xe3, 0x9f, 0x4f, 0x31, 0xfb, 0xf9, 0xfc, 0xa9, 0x04, 0xad, 0xf8, 0x01, 0xcd, 0xe2, 0x68, + 0xef, 0x30, 0x22, 0xcc, 0x0e, 0x68, 0xac, 0x85, 0x8b, 0x43, 0x52, 0x38, 0x89, 0xfc, 0x57, 0x12, + 0xbc, 0xe1, 0xb3, 0x43, 0x3f, 0xbd, 0x2a, 0x6d, 0x41, 0xd7, 0xa1, 0xa9, 0x9b, 0xbd, 0xc1, 0x48, + 0xc3, 0x4f, 0xcc, 0x87, 0x58, 0x1d, 0xb8, 0xfb, 0x47, 0xf4, 0x0c, 0xcb, 0x4a, 0x0c, 0x2e, 0x7f, + 0x23, 0xc1, 0x62, 0x94, 0xaf, 0x59, 0x84, 0xf4, 0x5b, 0x50, 0xd4, 0xcd, 0x3d, 0xcb, 0x93, 0xd1, + 0xf2, 0x18, 0xa3, 0x24, 0x6b, 0x31, 0x64, 0xd9, 0x80, 0x33, 0xeb, 0xd8, 0xed, 0x98, 0x0e, 0xb6, + 0xdd, 0x55, 0xdd, 0x1c, 0x58, 0xfd, 0x2d, 0xd5, 0xdd, 0x9f, 0xc1, 0xa0, 0x42, 0xb6, 0x91, 0x8b, + 0xd8, 0x86, 0xfc, 0xbd, 0x04, 0x67, 0x93, 0xd7, 0xe3, 0x5b, 0x6f, 0x43, 0x79, 0x4f, 0xc7, 0x03, + 0x8d, 0xc8, 0x57, 0xa2, 0xf2, 0x15, 0x63, 0x62, 0x58, 0x43, 0x82, 0xcc, 0x77, 0x78, 0x31, 0x45, + 0x9b, 0xb7, 0x5d, 0x5b, 0x37, 0xfb, 0x1b, 0xba, 0xe3, 0x2a, 0x0c, 0x3f, 0x20, 0xcf, 0x7c, 0x76, + 0x35, 0xfe, 0x13, 0x09, 0x96, 0xd7, 0xb1, 0x7b, 0x4f, 0xf8, 0x65, 0xf2, 0x5d, 0x77, 0x5c, 0xbd, + 0xe7, 0xbc, 0xdc, 0x8c, 0x26, 0x43, 0x80, 0x96, 0xbf, 0x93, 0xe0, 0x7c, 0x2a, 0x33, 0x5c, 0x74, + 0xdc, 0xef, 0x78, 0x5e, 0x39, 0xd9, 0xef, 0xfc, 0x2e, 0x3e, 0xfa, 0x4c, 0x1d, 0x8c, 0xf0, 0x96, + 0xaa, 0xdb, 0xcc, 0xef, 0x4c, 0xe9, 0x85, 0xff, 0x59, 0x82, 0x73, 0xeb, 0xd8, 0xdd, 0xf2, 0x62, + 0xd2, 0x6b, 0x94, 0x0e, 0xc1, 0x09, 0xc4, 0x46, 0x2f, 0xa5, 0x0a, 0xc1, 0xe4, 0x3f, 0x63, 0xc7, + 0x99, 0xc8, 0xef, 0x6b, 0x11, 0xe0, 0x32, 0xb5, 0x84, 0x80, 0x49, 0xde, 0x63, 0xa9, 0x03, 0x17, + 0x9f, 0xfc, 0x77, 0x12, 0x9c, 0xbe, 0xdb, 0x7b, 0x36, 0xd2, 0x6d, 0xcc, 0x91, 0x36, 0xac, 0xde, + 0xc1, 0xf4, 0xc2, 0xf5, 0xd3, 0xac, 0x5c, 0x28, 0xcd, 0x9a, 0x94, 0x50, 0x2f, 0x42, 0xc9, 0x65, + 0x79, 0x1d, 0xcb, 0x54, 0xf8, 0x88, 0xf2, 0xa7, 0xe0, 0x01, 0x56, 0x9d, 0x5f, 0x4f, 0xfe, 0xbe, + 0x2b, 0x40, 0xed, 0x33, 0x9e, 0x8e, 0xd1, 0xa8, 0x1d, 0xd5, 0x24, 0x29, 0x39, 0xf1, 0x0a, 0x64, + 0x70, 0x49, 0x49, 0xdd, 0x3a, 0xd4, 0x1d, 0x8c, 0x0f, 0xa6, 0x89, 0xd1, 0x35, 0x42, 0x28, 0x62, + 0xeb, 0x06, 0x2c, 0x8c, 0xcc, 0x3d, 0x52, 0x85, 0x60, 0x8d, 0x0b, 0x90, 0x69, 0xee, 0x64, 0xdf, + 0x1d, 0x27, 0x44, 0x0f, 0x61, 0x3e, 0x3a, 0x57, 0x31, 0xd3, 0x5c, 0x51, 0x32, 0xd4, 0x81, 0xa6, + 0x66, 0x5b, 0xc3, 0x21, 0xd6, 0xba, 0x8e, 0x37, 0x55, 0x29, 0xdb, 0x54, 0x9c, 0x4e, 0x4c, 0xf5, + 0x2e, 0x9c, 0x8c, 0x72, 0xda, 0xd1, 0x48, 0x42, 0x4a, 0xce, 0x30, 0xe9, 0x13, 0xba, 0x01, 0x0b, + 0x71, 0xfc, 0x32, 0xc5, 0x8f, 0x7f, 0x40, 0xef, 0x00, 0x8a, 0xb0, 0x4a, 0xd0, 0x2b, 0x0c, 0x3d, + 0xcc, 0x4c, 0x47, 0x73, 0xe4, 0x6f, 0x25, 0x58, 0x7c, 0xaa, 0xba, 0xbd, 0xfd, 0x35, 0x83, 0xdb, + 0xda, 0x0c, 0xbe, 0xea, 0x63, 0xa8, 0x3c, 0xe7, 0x7a, 0xe1, 0x05, 0xa4, 0xf3, 0x09, 0xf2, 0x09, + 0x6a, 0xa0, 0xe2, 0x53, 0xc8, 0x3f, 0x49, 0x70, 0x8a, 0x96, 0xa0, 0x9e, 0xb0, 0x7e, 0x7e, 0xaf, + 0x39, 0xa1, 0x0c, 0x45, 0x57, 0xa0, 0x61, 0xa8, 0xf6, 0xc1, 0xb6, 0x8f, 0x53, 0xa4, 0x38, 0x11, + 0xa8, 0xfc, 0x02, 0x80, 0x8f, 0x36, 0x9d, 0xfe, 0x14, 0xfc, 0x7f, 0x08, 0x73, 0x7c, 0x55, 0xee, + 0x3e, 0x27, 0xe9, 0x99, 0x87, 0x2e, 0xff, 0xa7, 0x04, 0x0d, 0x3f, 0x24, 0x52, 0x23, 0x6f, 0x40, + 0x4e, 0x98, 0x76, 0xae, 0xb3, 0x86, 0x3e, 0x86, 0x12, 0x6b, 0x4f, 0xf0, 0xb9, 0x2f, 0x87, 0xe7, + 0xe6, 0xad, 0x8b, 0x40, 0x5c, 0xa5, 0x00, 0x85, 0x13, 0x11, 0x19, 0x89, 0x28, 0x22, 0x9c, 0x8f, + 0x0f, 0x41, 0x1d, 0x98, 0x0f, 0xa7, 0xec, 0x9e, 0x09, 0x5f, 0x48, 0x0b, 0x1e, 0x6b, 0xaa, 0xab, + 0xd2, 0xd8, 0xd1, 0x08, 0x65, 0xec, 0x8e, 0xfc, 0x8b, 0x22, 0x54, 0x03, 0xbb, 0x8c, 0xed, 0x24, + 0x7a, 0xa4, 0xb9, 0xc9, 0x75, 0x63, 0x3e, 0x5e, 0x37, 0x5e, 0x86, 0x86, 0x4e, 0x93, 0xaf, 0x2e, + 0x57, 0x45, 0xea, 0x35, 0x2b, 0x4a, 0x9d, 0x41, 0xb9, 0x5d, 0xa0, 0x65, 0xa8, 0x9a, 0x23, 0xa3, + 0x6b, 0xed, 0x75, 0x6d, 0xeb, 0xd0, 0xe1, 0x05, 0x68, 0xc5, 0x1c, 0x19, 0xbf, 0xb7, 0xa7, 0x58, + 0x87, 0x8e, 0x5f, 0xe3, 0x94, 0x8e, 0x59, 0xe3, 0x2c, 0x43, 0xd5, 0x50, 0x5f, 0x90, 0x59, 0xbb, + 0xe6, 0xc8, 0xa0, 0xb5, 0x69, 0x5e, 0xa9, 0x18, 0xea, 0x0b, 0xc5, 0x3a, 0x7c, 0x34, 0x32, 0xd0, + 0x55, 0x68, 0x0e, 0x54, 0xc7, 0xed, 0x06, 0x8b, 0xdb, 0x32, 0x2d, 0x6e, 0x1b, 0x04, 0x7e, 0xdf, + 0x2f, 0x70, 0xe3, 0xd5, 0x52, 0x65, 0x86, 0x6a, 0x49, 0x33, 0x06, 0xfe, 0x44, 0x90, 0xbd, 0x5a, + 0xd2, 0x8c, 0x81, 0x98, 0xe6, 0x43, 0x98, 0xdb, 0xa5, 0x29, 0xad, 0xd3, 0xaa, 0xa6, 0x3a, 0xcc, + 0x07, 0x24, 0x9b, 0x65, 0x99, 0xaf, 0xe2, 0xa1, 0xa3, 0x8f, 0xa0, 0x42, 0x33, 0x09, 0x4a, 0x5b, + 0xcb, 0x44, 0xeb, 0x13, 0x10, 0x6a, 0x0d, 0x0f, 0x5c, 0x95, 0x52, 0xd7, 0xb3, 0x51, 0x0b, 0x02, + 0xe2, 0xa4, 0x7b, 0x36, 0x56, 0x5d, 0xac, 0xad, 0x1e, 0xdd, 0xb3, 0x8c, 0xa1, 0x4a, 0x95, 0xa9, + 0xd5, 0xa0, 0x65, 0x4b, 0xd2, 0x27, 0xe2, 0x18, 0x7a, 0x62, 0xf4, 0xc0, 0xb6, 0x8c, 0xd6, 0x3c, + 0x73, 0x0c, 0x61, 0x28, 0x3a, 0x07, 0xe0, 0xb9, 0x67, 0xd5, 0x6d, 0x35, 0xe9, 0x29, 0x56, 0x38, + 0xe4, 0xae, 0x2b, 0x7f, 0x05, 0xa7, 0x7c, 0x0d, 0x09, 0x9c, 0x46, 0xfc, 0x60, 0xa5, 0x69, 0x0f, + 0x76, 0x7c, 0x31, 0xf2, 0xdf, 0x05, 0x58, 0xdc, 0x56, 0x9f, 0xe3, 0x57, 0x5f, 0xf7, 0x64, 0xf2, + 0xc7, 0x1b, 0xb0, 0x40, 0x4b, 0x9d, 0x95, 0x00, 0x3f, 0x63, 0x12, 0x82, 0xe0, 0x71, 0xc6, 0x09, + 0xd1, 0xa7, 0x24, 0x93, 0xc1, 0xbd, 0x83, 0x2d, 0x4b, 0xf7, 0x93, 0x81, 0x73, 0x09, 0xf3, 0xdc, + 0x13, 0x58, 0x4a, 0x90, 0x02, 0x6d, 0xc5, 0x5d, 0x1b, 0x4b, 0x03, 0xde, 0x1a, 0x5b, 0x7d, 0xfb, + 0xd2, 0x8f, 0x7a, 0x38, 0xd4, 0x82, 0x39, 0x1e, 0xc3, 0xa9, 0xdd, 0x97, 0x15, 0x6f, 0x88, 0xb6, + 0xe0, 0x24, 0xdb, 0xc1, 0x36, 0x57, 0x6a, 0xb6, 0xf9, 0x72, 0xa6, 0xcd, 0x27, 0x91, 0x86, 0x6d, + 0xa2, 0x72, 0x5c, 0x9b, 0x68, 0xc1, 0x1c, 0xd7, 0x53, 0xea, 0x0b, 0xca, 0x8a, 0x37, 0x24, 0xc7, + 0xcc, 0xfa, 0x9a, 0xba, 0xd9, 0x6f, 0x55, 0xe9, 0x37, 0x1f, 0x40, 0x6a, 0x46, 0xf0, 0xe5, 0x39, + 0xa1, 0x4f, 0xf4, 0x09, 0x94, 0x85, 0x86, 0xe7, 0x32, 0x6b, 0xb8, 0xa0, 0x89, 0xfa, 0xe8, 0x7c, + 0xc4, 0x47, 0xcb, 0xff, 0x25, 0x41, 0x6d, 0x8d, 0x6c, 0x69, 0xc3, 0xea, 0xd3, 0x88, 0x72, 0x19, + 0x1a, 0x36, 0xee, 0x59, 0xb6, 0xd6, 0xc5, 0xa6, 0x6b, 0xeb, 0x98, 0xb5, 0x17, 0x0a, 0x4a, 0x9d, + 0x41, 0xef, 0x33, 0x20, 0x41, 0x23, 0x6e, 0xd7, 0x71, 0x55, 0x63, 0xd8, 0xdd, 0x23, 0xe6, 0x9d, + 0x63, 0x68, 0x02, 0x4a, 0xad, 0xfb, 0x22, 0xd4, 0x7c, 0x34, 0xd7, 0xa2, 0xeb, 0x17, 0x94, 0xaa, + 0x80, 0xed, 0x58, 0xe8, 0x4d, 0x68, 0x50, 0x99, 0x76, 0x07, 0x56, 0xbf, 0x4b, 0x4a, 0x71, 0x1e, + 0x6c, 0x6a, 0x1a, 0x67, 0x8b, 0x9c, 0x55, 0x18, 0xcb, 0xd1, 0xbf, 0xc4, 0x3c, 0xdc, 0x08, 0xac, + 0x6d, 0xfd, 0x4b, 0x4c, 0x62, 0x7d, 0x9d, 0xc4, 0xce, 0x47, 0x96, 0x86, 0x77, 0xa6, 0xcc, 0x34, + 0x32, 0xf4, 0x6c, 0xcf, 0x42, 0x45, 0xec, 0x80, 0x6f, 0xc9, 0x07, 0xa0, 0x07, 0xd0, 0xf0, 0x72, + 0xe2, 0x2e, 0x2b, 0x15, 0x0b, 0xa9, 0x99, 0x5f, 0x20, 0xfa, 0x39, 0x4a, 0xdd, 0x23, 0xa3, 0x43, + 0xf9, 0x01, 0xd4, 0x82, 0x9f, 0xc9, 0xaa, 0xdb, 0x51, 0x45, 0x11, 0x00, 0xa2, 0x8d, 0x8f, 0x46, + 0x06, 0x39, 0x53, 0xee, 0x58, 0xbc, 0xa1, 0xfc, 0x8d, 0x04, 0x75, 0x1e, 0xb2, 0xb7, 0xc5, 0x9d, + 0x04, 0xdd, 0x9a, 0x44, 0xb7, 0x46, 0xff, 0x46, 0xbf, 0x1d, 0x6e, 0x48, 0xbe, 0x99, 0xe8, 0x04, + 0xe8, 0x24, 0x34, 0x3b, 0x0e, 0xc5, 0xeb, 0x2c, 0xcd, 0x89, 0xaf, 0x89, 0xa2, 0xf1, 0xa3, 0xa1, + 0x8a, 0xd6, 0x82, 0x39, 0x55, 0xd3, 0x6c, 0xec, 0x38, 0x9c, 0x0f, 0x6f, 0x48, 0xbe, 0x3c, 0xc7, + 0xb6, 0xe3, 0xa9, 0x7c, 0x5e, 0xf1, 0x86, 0xe8, 0x23, 0x28, 0x8b, 0x74, 0x3a, 0x9f, 0x94, 0x42, + 0x05, 0xf9, 0xe4, 0xa5, 0xb4, 0xa0, 0x90, 0xff, 0x35, 0x07, 0x0d, 0x2e, 0xb0, 0x55, 0x1e, 0x53, + 0xc7, 0x1b, 0xdf, 0x2a, 0xd4, 0xf6, 0x7c, 0xdb, 0x1f, 0xd7, 0x34, 0x0b, 0xba, 0x88, 0x10, 0xcd, + 0x24, 0x03, 0x0c, 0x47, 0xf5, 0xc2, 0x4c, 0x51, 0xbd, 0x78, 0x5c, 0x0f, 0x16, 0xcf, 0xf3, 0x4a, + 0x09, 0x79, 0x9e, 0xfc, 0x07, 0x50, 0x0d, 0x4c, 0x40, 0x3d, 0x34, 0xeb, 0xb6, 0x71, 0x89, 0x79, + 0x43, 0x74, 0xdb, 0xcf, 0x6d, 0x98, 0xa8, 0x4e, 0x27, 0xf0, 0x12, 0x49, 0x6b, 0xe4, 0x7f, 0x94, + 0xa0, 0xc4, 0x67, 0x3e, 0x0f, 0x55, 0xee, 0x74, 0x68, 0xde, 0xc7, 0x66, 0x07, 0x0e, 0x22, 0x89, + 0xdf, 0xcb, 0xf3, 0x3a, 0xa7, 0xa1, 0x1c, 0xf1, 0x37, 0x73, 0x3c, 0x2c, 0x78, 0x9f, 0x02, 0x4e, + 0x86, 0x7c, 0xa2, 0xfe, 0xe5, 0x27, 0x89, 0x5e, 0x2b, 0x28, 0xb8, 0x67, 0x3d, 0xc7, 0xf6, 0xd1, + 0xec, 0xfd, 0xd8, 0x3b, 0x01, 0x85, 0xce, 0x58, 0x1f, 0x0a, 0x02, 0x74, 0xc7, 0x17, 0x77, 0x3e, + 0xa9, 0x19, 0x15, 0xf4, 0x30, 0x5c, 0x1d, 0x7d, 0xb1, 0xff, 0x39, 0xeb, 0x2c, 0x87, 0xb7, 0x32, + 0x6d, 0x5e, 0xf3, 0x52, 0xca, 0x0e, 0xf9, 0x2f, 0x25, 0x38, 0xbd, 0x8e, 0xdd, 0x07, 0xe1, 0x5e, + 0xc3, 0xeb, 0xe6, 0xca, 0x80, 0x76, 0x12, 0x53, 0xb3, 0x9c, 0x7a, 0x1b, 0xca, 0xa2, 0x6b, 0xc2, + 0xee, 0x07, 0xc4, 0x58, 0xfe, 0x63, 0x09, 0x5a, 0x7c, 0x15, 0xba, 0x26, 0x49, 0xa9, 0x07, 0xd8, + 0xc5, 0xda, 0xcf, 0x5d, 0x37, 0xff, 0x28, 0x41, 0x33, 0xe8, 0xf1, 0xa9, 0xd3, 0x7e, 0x1f, 0x8a, + 0xb4, 0x3d, 0xc1, 0x39, 0x98, 0xa8, 0xac, 0x0c, 0x9b, 0xb8, 0x0c, 0x9a, 0xe6, 0xed, 0x88, 0xe0, + 0xc4, 0x87, 0x7e, 0xd8, 0xc9, 0x1f, 0x3f, 0xec, 0xf0, 0x30, 0x6c, 0x8d, 0xc8, 0xbc, 0xac, 0xaf, + 0xe7, 0x03, 0xe4, 0xdf, 0x81, 0x45, 0xbf, 0x1c, 0x61, 0x74, 0xd3, 0x6a, 0x92, 0xfc, 0x43, 0x0e, + 0x5a, 0x81, 0xc9, 0x7e, 0xee, 0x18, 0x92, 0x92, 0xf9, 0xe6, 0x5f, 0x52, 0xe6, 0x5b, 0x98, 0x3d, + 0x6e, 0x14, 0x93, 0xe2, 0xc6, 0x7f, 0xe4, 0xa0, 0xe1, 0x4b, 0x6d, 0x6b, 0xa0, 0x9a, 0x68, 0x11, + 0x4a, 0xc3, 0x81, 0xea, 0x37, 0x56, 0xf9, 0x08, 0x6d, 0x8b, 0x9c, 0x29, 0x2c, 0xa7, 0xb7, 0x93, + 0xf4, 0x21, 0xe5, 0x20, 0x94, 0xc8, 0x14, 0xa4, 0xb4, 0x64, 0xc5, 0x09, 0x6d, 0x10, 0xf0, 0x3c, + 0x8d, 0x29, 0x9e, 0x6e, 0x60, 0x74, 0x03, 0x10, 0xd7, 0x96, 0xae, 0x6e, 0x76, 0x1d, 0xdc, 0xb3, + 0x4c, 0x8d, 0xe9, 0x51, 0x51, 0x69, 0xf2, 0x2f, 0x1d, 0x73, 0x9b, 0xc1, 0xd1, 0xfb, 0x50, 0x70, + 0x8f, 0x86, 0x2c, 0x22, 0x34, 0x12, 0x3d, 0xad, 0xcf, 0xd7, 0xce, 0xd1, 0x10, 0x2b, 0x14, 0x1d, + 0x2d, 0x03, 0x90, 0xa9, 0x5c, 0x5b, 0x7d, 0xce, 0xc3, 0x6b, 0x41, 0x09, 0x40, 0x88, 0x65, 0x78, + 0x32, 0x9c, 0x63, 0x61, 0x88, 0x0f, 0xe5, 0x7f, 0xcb, 0x41, 0xd3, 0x9f, 0x52, 0xc1, 0xce, 0x68, + 0xe0, 0xa6, 0xca, 0x6f, 0x7c, 0x61, 0x39, 0x29, 0x07, 0xf9, 0x14, 0xaa, 0xfc, 0x3c, 0x8f, 0xa1, + 0x0f, 0xc0, 0x48, 0x36, 0xc6, 0x28, 0x68, 0xf1, 0x25, 0x29, 0x68, 0xe9, 0x98, 0x0a, 0x2a, 0x7f, + 0x2f, 0xc1, 0x1b, 0x31, 0xe3, 0x1f, 0x2b, 0xc0, 0xf1, 0xe9, 0x2f, 0x77, 0x0a, 0xd1, 0x29, 0xb9, + 0x1f, 0xba, 0x03, 0x25, 0x9b, 0xce, 0xce, 0xdb, 0xfc, 0x97, 0xc6, 0x2a, 0x07, 0x63, 0x44, 0xe1, + 0x24, 0xf2, 0x5f, 0x48, 0xb0, 0x14, 0x67, 0x75, 0x86, 0xe0, 0xb2, 0x0a, 0x73, 0x6c, 0x6a, 0xcf, + 0x86, 0xae, 0x8e, 0xb7, 0x21, 0x5f, 0x38, 0x8a, 0x47, 0x28, 0x6f, 0xc3, 0xa2, 0x17, 0x83, 0x7c, + 0x01, 0x6f, 0x62, 0x57, 0x1d, 0x93, 0xfc, 0x9d, 0x87, 0x2a, 0xcb, 0x2d, 0x58, 0x52, 0xc5, 0xca, + 0x26, 0xd8, 0x15, 0xdd, 0x06, 0x92, 0xe8, 0x9d, 0xa2, 0x4e, 0x3c, 0xda, 0x57, 0xcf, 0x72, 0xe7, + 0x22, 0x8b, 0xaa, 0x8c, 0x54, 0x60, 0x6c, 0x6b, 0x15, 0x25, 0x04, 0x4b, 0xea, 0xb3, 0xe6, 0xa7, + 0xec, 0xb3, 0x6e, 0xc0, 0x1b, 0x11, 0x56, 0x67, 0x38, 0x12, 0xb2, 0xf3, 0xc5, 0xed, 0xf0, 0x63, + 0x87, 0xe9, 0xb3, 0x9a, 0x73, 0xa2, 0x23, 0xdf, 0xd5, 0xb5, 0xa8, 0xad, 0x6b, 0xe8, 0x13, 0xa8, + 0x98, 0xf8, 0xb0, 0x1b, 0x0c, 0xaa, 0x19, 0x1a, 0xaf, 0x65, 0x13, 0x1f, 0xd2, 0xbf, 0xe4, 0x47, + 0xb0, 0x14, 0x63, 0x75, 0x96, 0xbd, 0xff, 0xbb, 0x04, 0xa7, 0xd7, 0x6c, 0x6b, 0xf8, 0x99, 0x6e, + 0xbb, 0x23, 0x75, 0x10, 0xbe, 0xbf, 0x7c, 0x35, 0xe5, 0xf9, 0xc3, 0x40, 0x7a, 0xc5, 0x14, 0xe0, + 0x46, 0x82, 0x09, 0xc4, 0x99, 0xe2, 0x9b, 0x0e, 0x24, 0x63, 0xff, 0x97, 0x4f, 0x62, 0x9e, 0xe3, + 0x4d, 0x08, 0xfc, 0x59, 0xb2, 0xcf, 0xc4, 0x6e, 0x5e, 0x7e, 0xda, 0x6e, 0x5e, 0x8a, 0x17, 0x2e, + 0xbc, 0x24, 0x2f, 0x7c, 0xec, 0xf2, 0xf2, 0x21, 0x84, 0x3b, 0xad, 0x34, 0xfc, 0x4d, 0xd5, 0xa2, + 0x5d, 0x05, 0xf0, 0xbb, 0x8e, 0xfc, 0xad, 0x5a, 0x96, 0x69, 0x02, 0x54, 0xe4, 0xb4, 0x44, 0xc4, + 0xa3, 0xb7, 0x05, 0xa1, 0x3e, 0xd8, 0x63, 0x68, 0x27, 0x69, 0xe9, 0x2c, 0x9a, 0xff, 0x43, 0x0e, + 0xa0, 0x23, 0x9e, 0x37, 0x4e, 0xe7, 0xcc, 0x2f, 0x41, 0xdd, 0x57, 0x18, 0xdf, 0xde, 0x83, 0x5a, + 0xa4, 0x11, 0x93, 0x10, 0x05, 0x0b, 0xc1, 0x89, 0x15, 0x31, 0x1a, 0x9d, 0x27, 0x60, 0x35, 0x4c, + 0x29, 0xa2, 0xfe, 0xf3, 0x0c, 0x54, 0x6c, 0xeb, 0xb0, 0x4b, 0xcc, 0x4c, 0xf3, 0xde, 0x6f, 0xda, + 0xd6, 0x21, 0x31, 0x3e, 0x0d, 0x2d, 0xc1, 0x9c, 0xab, 0x3a, 0x07, 0x64, 0xfe, 0x52, 0xe0, 0x0a, + 0x5d, 0x43, 0xa7, 0xa0, 0xb8, 0xa7, 0x0f, 0x30, 0xbb, 0xb1, 0xad, 0x28, 0x6c, 0x80, 0x3e, 0xf0, + 0x1e, 0x1a, 0x95, 0x33, 0x3f, 0x93, 0x60, 0x6f, 0x8d, 0x7e, 0x92, 0x60, 0xde, 0x97, 0x1a, 0x75, + 0x40, 0xc4, 0xa7, 0x51, 0x7f, 0x76, 0xcf, 0xd2, 0x98, 0xab, 0x68, 0xa4, 0xb8, 0x74, 0x46, 0xc8, + 0xbc, 0x96, 0x4f, 0x32, 0xae, 0xde, 0x22, 0xfb, 0x22, 0x9b, 0xd6, 0x35, 0xef, 0xe6, 0xae, 0x64, + 0x5b, 0x87, 0x1d, 0x4d, 0x48, 0x83, 0x3d, 0xce, 0x64, 0xd5, 0x05, 0x91, 0xc6, 0x3d, 0xfa, 0x3e, + 0xf3, 0x12, 0xd4, 0xb1, 0x6d, 0x5b, 0x76, 0xd7, 0xc0, 0x8e, 0xa3, 0xf6, 0x31, 0x4f, 0x80, 0x6b, + 0x14, 0xb8, 0xc9, 0x60, 0xf2, 0x8f, 0x79, 0x68, 0xf8, 0x5b, 0xf1, 0xee, 0xeb, 0x74, 0xcd, 0xbb, + 0xaf, 0xd3, 0xc9, 0xd1, 0x81, 0xcd, 0x5c, 0xa1, 0x38, 0xdc, 0xd5, 0x5c, 0x4b, 0x52, 0x2a, 0x1c, + 0xda, 0xd1, 0x48, 0x5c, 0x25, 0x46, 0x66, 0x5a, 0x1a, 0xf6, 0x0f, 0x17, 0x3c, 0x10, 0x3f, 0xdb, + 0x90, 0x8e, 0x14, 0x32, 0xe8, 0x48, 0x31, 0x83, 0x8e, 0x94, 0x12, 0x74, 0x64, 0x11, 0x4a, 0xbb, + 0xa3, 0xde, 0x01, 0x76, 0x79, 0xba, 0xca, 0x47, 0x61, 0xdd, 0x29, 0x47, 0x74, 0x47, 0xa8, 0x48, + 0x25, 0xa8, 0x22, 0x67, 0xa0, 0xc2, 0x2e, 0x8e, 0xba, 0xae, 0x43, 0x3b, 0xe8, 0x79, 0xa5, 0xcc, + 0x00, 0x3b, 0x0e, 0xfa, 0xd0, 0xcb, 0xc7, 0xaa, 0x49, 0xc6, 0x4e, 0xbd, 0x4e, 0x44, 0x4b, 0xbc, + 0x6c, 0xec, 0x32, 0x34, 0xe8, 0xe3, 0xf5, 0x67, 0x23, 0x6c, 0x1f, 0xa9, 0xbb, 0x03, 0xdc, 0xaa, + 0x51, 0x76, 0xea, 0x04, 0xfa, 0xd8, 0x03, 0x12, 0x81, 0x50, 0x34, 0xdd, 0xd4, 0xf0, 0x0b, 0xac, + 0xb5, 0xea, 0x14, 0x89, 0x8a, 0xba, 0xc3, 0x40, 0xf2, 0x17, 0x80, 0xfc, 0x35, 0x66, 0x4b, 0xca, + 0x22, 0x87, 0x98, 0x8b, 0x1e, 0xa2, 0xfc, 0x4f, 0x12, 0x2c, 0x04, 0x17, 0x9b, 0x36, 0x3c, 0x7e, + 0x02, 0x55, 0x76, 0xd3, 0xd0, 0x25, 0xe6, 0xc9, 0x6b, 0xfe, 0x73, 0x63, 0xa5, 0xa7, 0x80, 0xff, + 0x08, 0x9b, 0x28, 0xc1, 0xa1, 0x65, 0x1f, 0xe8, 0x66, 0xbf, 0x4b, 0x38, 0xf3, 0x8c, 0xa2, 0xc6, + 0x81, 0x8f, 0x08, 0x4c, 0xfe, 0x56, 0x82, 0xe5, 0x27, 0x43, 0x4d, 0x75, 0x71, 0x20, 0x4f, 0x98, + 0xf5, 0x5d, 0xd7, 0xfb, 0xde, 0xc3, 0xaa, 0x5c, 0xb6, 0x6e, 0x39, 0xc3, 0x96, 0x37, 0xe1, 0xb4, + 0x82, 0x1d, 0x6c, 0x6a, 0xa1, 0x8f, 0x53, 0x57, 0xfa, 0x43, 0x68, 0x27, 0x4d, 0x37, 0xcb, 0xd9, + 0xb3, 0x84, 0xad, 0x6b, 0x93, 0x69, 0x5d, 0xee, 0x7f, 0x48, 0x9e, 0x40, 0xd7, 0x71, 0xe5, 0xff, + 0x97, 0x60, 0xe1, 0xae, 0xe6, 0xad, 0xf7, 0xca, 0xf2, 0xc2, 0x68, 0xde, 0x94, 0x8f, 0xe7, 0x4d, + 0x2f, 0xcb, 0x91, 0x70, 0x97, 0x6a, 0x8e, 0x0c, 0x2f, 0x54, 0xd8, 0xf4, 0xde, 0x5e, 0xde, 0x13, + 0x97, 0xb9, 0x0a, 0xde, 0xc3, 0x36, 0x36, 0x7b, 0x78, 0xc3, 0xea, 0x1d, 0x04, 0x5e, 0x67, 0x49, + 0xc1, 0xd7, 0x59, 0xd3, 0xbe, 0xf6, 0xba, 0xfe, 0x37, 0x12, 0x2c, 0xc4, 0xba, 0x46, 0xa8, 0x01, + 0xf0, 0xc4, 0xec, 0xf1, 0x76, 0x5a, 0xf3, 0x04, 0xaa, 0x41, 0xd9, 0x6b, 0xae, 0x35, 0x25, 0x54, + 0x85, 0xb9, 0x1d, 0x8b, 0x62, 0x37, 0x73, 0xa8, 0x09, 0x35, 0x46, 0x38, 0xea, 0xf5, 0xb0, 0xe3, + 0x34, 0xf3, 0x02, 0xf2, 0x40, 0xd5, 0x07, 0x23, 0x1b, 0x37, 0x0b, 0xa8, 0x0e, 0x95, 0x1d, 0x8b, + 0xbf, 0x6d, 0x6b, 0x16, 0x11, 0x82, 0x86, 0xf7, 0xd0, 0x8d, 0x13, 0x95, 0x02, 0x30, 0x8f, 0x6c, + 0xee, 0xfa, 0x5e, 0xb0, 0x27, 0xb2, 0x73, 0x34, 0xc4, 0x68, 0x09, 0x4e, 0x3e, 0x31, 0x35, 0xbc, + 0xa7, 0x9b, 0x58, 0xf3, 0x3f, 0x35, 0x4f, 0xa0, 0x93, 0x30, 0xdf, 0x31, 0x4d, 0x6c, 0x07, 0x80, + 0x12, 0x01, 0x6e, 0x62, 0xbb, 0x8f, 0x03, 0xc0, 0x1c, 0x5a, 0x80, 0xfa, 0xa6, 0xfe, 0x22, 0x00, + 0xca, 0xaf, 0xfc, 0x72, 0x09, 0x2a, 0xa4, 0xbc, 0xb9, 0x67, 0x59, 0xb6, 0x86, 0x86, 0x80, 0xe8, + 0xcb, 0x50, 0x63, 0x68, 0x99, 0xe2, 0xbd, 0x35, 0x7a, 0x37, 0x25, 0x85, 0x8a, 0xa3, 0x72, 0xb5, + 0x6c, 0x5f, 0x49, 0xa1, 0x88, 0xa0, 0xcb, 0x27, 0x90, 0x41, 0x57, 0xdc, 0xd1, 0x0d, 0xbc, 0xa3, + 0xf7, 0x0e, 0xbc, 0x27, 0x23, 0x63, 0x56, 0x8c, 0xa0, 0x7a, 0x2b, 0x46, 0x8a, 0x69, 0x3e, 0x60, + 0xcf, 0x77, 0x3d, 0xbb, 0x94, 0x4f, 0xa0, 0x67, 0x70, 0x6a, 0x1d, 0x07, 0xfc, 0x90, 0xb7, 0xe0, + 0x4a, 0xfa, 0x82, 0x31, 0xe4, 0x63, 0x2e, 0xb9, 0x01, 0x45, 0xda, 0xa1, 0x45, 0x49, 0xae, 0x2a, + 0xf8, 0xa3, 0xa6, 0xf6, 0x85, 0x74, 0x04, 0x31, 0xdb, 0x17, 0x30, 0x1f, 0xf9, 0x51, 0x05, 0xba, + 0x96, 0x40, 0x96, 0xfc, 0xf3, 0x98, 0xf6, 0xf5, 0x2c, 0xa8, 0x62, 0xad, 0x3e, 0x34, 0xc2, 0xaf, + 0x4a, 0x51, 0x52, 0x8f, 0x20, 0xf1, 0x3d, 0x7c, 0xfb, 0x5a, 0x06, 0x4c, 0xb1, 0x90, 0x01, 0xcd, + 0xe8, 0x23, 0x7f, 0x74, 0x7d, 0xec, 0x04, 0x61, 0x75, 0x7b, 0x3b, 0x13, 0xae, 0x58, 0xee, 0x88, + 0x2a, 0x41, 0xec, 0xdd, 0x38, 0xba, 0x99, 0x3c, 0x4d, 0xda, 0x83, 0xf6, 0xf6, 0xad, 0xcc, 0xf8, + 0x62, 0xe9, 0x3f, 0x62, 0x37, 0x43, 0x49, 0x6f, 0xaf, 0xd1, 0x7b, 0xc9, 0xd3, 0x8d, 0x79, 0x34, + 0xde, 0x5e, 0x39, 0x0e, 0x89, 0x60, 0xe2, 0x2b, 0x7a, 0xa5, 0x93, 0xf0, 0x7a, 0x39, 0x6a, 0x77, + 0xde, 0x7c, 0xe9, 0x0f, 0xb3, 0xdb, 0xef, 0x1d, 0x83, 0x42, 0x30, 0x60, 0x45, 0x7f, 0x45, 0xe1, + 0x99, 0xe1, 0xad, 0x89, 0x5a, 0x33, 0x9d, 0x0d, 0x7e, 0x0e, 0xf3, 0x91, 0xc7, 0x39, 0x89, 0x56, + 0x93, 0xfc, 0x80, 0xa7, 0x3d, 0x2e, 0x7c, 0x33, 0x93, 0x8c, 0xdc, 0x90, 0xa1, 0x14, 0xed, 0x4f, + 0xb8, 0x45, 0x6b, 0x5f, 0xcf, 0x82, 0x2a, 0x36, 0xe2, 0x50, 0x77, 0x19, 0xb9, 0x65, 0x42, 0x37, + 0x92, 0xe7, 0x48, 0xbe, 0x21, 0x6b, 0xbf, 0x93, 0x11, 0x5b, 0x2c, 0xfa, 0x87, 0x80, 0xb6, 0xf7, + 0x49, 0x49, 0x63, 0xee, 0xe9, 0xfd, 0x91, 0xad, 0xb2, 0x17, 0x38, 0x69, 0x3e, 0x3a, 0x8e, 0x9a, + 0xa2, 0x2b, 0x63, 0x29, 0xc4, 0xe2, 0x5d, 0x80, 0x75, 0xec, 0x6e, 0x62, 0xd7, 0x26, 0x0a, 0x7a, + 0x25, 0xf1, 0xbc, 0x7d, 0x04, 0x6f, 0xa9, 0xb7, 0x26, 0xe2, 0x05, 0x42, 0x42, 0x73, 0x53, 0x35, + 0x49, 0x35, 0xef, 0xbf, 0x4a, 0xbb, 0x91, 0x48, 0x1e, 0x45, 0x4b, 0x11, 0x68, 0x2a, 0xb6, 0x58, + 0xf2, 0x50, 0x84, 0xd9, 0x40, 0x73, 0x35, 0xea, 0x7e, 0x7c, 0x9e, 0x93, 0xef, 0xa7, 0xa2, 0xee, + 0x67, 0x0c, 0xbe, 0x58, 0xf8, 0x6b, 0x89, 0xfe, 0x44, 0x27, 0x82, 0xf0, 0x54, 0x77, 0xf7, 0xb7, + 0x06, 0xaa, 0xe9, 0x64, 0x61, 0x81, 0x22, 0x1e, 0x83, 0x05, 0x8e, 0x2f, 0x58, 0xd0, 0xa0, 0x1e, + 0x6a, 0x99, 0xa2, 0xa4, 0x27, 0x60, 0x49, 0xfd, 0xdf, 0xf6, 0xd5, 0xc9, 0x88, 0x62, 0x95, 0x7d, + 0xa8, 0x7b, 0x2a, 0xcd, 0x84, 0x7b, 0x2d, 0x8d, 0x53, 0x1f, 0x27, 0xc5, 0x22, 0x93, 0x51, 0x83, + 0x16, 0x19, 0xef, 0x08, 0xa1, 0x6c, 0x9d, 0xc4, 0x71, 0x16, 0x99, 0xde, 0x66, 0x62, 0x2e, 0x27, + 0xd2, 0x7d, 0x4d, 0xf6, 0x67, 0x89, 0xcd, 0xe4, 0x44, 0x97, 0x93, 0xd2, 0xcc, 0x95, 0x4f, 0xa0, + 0xa7, 0x50, 0xe2, 0xbf, 0xcd, 0x7d, 0x73, 0x7c, 0x7d, 0xc8, 0x67, 0xbf, 0x3c, 0x01, 0x4b, 0x4c, + 0x7c, 0x00, 0x4b, 0x29, 0xd5, 0x61, 0x62, 0x28, 0x1c, 0x5f, 0x49, 0x4e, 0x72, 0xd2, 0x2a, 0xa0, + 0xf8, 0x0f, 0x60, 0x12, 0x8f, 0x29, 0xf5, 0x77, 0x32, 0x19, 0x96, 0x88, 0xff, 0x86, 0x25, 0x71, + 0x89, 0xd4, 0x9f, 0xba, 0x4c, 0x5a, 0xe2, 0x31, 0x80, 0x5f, 0x03, 0x26, 0x9e, 0x47, 0xac, 0x44, + 0x9c, 0x30, 0xe5, 0xca, 0xff, 0x96, 0xa1, 0xec, 0x3d, 0xb8, 0x7a, 0x0d, 0xf9, 0xff, 0x6b, 0x48, + 0xc8, 0x3f, 0x87, 0xf9, 0xc8, 0x2f, 0x37, 0x12, 0x8d, 0x27, 0xf9, 0xd7, 0x1d, 0x93, 0x4e, 0xe8, + 0x29, 0xff, 0x6f, 0x00, 0x22, 0x36, 0xbf, 0x95, 0x96, 0xd4, 0x47, 0xc3, 0xf2, 0x84, 0x89, 0x7f, + 0xb3, 0x83, 0xf0, 0x23, 0x80, 0x40, 0xf8, 0x1d, 0x7f, 0x6d, 0x4e, 0x22, 0xca, 0x24, 0x69, 0x19, + 0x89, 0x11, 0xf6, 0x5a, 0x96, 0x2b, 0xce, 0x74, 0x1f, 0x99, 0x1e, 0x57, 0x37, 0x8f, 0xe9, 0x23, + 0x27, 0x70, 0xef, 0x10, 0x4f, 0x12, 0xed, 0x2e, 0xa5, 0x78, 0x92, 0x94, 0x9e, 0x56, 0x62, 0x4c, + 0x49, 0x6f, 0x59, 0xbd, 0x12, 0xdf, 0xb2, 0x7a, 0xfb, 0xf7, 0xdf, 0xeb, 0xeb, 0xee, 0xfe, 0x68, + 0x97, 0x7c, 0xb9, 0xc5, 0x50, 0xdf, 0xd1, 0x2d, 0xfe, 0xd7, 0x2d, 0x4f, 0xf7, 0x6e, 0x51, 0xea, + 0x5b, 0x64, 0x8d, 0xe1, 0xee, 0x6e, 0x89, 0x8e, 0x6e, 0xff, 0x2a, 0x00, 0x00, 0xff, 0xff, 0xed, + 0xbc, 0xc3, 0xee, 0x5c, 0x44, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -4465,7 +4614,6 @@ type DataCoordClient interface { ShowConfigurations(ctx context.Context, in *internalpb.ShowConfigurationsRequest, opts ...grpc.CallOption) (*internalpb.ShowConfigurationsResponse, error) // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error) - CompleteCompaction(ctx context.Context, in *CompactionResult, opts ...grpc.CallOption) (*commonpb.Status, error) ManualCompaction(ctx context.Context, in *milvuspb.ManualCompactionRequest, opts ...grpc.CallOption) (*milvuspb.ManualCompactionResponse, error) GetCompactionState(ctx context.Context, in *milvuspb.GetCompactionStateRequest, opts ...grpc.CallOption) (*milvuspb.GetCompactionStateResponse, error) GetCompactionStateWithPlans(ctx context.Context, in *milvuspb.GetCompactionPlansRequest, opts ...grpc.CallOption) (*milvuspb.GetCompactionPlansResponse, error) @@ -4633,15 +4781,6 @@ func (c *dataCoordClient) GetMetrics(ctx context.Context, in *milvuspb.GetMetric return out, nil } -func (c *dataCoordClient) CompleteCompaction(ctx context.Context, in *CompactionResult, opts ...grpc.CallOption) (*commonpb.Status, error) { - out := new(commonpb.Status) - err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/CompleteCompaction", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - func (c *dataCoordClient) ManualCompaction(ctx context.Context, in *milvuspb.ManualCompactionRequest, opts ...grpc.CallOption) (*milvuspb.ManualCompactionResponse, error) { out := new(milvuspb.ManualCompactionResponse) err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/ManualCompaction", in, out, opts...) @@ -4769,7 +4908,6 @@ type DataCoordServer interface { ShowConfigurations(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy GetMetrics(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) - CompleteCompaction(context.Context, *CompactionResult) (*commonpb.Status, error) ManualCompaction(context.Context, *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) GetCompactionState(context.Context, *milvuspb.GetCompactionStateRequest) (*milvuspb.GetCompactionStateResponse, error) GetCompactionStateWithPlans(context.Context, *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error) @@ -4837,9 +4975,6 @@ func (*UnimplementedDataCoordServer) ShowConfigurations(ctx context.Context, req func (*UnimplementedDataCoordServer) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetMetrics not implemented") } -func (*UnimplementedDataCoordServer) CompleteCompaction(ctx context.Context, req *CompactionResult) (*commonpb.Status, error) { - return nil, status.Errorf(codes.Unimplemented, "method CompleteCompaction not implemented") -} func (*UnimplementedDataCoordServer) ManualCompaction(ctx context.Context, req *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ManualCompaction not implemented") } @@ -5169,24 +5304,6 @@ func _DataCoord_GetMetrics_Handler(srv interface{}, ctx context.Context, dec fun return interceptor(ctx, in, info, handler) } -func _DataCoord_CompleteCompaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(CompactionResult) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(DataCoordServer).CompleteCompaction(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/milvus.proto.data.DataCoord/CompleteCompaction", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(DataCoordServer).CompleteCompaction(ctx, req.(*CompactionResult)) - } - return interceptor(ctx, in, info, handler) -} - func _DataCoord_ManualCompaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(milvuspb.ManualCompactionRequest) if err := dec(in); err != nil { @@ -5471,10 +5588,6 @@ var _DataCoord_serviceDesc = grpc.ServiceDesc{ MethodName: "GetMetrics", Handler: _DataCoord_GetMetrics_Handler, }, - { - MethodName: "CompleteCompaction", - Handler: _DataCoord_CompleteCompaction_Handler, - }, { MethodName: "ManualCompaction", Handler: _DataCoord_ManualCompaction_Handler, @@ -5540,6 +5653,7 @@ type DataNodeClient interface { // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error) Compaction(ctx context.Context, in *CompactionPlan, opts ...grpc.CallOption) (*commonpb.Status, error) + GetCompactionState(ctx context.Context, in *CompactionStateRequest, opts ...grpc.CallOption) (*CompactionStateResponse, error) // https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load Import(ctx context.Context, in *ImportTaskRequest, opts ...grpc.CallOption) (*commonpb.Status, error) ResendSegmentStats(ctx context.Context, in *ResendSegmentStatsRequest, opts ...grpc.CallOption) (*ResendSegmentStatsResponse, error) @@ -5617,6 +5731,15 @@ func (c *dataNodeClient) Compaction(ctx context.Context, in *CompactionPlan, opt return out, nil } +func (c *dataNodeClient) GetCompactionState(ctx context.Context, in *CompactionStateRequest, opts ...grpc.CallOption) (*CompactionStateResponse, error) { + out := new(CompactionStateResponse) + err := c.cc.Invoke(ctx, "/milvus.proto.data.DataNode/GetCompactionState", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *dataNodeClient) Import(ctx context.Context, in *ImportTaskRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { out := new(commonpb.Status) err := c.cc.Invoke(ctx, "/milvus.proto.data.DataNode/Import", in, out, opts...) @@ -5654,6 +5777,7 @@ type DataNodeServer interface { // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy GetMetrics(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) Compaction(context.Context, *CompactionPlan) (*commonpb.Status, error) + GetCompactionState(context.Context, *CompactionStateRequest) (*CompactionStateResponse, error) // https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load Import(context.Context, *ImportTaskRequest) (*commonpb.Status, error) ResendSegmentStats(context.Context, *ResendSegmentStatsRequest) (*ResendSegmentStatsResponse, error) @@ -5685,6 +5809,9 @@ func (*UnimplementedDataNodeServer) GetMetrics(ctx context.Context, req *milvusp func (*UnimplementedDataNodeServer) Compaction(ctx context.Context, req *CompactionPlan) (*commonpb.Status, error) { return nil, status.Errorf(codes.Unimplemented, "method Compaction not implemented") } +func (*UnimplementedDataNodeServer) GetCompactionState(ctx context.Context, req *CompactionStateRequest) (*CompactionStateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetCompactionState not implemented") +} func (*UnimplementedDataNodeServer) Import(ctx context.Context, req *ImportTaskRequest) (*commonpb.Status, error) { return nil, status.Errorf(codes.Unimplemented, "method Import not implemented") } @@ -5825,6 +5952,24 @@ func _DataNode_Compaction_Handler(srv interface{}, ctx context.Context, dec func return interceptor(ctx, in, info, handler) } +func _DataNode_GetCompactionState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CompactionStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DataNodeServer).GetCompactionState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.data.DataNode/GetCompactionState", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DataNodeServer).GetCompactionState(ctx, req.(*CompactionStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _DataNode_Import_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ImportTaskRequest) if err := dec(in); err != nil { @@ -5911,6 +6056,10 @@ var _DataNode_serviceDesc = grpc.ServiceDesc{ MethodName: "Compaction", Handler: _DataNode_Compaction_Handler, }, + { + MethodName: "GetCompactionState", + Handler: _DataNode_GetCompactionState_Handler, + }, { MethodName: "Import", Handler: _DataNode_Import_Handler, diff --git a/internal/proto/milvus.proto b/internal/proto/milvus.proto index a0f48899d7..018a07559e 100644 --- a/internal/proto/milvus.proto +++ b/internal/proto/milvus.proto @@ -908,6 +908,7 @@ message GetCompactionStateResponse { int64 executingPlanNo = 3; int64 timeoutPlanNo = 4; int64 completedPlanNo = 5; + int64 failedPlanNo = 6; } message GetCompactionPlansRequest { @@ -1259,4 +1260,4 @@ extend google.protobuf.FileOptions { option (milvus_ext_obj) = { version: "2.1.0" -}; \ No newline at end of file +}; diff --git a/internal/proto/milvuspb/milvus.pb.go b/internal/proto/milvuspb/milvus.pb.go index 3cca88991d..915ce64e93 100644 --- a/internal/proto/milvuspb/milvus.pb.go +++ b/internal/proto/milvuspb/milvus.pb.go @@ -4773,6 +4773,7 @@ type GetCompactionStateResponse struct { ExecutingPlanNo int64 `protobuf:"varint,3,opt,name=executingPlanNo,proto3" json:"executingPlanNo,omitempty"` TimeoutPlanNo int64 `protobuf:"varint,4,opt,name=timeoutPlanNo,proto3" json:"timeoutPlanNo,omitempty"` CompletedPlanNo int64 `protobuf:"varint,5,opt,name=completedPlanNo,proto3" json:"completedPlanNo,omitempty"` + FailedPlanNo int64 `protobuf:"varint,6,opt,name=failedPlanNo,proto3" json:"failedPlanNo,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -4838,6 +4839,13 @@ func (m *GetCompactionStateResponse) GetCompletedPlanNo() int64 { return 0 } +func (m *GetCompactionStateResponse) GetFailedPlanNo() int64 { + if m != nil { + return m.FailedPlanNo + } + return 0 +} + type GetCompactionPlansRequest struct { CompactionID int64 `protobuf:"varint,1,opt,name=compactionID,proto3" json:"compactionID,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` @@ -7049,34 +7057,34 @@ func init() { func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) } var fileDescriptor_02345ba45cc0e303 = []byte{ - // 5188 bytes of a gzipped FileDescriptorProto + // 5200 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x3d, 0x4b, 0x6c, 0x1c, 0x47, 0x76, 0xec, 0x19, 0xce, 0xef, 0xcd, 0x87, 0xc3, 0xe2, 0x6f, 0x3c, 0x92, 0x2c, 0xaa, 0x6d, 0xd9, 0xb4, 0xb4, 0xa6, 0x6c, 0xca, 0x96, 0xd7, 0xb2, 0x57, 0xb6, 0x24, 0x5a, 0x12, 0x61, 0x7d, 0xe8, 0xa6, 0xec, 0x60, 0xe3, 0x18, 0x8d, 0xe6, 0x74, 0x71, 0xd8, 0x56, 0x4f, 0xf7, 0xa8, 0xbb, 0x87, - 0x14, 0x9d, 0xcb, 0x02, 0x9b, 0xdd, 0x6c, 0x90, 0xcd, 0x2e, 0x36, 0xbf, 0x45, 0x0e, 0xf9, 0x20, - 0xd8, 0x1c, 0x02, 0x6c, 0x82, 0x38, 0x09, 0x10, 0x60, 0x73, 0xc8, 0x39, 0x46, 0xbe, 0x87, 0x20, + 0x14, 0x9d, 0xcb, 0x02, 0x9b, 0x5d, 0x6c, 0x90, 0xcd, 0x2e, 0x36, 0xbf, 0x45, 0x0e, 0xf9, 0x20, + 0xd8, 0x1c, 0x82, 0x6c, 0x82, 0x38, 0x09, 0x10, 0x60, 0x73, 0xc8, 0x39, 0x46, 0xbe, 0x87, 0x20, 0x59, 0x24, 0xc7, 0x45, 0x80, 0x1c, 0x02, 0xe4, 0x90, 0x63, 0x82, 0x04, 0xf5, 0xe9, 0x9e, 0xea, 0x9e, 0xea, 0xe1, 0x90, 0xb3, 0x32, 0x29, 0xf3, 0x34, 0xf5, 0xea, 0x55, 0xd5, 0xab, 0x57, 0xef, 0xbd, 0x7a, 0x55, 0xef, 0x55, 0x13, 0x2a, 0x1d, 0xcb, 0xde, 0xe9, 0xf9, 0xcb, 0x5d, 0xcf, 0x0d, 0x5c, 0x34, 0x23, 0x96, 0x96, 0x59, 0xa1, 0x59, 0x69, 0xb9, 0x9d, 0x8e, 0xeb, 0x30, 0x60, 0xb3, 0xe2, 0xb7, 0xb6, 0x71, 0xc7, 0xe0, 0xa5, 0xc5, 0xb6, 0xeb, 0xb6, 0x6d, 0x7c, 0x81, 0x96, 0x36, - 0x7b, 0x5b, 0x17, 0x4c, 0xec, 0xb7, 0x3c, 0xab, 0x1b, 0xb8, 0x1e, 0xc3, 0x50, 0x7f, 0x47, 0x01, + 0x7b, 0x5b, 0x17, 0x4c, 0xec, 0xb7, 0x3c, 0xab, 0x1b, 0xb8, 0x1e, 0xc3, 0x50, 0x7f, 0x5b, 0x01, 0x74, 0xdd, 0xc3, 0x46, 0x80, 0xaf, 0xda, 0x96, 0xe1, 0x6b, 0xf8, 0x61, 0x0f, 0xfb, 0x01, 0x7a, 0x09, 0x26, 0x37, 0x0d, 0x1f, 0x37, 0x94, 0x45, 0x65, 0xa9, 0xbc, 0x72, 0x72, 0x39, 0x36, 0x30, 0x1f, 0xf0, 0x8e, 0xdf, 0xbe, 0x66, 0xf8, 0x58, 0xa3, 0x98, 0x68, 0x01, 0x0a, 0xe6, 0xa6, 0xee, 0x18, 0x1d, 0xdc, 0xc8, 0x2c, 0x2a, 0x4b, 0x25, 0x2d, 0x6f, 0x6e, 0xde, 0x35, 0x3a, 0x18, 0x3d, 0x0f, 0x53, 0x2d, 0xd7, 0xb6, 0x71, 0x2b, 0xb0, 0x5c, 0x87, 0x21, 0x64, 0x29, 0x42, 0xad, 0x0f, 0xa6, 0x88, 0xb3, 0x90, 0x33, 0x08, 0x0d, 0x8d, 0x49, 0x5a, 0xcd, 0x0a, 0xaa, 0x0f, 0xf5, 0x55, - 0xcf, 0xed, 0x3e, 0x2e, 0xea, 0xa2, 0x41, 0xb3, 0xe2, 0xa0, 0xbf, 0xad, 0xc0, 0xf4, 0x55, 0x3b, + 0xcf, 0xed, 0x3e, 0x2e, 0xea, 0xa2, 0x41, 0xb3, 0xe2, 0xa0, 0xbf, 0xa5, 0xc0, 0xf4, 0x55, 0x3b, 0xc0, 0xde, 0x31, 0x65, 0xca, 0x0f, 0x33, 0xb0, 0xc0, 0x56, 0xed, 0x7a, 0x84, 0x7e, 0x94, 0x54, 0xce, 0x43, 0x9e, 0xc9, 0x1d, 0x25, 0xb3, 0xa2, 0xf1, 0x12, 0x3a, 0x05, 0xe0, 0x6f, 0x1b, 0x9e, 0xe9, 0xeb, 0x4e, 0xaf, 0xd3, 0xc8, 0x2d, 0x2a, 0x4b, 0x39, 0xad, 0xc4, 0x20, 0x77, 0x7b, 0x1d, 0xa4, 0xc1, 0x74, 0xcb, 0x75, 0x7c, 0xcb, 0x0f, 0xb0, 0xd3, 0xda, 0xd3, 0x6d, 0xbc, 0x83, 0xed, 0x46, 0x7e, 0x51, 0x59, 0xaa, 0xad, 0x9c, 0x95, 0xd2, 0x7d, 0xbd, 0x8f, 0x7d, 0x9b, 0x20, 0x6b, 0xf5, 0x56, 0x02, 0x72, 0x19, 0x7d, 0x76, 0x65, 0xaa, 0xa8, 0xd4, 0x95, 0xc6, 0xff, 0x85, 0x7f, - 0x8a, 0xfa, 0xbb, 0x0a, 0xcc, 0x11, 0x21, 0x3a, 0x16, 0xcc, 0x0a, 0x29, 0xcc, 0x88, 0x14, 0xfe, - 0xa1, 0x02, 0xb3, 0xb7, 0x0c, 0xff, 0x78, 0xac, 0xe6, 0x29, 0x80, 0xc0, 0xea, 0x60, 0xdd, 0x0f, + 0x8a, 0xfa, 0x3b, 0x0a, 0xcc, 0x11, 0x21, 0x3a, 0x16, 0xcc, 0x0a, 0x29, 0xcc, 0x88, 0x14, 0xfe, + 0x81, 0x02, 0xb3, 0xb7, 0x0c, 0xff, 0x78, 0xac, 0xe6, 0x29, 0x80, 0xc0, 0xea, 0x60, 0xdd, 0x0f, 0x8c, 0x4e, 0x97, 0xae, 0xe8, 0xa4, 0x56, 0x22, 0x90, 0x0d, 0x02, 0x50, 0xbf, 0x0a, 0x95, 0x6b, 0xae, 0x6b, 0x6b, 0xd8, 0xef, 0xba, 0x8e, 0x8f, 0xd1, 0x45, 0xc8, 0xfb, 0x81, 0x11, 0xf4, 0x7c, 0x4e, 0xe4, 0x09, 0x29, 0x91, 0x1b, 0x14, 0x45, 0xe3, 0xa8, 0x44, 0xae, 0x77, 0x0c, 0xbb, 0xc7, @@ -7122,7 +7130,7 @@ var fileDescriptor_02345ba45cc0e303 = []byte{ 0xf2, 0xbf, 0x72, 0x47, 0x24, 0xa2, 0xf9, 0xc9, 0xd8, 0x31, 0x07, 0x3d, 0x96, 0x9c, 0xc4, 0x63, 0x51, 0xff, 0xa2, 0xef, 0xa8, 0x3c, 0x59, 0x13, 0x54, 0x7f, 0xa4, 0xc0, 0xa9, 0x9b, 0x38, 0x88, 0xa8, 0x3e, 0x1e, 0x1e, 0xcd, 0x88, 0x42, 0xf5, 0x1d, 0xe6, 0x0d, 0x48, 0x89, 0x3f, 0x92, 0xcd, - 0xf6, 0x97, 0x33, 0x30, 0x47, 0x76, 0x9d, 0xe3, 0x21, 0x04, 0xa3, 0x1c, 0x6b, 0x25, 0x82, 0x92, + 0xf6, 0x97, 0x32, 0x30, 0x47, 0x76, 0x9d, 0xe3, 0x21, 0x04, 0xa3, 0x1c, 0x6b, 0x25, 0x82, 0x92, 0x93, 0x6a, 0x42, 0xb8, 0x85, 0xe7, 0x47, 0xde, 0xc2, 0xd5, 0x3f, 0xcd, 0x30, 0xd7, 0x43, 0xe4, 0xc6, 0x38, 0xcb, 0x22, 0xa1, 0x35, 0x23, 0xa5, 0x55, 0x85, 0x4a, 0x04, 0x59, 0x5b, 0x0d, 0xb7, 0xdf, 0x18, 0xec, 0xb8, 0xee, 0xbe, 0xea, 0xb7, 0x15, 0x98, 0x0f, 0x2f, 0x0d, 0x36, 0x70, 0xbb, @@ -7130,20 +7138,20 @@ var fileDescriptor_02345ba45cc0e303 = []byte{ 0x44, 0xf7, 0x01, 0x7d, 0x80, 0xfa, 0x57, 0x0a, 0x2c, 0x0c, 0x90, 0x33, 0xce, 0x22, 0x36, 0xa0, 0x60, 0x39, 0x26, 0x7e, 0x14, 0x51, 0x13, 0x16, 0x49, 0xcd, 0x66, 0xcf, 0xb2, 0xcd, 0x88, 0x8c, 0xb0, 0x88, 0xce, 0x40, 0x05, 0x3b, 0xc4, 0xc7, 0xd0, 0x29, 0x2e, 0x15, 0xe4, 0xa2, 0x56, 0x66, - 0xb0, 0x35, 0x02, 0x22, 0x8d, 0xb7, 0x2c, 0x4c, 0x1b, 0xe7, 0x58, 0x63, 0x5e, 0x54, 0x7f, 0x45, + 0xb0, 0x35, 0x02, 0x22, 0x8d, 0xb7, 0x2c, 0x4c, 0x1b, 0xe7, 0x58, 0x63, 0x5e, 0x54, 0x7f, 0x59, 0x81, 0x19, 0x22, 0x85, 0x9c, 0x7a, 0xff, 0xf1, 0x72, 0x73, 0x11, 0xca, 0x82, 0x98, 0xf1, 0x89, 0x88, 0x20, 0xf5, 0x01, 0xcc, 0xc6, 0xc9, 0x19, 0x87, 0x9b, 0x4f, 0x03, 0x44, 0x6b, 0xc5, 0xb4, - 0x21, 0xab, 0x09, 0x10, 0xf5, 0x37, 0x32, 0x61, 0x58, 0x81, 0xb2, 0xe9, 0x88, 0x6f, 0x33, 0xe9, + 0x21, 0xab, 0x09, 0x10, 0xf5, 0xd7, 0x33, 0x61, 0x58, 0x81, 0xb2, 0xe9, 0x88, 0x6f, 0x33, 0xe9, 0x92, 0x88, 0xf6, 0xbc, 0x44, 0x21, 0xb4, 0x7a, 0x15, 0x2a, 0xf8, 0x51, 0xe0, 0x19, 0x7a, 0xd7, 0xf0, 0x8c, 0x0e, 0x53, 0xab, 0x91, 0x4c, 0x6f, 0x99, 0x36, 0x5b, 0xa7, 0xad, 0xc8, 0x20, 0x54, 0x44, 0xd8, 0x20, 0x79, 0x36, 0x08, 0x85, 0xf4, 0xcf, 0x69, 0xe5, 0x46, 0x56, 0xfd, 0x47, 0xe2, - 0xf5, 0x71, 0xb1, 0x3e, 0xee, 0x9c, 0x89, 0xcf, 0x29, 0x27, 0x9d, 0x53, 0xa5, 0x91, 0x55, 0xff, - 0x40, 0x81, 0x3a, 0x9d, 0xcb, 0x2a, 0x0f, 0x2e, 0x59, 0xae, 0x93, 0x68, 0xac, 0x24, 0x1a, 0x0f, + 0xf5, 0x71, 0xb1, 0x3e, 0xee, 0x9c, 0x89, 0xcf, 0x29, 0x27, 0x9d, 0x53, 0xa5, 0x91, 0x55, 0x7f, + 0x5f, 0x81, 0x3a, 0x9d, 0xcb, 0x2a, 0x0f, 0x2e, 0x59, 0xae, 0x93, 0x68, 0xac, 0x24, 0x1a, 0x0f, 0xd1, 0xc6, 0xd7, 0x21, 0xcf, 0x57, 0x22, 0x3b, 0xea, 0x4a, 0xf0, 0x06, 0xfb, 0xcc, 0x47, 0xfd, - 0x7d, 0x05, 0xe6, 0x12, 0xbc, 0x1f, 0x47, 0x05, 0xee, 0x03, 0x62, 0x33, 0x34, 0xfb, 0xd3, 0x0e, + 0x3d, 0x05, 0xe6, 0x12, 0xbc, 0x1f, 0x47, 0x05, 0xee, 0x03, 0x62, 0x33, 0x34, 0xfb, 0xd3, 0x0e, 0x77, 0xee, 0xb3, 0xd2, 0x6d, 0x2a, 0xc9, 0x24, 0x6d, 0xda, 0x4a, 0x40, 0x7c, 0xf5, 0xc7, 0x0a, 0x9c, 0xbc, 0x89, 0x03, 0x8a, 0x7a, 0x8d, 0x98, 0xa1, 0x75, 0xcf, 0x6d, 0x7b, 0xd8, 0xf7, 0xbf, - 0x00, 0x82, 0xf2, 0x9b, 0xcc, 0xe7, 0x93, 0xcd, 0x6d, 0x9c, 0x85, 0x38, 0x03, 0x15, 0x3a, 0x18, + 0x00, 0x82, 0xf2, 0x1b, 0xcc, 0xe7, 0x93, 0xcd, 0x6d, 0x9c, 0x85, 0x38, 0x03, 0x15, 0x3a, 0x18, 0x36, 0x75, 0xcf, 0xdd, 0xf5, 0xb9, 0x40, 0x95, 0x39, 0x4c, 0x73, 0x77, 0xa9, 0x64, 0x04, 0x6e, 0x60, 0xd8, 0x0c, 0x81, 0x6f, 0x36, 0x14, 0x42, 0xaa, 0xa9, 0x56, 0x86, 0x84, 0x91, 0xce, 0xf1, 0x17, 0x80, 0xd9, 0x3f, 0x60, 0x37, 0x67, 0xe2, 0x9c, 0xc6, 0x61, 0xf2, 0xab, 0xcc, 0x35, 0x65, @@ -7204,8 +7212,8 @@ var fileDescriptor_02345ba45cc0e303 = []byte{ 0x5e, 0x81, 0xb9, 0x75, 0xec, 0xb1, 0x1c, 0xa3, 0x80, 0xdf, 0x4c, 0xae, 0x39, 0x5b, 0x6e, 0xfc, 0x72, 0x58, 0x49, 0x5c, 0x0e, 0xff, 0x74, 0x2e, 0x44, 0x63, 0xe7, 0x13, 0x16, 0xa2, 0x08, 0xcf, 0x27, 0x61, 0x20, 0x86, 0x1d, 0xf4, 0x6a, 0x29, 0xcb, 0xc4, 0xe9, 0x15, 0xcf, 0xbb, 0xea, 0xaf, - 0xb1, 0x3c, 0x0c, 0xe9, 0xa4, 0x0e, 0x2f, 0xb0, 0xf3, 0xc0, 0x4d, 0x7e, 0x62, 0x03, 0x78, 0x0e, - 0x12, 0xb6, 0x23, 0xc5, 0x10, 0xfd, 0x96, 0x02, 0x8b, 0xe9, 0x54, 0x8d, 0xb3, 0x57, 0xbf, 0x0d, + 0xb2, 0x3c, 0x0c, 0xe9, 0xa4, 0x0e, 0x2f, 0xb0, 0xf3, 0xc0, 0x4d, 0x7e, 0x62, 0x03, 0x78, 0x0e, + 0x12, 0xb6, 0x23, 0xc5, 0x10, 0xfd, 0xa6, 0x02, 0x8b, 0xe9, 0x54, 0x8d, 0xb3, 0x57, 0xbf, 0x0d, 0x39, 0xcb, 0xd9, 0x72, 0xc3, 0x7b, 0xaf, 0x73, 0x52, 0x5d, 0x90, 0x8f, 0xcb, 0x1a, 0xaa, 0xff, 0x90, 0x81, 0xfa, 0x7b, 0x2c, 0xae, 0xff, 0xb9, 0x2f, 0x7f, 0x07, 0x77, 0x74, 0xdf, 0xfa, 0x04, 0x87, 0xcb, 0xdf, 0xc1, 0x9d, 0x0d, 0xeb, 0x13, 0x1c, 0x93, 0x8c, 0x5c, 0x5c, 0x32, 0x86, 0x5f, @@ -7230,151 +7238,151 @@ var fileDescriptor_02345ba45cc0e303 = []byte{ 0xd3, 0x2c, 0x95, 0x8e, 0xb9, 0xeb, 0x74, 0x72, 0x93, 0x9a, 0x00, 0x61, 0xe3, 0x14, 0x1a, 0x8a, 0xea, 0x43, 0x63, 0x70, 0x9c, 0x71, 0x96, 0x98, 0x52, 0x17, 0x76, 0x25, 0xda, 0xf3, 0x3e, 0x4c, 0x7d, 0x0b, 0x9e, 0xa2, 0xf9, 0x8d, 0x21, 0x28, 0x76, 0x4d, 0x9f, 0xec, 0x40, 0x91, 0x74, 0xf0, - 0x8b, 0x19, 0x6a, 0x14, 0x07, 0x7a, 0x18, 0x87, 0xf0, 0xcb, 0xf1, 0x4b, 0xf1, 0x67, 0x53, 0xd2, + 0x87, 0x19, 0x6a, 0x14, 0x07, 0x7a, 0x18, 0x87, 0xf0, 0xcb, 0xf1, 0x4b, 0xf1, 0x67, 0x53, 0xd2, 0xaa, 0xe3, 0x23, 0x72, 0xf3, 0xbd, 0x04, 0x53, 0xf8, 0x11, 0x6e, 0xf5, 0x02, 0xcb, 0x69, 0xaf, 0xdb, 0x86, 0x73, 0xd7, 0xe5, 0x9b, 0x54, 0x12, 0x8c, 0x9e, 0x85, 0x2a, 0x59, 0x06, 0xb7, 0x17, 0x70, 0x3c, 0xb6, 0x5b, 0xc5, 0x81, 0xa4, 0x3f, 0x32, 0x5f, 0x1b, 0x07, 0xd8, 0xe4, 0x78, 0x6c, - 0xeb, 0x4a, 0x82, 0x07, 0x58, 0x49, 0xc0, 0xfe, 0x41, 0x58, 0xf9, 0xcf, 0x4a, 0x82, 0x95, 0xbc, - 0x87, 0xa3, 0x62, 0xe5, 0x2d, 0x80, 0x0e, 0xf6, 0xda, 0x78, 0x8d, 0x6e, 0x07, 0xec, 0x5a, 0x60, - 0x49, 0xba, 0x1d, 0xf4, 0x3b, 0xb8, 0x13, 0x36, 0xd0, 0x84, 0xb6, 0xea, 0x4d, 0x98, 0x91, 0xa0, - 0x10, 0x4b, 0xe7, 0xbb, 0x3d, 0xaf, 0x85, 0xc3, 0x2b, 0xa6, 0xb0, 0x48, 0x76, 0xc6, 0xc0, 0xf0, - 0xda, 0x38, 0xe0, 0x42, 0xcb, 0x4b, 0xea, 0x25, 0x1a, 0x50, 0xa2, 0xb7, 0x10, 0x31, 0x49, 0x8d, - 0xc7, 0xcd, 0x95, 0x81, 0xb8, 0xf9, 0x16, 0x0d, 0xda, 0x88, 0xed, 0xc6, 0xcc, 0x79, 0xd8, 0x22, - 0x5d, 0x61, 0x93, 0x3f, 0xb3, 0x09, 0x8b, 0xea, 0xff, 0x2a, 0x50, 0x5d, 0xeb, 0x74, 0xdd, 0x7e, - 0x98, 0x62, 0xe4, 0xe3, 0xe9, 0xe0, 0xed, 0x6e, 0x46, 0x76, 0xbb, 0xfb, 0x0c, 0x54, 0xe3, 0x0f, - 0x32, 0xd8, 0xed, 0x51, 0xa5, 0x25, 0x3e, 0xc4, 0x38, 0x01, 0x25, 0xcf, 0xdd, 0xd5, 0x89, 0x71, - 0x35, 0x79, 0x76, 0x45, 0xd1, 0x73, 0x77, 0x89, 0xc9, 0x35, 0xd1, 0x2c, 0xe4, 0xb6, 0x2c, 0x3b, - 0x4a, 0x0c, 0x62, 0x05, 0xf4, 0x06, 0x39, 0xbc, 0xb1, 0x58, 0x6b, 0x7e, 0xd4, 0x33, 0x54, 0xd8, - 0x82, 0xd9, 0x30, 0xd4, 0x50, 0xd4, 0x0f, 0xa1, 0x16, 0x4e, 0x7f, 0xcc, 0x87, 0x46, 0x81, 0xe1, - 0x3f, 0x08, 0x33, 0x20, 0x58, 0x41, 0x3d, 0xcf, 0x22, 0x6f, 0xb4, 0xff, 0xd8, 0xea, 0x23, 0x98, - 0x24, 0x18, 0x5c, 0xa9, 0xe8, 0x6f, 0xf5, 0xef, 0x32, 0x30, 0x9f, 0xc4, 0x1e, 0x87, 0xa4, 0x4b, - 0x71, 0x45, 0x92, 0xbf, 0x1b, 0x11, 0x47, 0xe3, 0x4a, 0xc4, 0x97, 0xa2, 0xe5, 0xf6, 0x9c, 0x80, - 0x5b, 0x22, 0xb2, 0x14, 0xd7, 0x49, 0x19, 0x2d, 0x40, 0xc1, 0x32, 0x75, 0x9b, 0x1c, 0xf8, 0xd8, - 0x76, 0x95, 0xb7, 0xcc, 0xdb, 0xe4, 0x30, 0xf8, 0x5a, 0xe8, 0x84, 0x8d, 0x9c, 0x36, 0xc1, 0xf0, - 0x51, 0x0d, 0x32, 0x96, 0xc9, 0x83, 0x23, 0x19, 0xcb, 0x24, 0x52, 0x45, 0x6f, 0x0a, 0x68, 0x8a, - 0x2f, 0xcf, 0xf9, 0x25, 0xe2, 0x50, 0x25, 0xd0, 0xf7, 0x42, 0x20, 0xf1, 0xd3, 0x28, 0x1a, 0x0f, - 0xee, 0x52, 0x5f, 0xba, 0xa8, 0x95, 0x09, 0x6c, 0x8d, 0x81, 0xd4, 0x06, 0xcc, 0x13, 0xd2, 0xd8, - 0x14, 0xef, 0x93, 0x05, 0x09, 0xbd, 0xaf, 0xef, 0x29, 0xb0, 0x30, 0x50, 0x35, 0x0e, 0xaf, 0xaf, - 0x8a, 0xcb, 0x5f, 0x5e, 0x39, 0x2f, 0xb5, 0x39, 0xf2, 0xc5, 0x0d, 0x65, 0xe5, 0xd7, 0x99, 0xab, - 0xa4, 0xb1, 0xb4, 0xce, 0xc7, 0x9c, 0x24, 0xb4, 0x04, 0xf5, 0x5d, 0x2b, 0xd8, 0xd6, 0xe9, 0x4b, - 0x24, 0xea, 0xa7, 0xb0, 0x60, 0x78, 0x51, 0xab, 0x11, 0xf8, 0x06, 0x01, 0x13, 0x5f, 0xc5, 0x57, - 0xbf, 0xa5, 0xc0, 0x4c, 0x8c, 0xac, 0x71, 0xd8, 0xf4, 0x26, 0x71, 0xe1, 0x58, 0x47, 0x9c, 0x53, - 0x8b, 0x52, 0x4e, 0xf1, 0xd1, 0xa8, 0x55, 0x8e, 0x5a, 0xa8, 0x3f, 0x56, 0xa0, 0x2c, 0xd4, 0x90, - 0xb3, 0x21, 0xaf, 0xeb, 0x9f, 0x0d, 0x23, 0xc0, 0x48, 0x6c, 0x78, 0x06, 0xfa, 0xb6, 0x4a, 0x48, - 0x93, 0x17, 0xf2, 0xf4, 0x4c, 0x1f, 0xdd, 0x82, 0x1a, 0x63, 0x53, 0x44, 0xba, 0xf4, 0xca, 0x26, - 0xca, 0x40, 0x34, 0x3c, 0x93, 0x53, 0xa9, 0x55, 0x7d, 0xa1, 0xc4, 0xe2, 0xa0, 0xae, 0x89, 0xe9, - 0x48, 0xb9, 0x81, 0x93, 0x5a, 0x45, 0x6c, 0x4a, 0xbc, 0x5d, 0x1b, 0x1b, 0x26, 0xf6, 0xa2, 0xb9, - 0x45, 0x65, 0xe2, 0x5e, 0xb2, 0xdf, 0x3a, 0xf1, 0xfe, 0xb9, 0xd5, 0x05, 0x06, 0x22, 0x07, 0x03, - 0xf4, 0x1c, 0x4c, 0x99, 0x9d, 0xd8, 0x33, 0xb8, 0xd0, 0x1f, 0x36, 0x3b, 0xc2, 0xfb, 0xb7, 0x18, - 0x41, 0x93, 0x71, 0x82, 0xbe, 0xd1, 0x7f, 0x58, 0xec, 0x61, 0x13, 0x3b, 0x81, 0x65, 0xd8, 0x87, - 0x97, 0xc9, 0x26, 0x14, 0x7b, 0x3e, 0xf6, 0x84, 0x4d, 0x22, 0x2a, 0x93, 0xba, 0xae, 0xe1, 0xfb, - 0xbb, 0xae, 0x67, 0x72, 0x2a, 0xa3, 0xf2, 0x90, 0xa4, 0x47, 0xf6, 0x18, 0x55, 0x9e, 0xf4, 0x78, - 0x09, 0x16, 0x3a, 0xae, 0x69, 0x6d, 0x59, 0xb2, 0x5c, 0x49, 0xd2, 0x6c, 0x2e, 0xac, 0x8e, 0xb5, - 0x0b, 0x9f, 0x71, 0xcc, 0x88, 0xcf, 0x38, 0x7e, 0x90, 0x81, 0x85, 0xf7, 0xbb, 0xe6, 0xe7, 0xc0, - 0x87, 0x45, 0x28, 0xbb, 0xb6, 0xb9, 0x1e, 0x67, 0x85, 0x08, 0x22, 0x18, 0x0e, 0xde, 0x8d, 0x30, - 0xd8, 0x25, 0xbe, 0x08, 0x1a, 0x9a, 0x24, 0x7a, 0x28, 0x7e, 0xe5, 0x87, 0xf1, 0xab, 0xf4, 0xd9, - 0x95, 0x7c, 0x31, 0x53, 0x9f, 0x6d, 0x64, 0xd4, 0x9f, 0x87, 0x05, 0x16, 0x6e, 0x7e, 0xcc, 0x5c, - 0x0a, 0xd7, 0x68, 0x4e, 0x5c, 0xa3, 0x8f, 0x61, 0x8e, 0x58, 0x73, 0x32, 0xf4, 0xfb, 0x3e, 0xf6, - 0xc6, 0x34, 0x52, 0x27, 0xa1, 0x14, 0x8e, 0x16, 0xa6, 0xf7, 0xf6, 0x01, 0xea, 0xcf, 0xc1, 0x6c, - 0x62, 0xac, 0x43, 0xce, 0x32, 0x9c, 0xc9, 0xbc, 0x38, 0x93, 0x45, 0x00, 0xcd, 0xb5, 0xf1, 0x3b, - 0x4e, 0x60, 0x05, 0x7b, 0xc4, 0x4b, 0x10, 0xdc, 0x2f, 0xfa, 0x9b, 0x60, 0x90, 0x71, 0x87, 0x60, - 0xfc, 0xaa, 0x02, 0xd3, 0x4c, 0x73, 0x49, 0x57, 0x87, 0x5f, 0x85, 0xd7, 0x20, 0x8f, 0xe9, 0x28, - 0xfc, 0x46, 0xe1, 0xb4, 0xdc, 0x54, 0x47, 0xe4, 0x6a, 0x1c, 0x5d, 0xaa, 0x46, 0x01, 0x4c, 0xad, - 0x7a, 0x6e, 0x77, 0x3c, 0x8a, 0xa8, 0x67, 0x62, 0x63, 0xd1, 0xd7, 0x2c, 0x12, 0xc0, 0xdd, 0x34, - 0xc1, 0xf8, 0x27, 0x05, 0xe6, 0xef, 0x75, 0xb1, 0x67, 0x04, 0x98, 0x30, 0x6d, 0xbc, 0xd1, 0x87, - 0xe9, 0x6e, 0x8c, 0xb2, 0x6c, 0x9c, 0x32, 0xf4, 0x66, 0xec, 0xed, 0x99, 0xfc, 0x3c, 0x92, 0xa0, - 0xb2, 0x9f, 0xc3, 0x1e, 0xce, 0x6b, 0x41, 0x9c, 0xd7, 0x8f, 0x14, 0x98, 0xde, 0xc0, 0x64, 0x1f, - 0x1b, 0x6f, 0x4a, 0x17, 0x61, 0x92, 0x50, 0x39, 0xea, 0x02, 0x53, 0x64, 0x74, 0x0e, 0xa6, 0x2d, - 0xa7, 0x65, 0xf7, 0x4c, 0xac, 0x93, 0xf9, 0xeb, 0xc4, 0x8d, 0xe3, 0xce, 0xc3, 0x14, 0xaf, 0x20, - 0xd3, 0x20, 0x5b, 0xb4, 0x54, 0xc6, 0x1f, 0x31, 0x19, 0x8f, 0x92, 0x7c, 0x18, 0x09, 0xca, 0x41, - 0x48, 0x78, 0x15, 0x72, 0x64, 0xe8, 0xd0, 0x89, 0x90, 0xb7, 0xea, 0xab, 0x89, 0xc6, 0xb0, 0xd5, - 0x5f, 0x50, 0x00, 0x89, 0x6c, 0x1b, 0xc7, 0x4a, 0xbc, 0x2e, 0x06, 0xf7, 0xb3, 0x43, 0x49, 0x67, - 0x33, 0x8d, 0xc2, 0xfa, 0xea, 0xa7, 0xd1, 0xea, 0xd1, 0xe5, 0x1e, 0x67, 0xf5, 0xc8, 0xbc, 0x86, - 0xae, 0x9e, 0xc0, 0x04, 0x8a, 0x2c, 0xae, 0x1e, 0x95, 0x58, 0xc9, 0xea, 0x11, 0x9a, 0xe9, 0xea, - 0x71, 0xfb, 0xde, 0x68, 0x64, 0xc8, 0xa2, 0x31, 0x62, 0xc3, 0x45, 0xa3, 0x23, 0x2b, 0x07, 0x19, - 0xf9, 0x55, 0xc8, 0x91, 0x11, 0xf7, 0xe7, 0x57, 0xb8, 0x68, 0x14, 0x5b, 0x58, 0x34, 0x4e, 0xc0, - 0xe3, 0x5f, 0xb4, 0xfe, 0x4c, 0xfb, 0x8b, 0xa6, 0x42, 0xe5, 0xde, 0xe6, 0xc7, 0xb8, 0x15, 0x0c, - 0xb1, 0xbc, 0x67, 0x61, 0x6a, 0xdd, 0xb3, 0x76, 0x2c, 0x1b, 0xb7, 0x87, 0x99, 0xf0, 0x6f, 0x29, - 0x50, 0xbd, 0xe9, 0x19, 0x4e, 0xe0, 0x86, 0x66, 0xfc, 0x50, 0xfc, 0xbc, 0x06, 0xa5, 0x6e, 0x38, - 0x1a, 0x97, 0x81, 0x67, 0xe5, 0x51, 0x97, 0x38, 0x4d, 0x5a, 0xbf, 0x99, 0xfa, 0x01, 0xcc, 0x52, - 0x4a, 0x92, 0x64, 0x5f, 0x81, 0x22, 0x35, 0xe6, 0x16, 0xbf, 0xe8, 0x28, 0xaf, 0xa8, 0xf2, 0x23, - 0x8d, 0x38, 0x0d, 0x2d, 0x6a, 0xa3, 0xfe, 0x9b, 0x02, 0x65, 0x5a, 0xd7, 0x9f, 0xe0, 0xc1, 0xb5, - 0xfc, 0x75, 0xc8, 0xbb, 0x94, 0xe5, 0x43, 0x83, 0xb3, 0xe2, 0xaa, 0x68, 0xbc, 0x01, 0xf1, 0x90, - 0xd9, 0x2f, 0xd1, 0x22, 0x03, 0x03, 0x71, 0x9b, 0x5c, 0x68, 0x33, 0xda, 0xa9, 0x59, 0x1e, 0x6d, - 0x7e, 0x61, 0x13, 0x7a, 0x56, 0x63, 0x32, 0x49, 0x11, 0x0e, 0xaf, 0xc2, 0x5f, 0x4e, 0xec, 0xb1, - 0x8b, 0xe9, 0x54, 0xc8, 0x37, 0xd9, 0x98, 0x65, 0x25, 0x67, 0xb5, 0x18, 0x59, 0x63, 0x9e, 0xd5, - 0x22, 0x11, 0x18, 0x76, 0x56, 0x13, 0x89, 0xeb, 0x0b, 0xc0, 0xbf, 0x28, 0xb0, 0xc0, 0xf7, 0xb4, - 0x48, 0xb6, 0x8e, 0x80, 0x4d, 0xe8, 0x2b, 0x7c, 0xef, 0xcd, 0xd2, 0xbd, 0xf7, 0x85, 0x61, 0x7b, - 0x6f, 0x44, 0xe7, 0x3e, 0x9b, 0xef, 0x59, 0x28, 0xdd, 0xa1, 0x0d, 0xdf, 0x79, 0x14, 0xa0, 0x06, - 0x14, 0x76, 0xb0, 0xe7, 0x5b, 0xae, 0xc3, 0x55, 0x3c, 0x2c, 0x9e, 0x3b, 0x03, 0xc5, 0xf0, 0x35, - 0x1a, 0x2a, 0x40, 0xf6, 0xaa, 0x6d, 0xd7, 0x27, 0x50, 0x05, 0x8a, 0x6b, 0xfc, 0xc9, 0x55, 0x5d, - 0x39, 0xf7, 0x36, 0xcc, 0x48, 0xf6, 0x7d, 0x34, 0x0d, 0xd5, 0xab, 0x26, 0xf5, 0x2e, 0xef, 0xbb, - 0x04, 0x58, 0x9f, 0x40, 0xf3, 0x80, 0x34, 0xdc, 0x71, 0x77, 0x28, 0xe2, 0x0d, 0xcf, 0xed, 0x50, - 0xb8, 0x72, 0xee, 0x45, 0x98, 0x95, 0x51, 0x8f, 0x4a, 0x90, 0xa3, 0xdc, 0xa8, 0x4f, 0x20, 0x80, - 0xbc, 0x86, 0x77, 0xdc, 0x07, 0xb8, 0xae, 0xac, 0xfc, 0xf9, 0x39, 0xa8, 0x32, 0xda, 0xf9, 0xdb, - 0x69, 0xa4, 0x43, 0x3d, 0xf9, 0xf9, 0x28, 0xf4, 0x25, 0xf9, 0x8d, 0xa9, 0xfc, 0x2b, 0x53, 0xcd, - 0x61, 0xc2, 0xa4, 0x4e, 0xa0, 0x0f, 0xa1, 0x16, 0xff, 0xe0, 0x12, 0x92, 0x87, 0x86, 0xa5, 0x5f, - 0x65, 0xda, 0xaf, 0x73, 0x1d, 0xaa, 0xb1, 0x6f, 0x25, 0x21, 0xf9, 0x02, 0xcb, 0xbe, 0xa7, 0xd4, - 0x94, 0x5b, 0x13, 0xf1, 0x7b, 0x46, 0x8c, 0xfa, 0xf8, 0xc7, 0x4b, 0x52, 0xa8, 0x97, 0x7e, 0xe1, - 0x64, 0x3f, 0xea, 0x0d, 0x98, 0x1e, 0xf8, 0xb6, 0x08, 0x7a, 0x31, 0xe5, 0x42, 0x44, 0xfe, 0x0d, - 0x92, 0xfd, 0x86, 0xd8, 0x05, 0x34, 0xf8, 0xfd, 0x1f, 0xb4, 0x2c, 0x5f, 0x81, 0xb4, 0x2f, 0x22, - 0x35, 0x2f, 0x8c, 0x8c, 0x1f, 0x31, 0xee, 0x9b, 0x0a, 0x2c, 0xa4, 0x7c, 0x86, 0x02, 0x5d, 0x4c, - 0xbb, 0x1d, 0x1b, 0xf2, 0x51, 0x8d, 0xe6, 0x2b, 0x07, 0x6b, 0x14, 0x11, 0xe2, 0xc0, 0x54, 0xe2, - 0x2b, 0x0c, 0xe8, 0x7c, 0xea, 0xd3, 0xd1, 0xc1, 0x4f, 0x54, 0x34, 0xbf, 0x34, 0x1a, 0x72, 0x34, - 0xde, 0x47, 0x30, 0x95, 0xf8, 0x04, 0x41, 0xca, 0x78, 0xf2, 0x0f, 0x15, 0xec, 0xb7, 0xa0, 0x5f, - 0x85, 0x6a, 0xec, 0x5b, 0x01, 0x29, 0x12, 0x2f, 0xfb, 0x9e, 0xc0, 0x7e, 0x5d, 0x7f, 0x04, 0x15, - 0xf1, 0x49, 0x3f, 0x5a, 0x4a, 0xd3, 0xa5, 0x81, 0x8e, 0x0f, 0xa2, 0x4a, 0xfd, 0xa7, 0xb8, 0x43, - 0x54, 0x69, 0xe0, 0xf5, 0xf2, 0xe8, 0xaa, 0x24, 0xf4, 0x3f, 0x54, 0x95, 0x0e, 0x3c, 0xc4, 0xd7, - 0x15, 0x7a, 0x3d, 0x2f, 0x79, 0xea, 0x8d, 0x56, 0xd2, 0x64, 0x33, 0xfd, 0x51, 0x7b, 0xf3, 0xe2, - 0x81, 0xda, 0x44, 0x5c, 0x7c, 0x00, 0xb5, 0xf8, 0x83, 0xe6, 0x14, 0x2e, 0x4a, 0xdf, 0x80, 0x37, - 0xcf, 0x8f, 0x84, 0x1b, 0x0d, 0xf6, 0x3e, 0x94, 0x85, 0x2f, 0x42, 0xa2, 0xe7, 0x87, 0xc8, 0xb1, - 0xf8, 0x79, 0xc4, 0xfd, 0x38, 0xf9, 0x1e, 0x94, 0xa2, 0x0f, 0x39, 0xa2, 0xb3, 0xa9, 0xf2, 0x7b, - 0x90, 0x2e, 0x37, 0x00, 0xfa, 0x5f, 0x69, 0x44, 0xcf, 0x49, 0xfb, 0x1c, 0xf8, 0x8c, 0xe3, 0x7e, - 0x9d, 0x46, 0xd3, 0x67, 0x2f, 0x3e, 0x86, 0x4d, 0x5f, 0x7c, 0xb4, 0xb4, 0x5f, 0xb7, 0xdb, 0x50, - 0x8d, 0x3d, 0x3e, 0x4c, 0x53, 0x61, 0xc9, 0xe3, 0xd0, 0xe6, 0xb9, 0x51, 0x50, 0xa3, 0xf5, 0xdb, - 0x86, 0x6a, 0xec, 0xe1, 0x57, 0xca, 0x48, 0xb2, 0x07, 0x6f, 0x29, 0x23, 0x49, 0xdf, 0x91, 0xa9, - 0x13, 0xe8, 0x6b, 0xc2, 0x1b, 0xb3, 0xd8, 0x83, 0x3e, 0xf4, 0xf2, 0xd0, 0x7e, 0x64, 0x0f, 0x1b, - 0x9b, 0x2b, 0x07, 0x69, 0x12, 0x91, 0xc0, 0xa5, 0x8a, 0xb1, 0x34, 0x5d, 0xaa, 0x0e, 0xb2, 0x52, - 0x1b, 0x90, 0x67, 0x2f, 0xb8, 0x90, 0x9a, 0xf2, 0x8c, 0x53, 0x78, 0xde, 0xd5, 0x7c, 0x46, 0x8a, - 0x13, 0x7f, 0xd3, 0xc4, 0x3a, 0x65, 0x37, 0xa5, 0x29, 0x9d, 0xc6, 0x5e, 0xed, 0x8c, 0xda, 0xa9, - 0x06, 0x79, 0xf6, 0x8c, 0x20, 0xa5, 0xd3, 0xd8, 0x1b, 0x99, 0xe6, 0x70, 0x1c, 0x76, 0xde, 0x9d, - 0x40, 0xeb, 0x90, 0xa3, 0xe1, 0x67, 0x74, 0x66, 0x58, 0x62, 0xfd, 0xb0, 0x1e, 0x63, 0xb9, 0xf7, - 0xea, 0x04, 0xba, 0x07, 0x39, 0x1a, 0xc0, 0x4b, 0xe9, 0x51, 0xcc, 0x8e, 0x6f, 0x0e, 0x45, 0x09, - 0x49, 0x34, 0xa1, 0x22, 0x66, 0xc2, 0xa6, 0x6c, 0x59, 0x92, 0x5c, 0xe1, 0xe6, 0x28, 0x98, 0xe1, - 0x28, 0x4c, 0x8d, 0xfa, 0xa1, 0xf8, 0x74, 0x35, 0x1a, 0x08, 0xf3, 0xa7, 0xab, 0xd1, 0x60, 0x64, - 0x5f, 0x9d, 0x40, 0xbf, 0xa4, 0x40, 0x23, 0x2d, 0x3d, 0x13, 0xa5, 0x7a, 0x40, 0xc3, 0x72, 0x4c, - 0x9b, 0xaf, 0x1e, 0xb0, 0x55, 0x44, 0xcb, 0x27, 0x34, 0xee, 0x37, 0x90, 0x90, 0x79, 0x21, 0xad, - 0xbf, 0x94, 0x24, 0xc3, 0xe6, 0x4b, 0xa3, 0x37, 0x88, 0xc6, 0xde, 0x84, 0xb2, 0x10, 0x73, 0x4c, - 0xb1, 0xbc, 0x83, 0xc1, 0xd2, 0x94, 0x55, 0x95, 0x84, 0x2f, 0x99, 0x78, 0xd3, 0x2c, 0xbe, 0x14, - 0x61, 0x14, 0x93, 0x02, 0x53, 0xc4, 0x3b, 0x96, 0x04, 0xa8, 0x4e, 0x20, 0x0c, 0x15, 0x31, 0xa5, - 0x2f, 0x45, 0x1a, 0x25, 0xd9, 0x80, 0xcd, 0x17, 0x46, 0xc0, 0x8c, 0x86, 0xd1, 0x01, 0xfa, 0x29, - 0x75, 0x29, 0x7b, 0xdd, 0x40, 0x56, 0x5f, 0xf3, 0xf9, 0x7d, 0xf1, 0xc4, 0x6d, 0x5f, 0x48, 0x92, - 0x4b, 0xe1, 0xfe, 0x60, 0x1a, 0xdd, 0x08, 0x67, 0x91, 0xc1, 0xb4, 0xab, 0x94, 0xb3, 0x48, 0x6a, - 0x86, 0x57, 0xf3, 0xc2, 0xc8, 0xf8, 0xd1, 0x7c, 0x1e, 0x42, 0x3d, 0x99, 0xa6, 0x96, 0x72, 0xc6, - 0x4d, 0xc9, 0x9a, 0x6b, 0xbe, 0x38, 0x22, 0xb6, 0xb8, 0x1f, 0x9e, 0x18, 0xa4, 0xe9, 0x67, 0xac, - 0x60, 0x9b, 0x66, 0x48, 0x8d, 0x32, 0x6b, 0x31, 0x19, 0x6b, 0x94, 0x59, 0xc7, 0x52, 0xaf, 0xf8, - 0xe6, 0x45, 0xb3, 0x0d, 0xd2, 0x36, 0x2f, 0x31, 0xe9, 0x27, 0x65, 0x9f, 0x89, 0x67, 0xc6, 0x30, - 0xf7, 0x33, 0x9e, 0xc5, 0x80, 0xce, 0x8d, 0x94, 0xea, 0x30, 0xcc, 0xfd, 0x94, 0xa7, 0x45, 0xb0, - 0xa3, 0x5b, 0x22, 0x49, 0x23, 0xe5, 0x28, 0x25, 0xcf, 0xf2, 0x48, 0x39, 0xba, 0xa5, 0xe4, 0x7d, - 0x50, 0xc5, 0xaa, 0x27, 0x23, 0xde, 0xc3, 0xef, 0x42, 0x92, 0xa1, 0xce, 0xfd, 0xaf, 0x2b, 0xea, - 0xc9, 0x50, 0x72, 0xca, 0x00, 0x29, 0x11, 0xe7, 0x11, 0x06, 0x48, 0x46, 0x61, 0x53, 0x06, 0x48, - 0x09, 0xd6, 0x8e, 0xe0, 0xbb, 0xc6, 0xa2, 0x9f, 0x29, 0x5b, 0xa1, 0x2c, 0x42, 0x9a, 0xb2, 0x15, - 0x4a, 0x03, 0xb7, 0xcc, 0xa3, 0xef, 0x07, 0x31, 0x53, 0xac, 0xdc, 0x40, 0x94, 0x73, 0x3f, 0xf2, - 0xef, 0x41, 0x31, 0x8c, 0x42, 0xa2, 0x67, 0x53, 0x5d, 0xc4, 0x03, 0x74, 0xf8, 0x11, 0x4c, 0x25, - 0x6e, 0xf0, 0x52, 0x44, 0x54, 0x1e, 0x85, 0xdc, 0x7f, 0x3d, 0xa1, 0x1f, 0xaf, 0x4a, 0x61, 0xc2, - 0x40, 0x1c, 0x30, 0xc5, 0xd4, 0x0f, 0x06, 0xbe, 0xc4, 0x01, 0x08, 0x61, 0x43, 0x07, 0x10, 0x42, - 0x55, 0x43, 0x07, 0x10, 0x83, 0x34, 0x4c, 0x22, 0x93, 0x17, 0x94, 0x29, 0x12, 0x99, 0x72, 0x5b, - 0xbc, 0x1f, 0x8b, 0x36, 0xa1, 0x2c, 0x5c, 0x79, 0xa3, 0x61, 0xa4, 0x89, 0x77, 0xf5, 0x29, 0xae, - 0x82, 0xe4, 0xf6, 0x5c, 0x9d, 0x58, 0xe9, 0x41, 0x65, 0xdd, 0x73, 0x1f, 0x85, 0x1f, 0x9c, 0xfc, - 0x9c, 0x36, 0xfa, 0xcb, 0x2d, 0xa8, 0x31, 0x04, 0x1d, 0x3f, 0x0a, 0x74, 0x77, 0xf3, 0x63, 0x74, - 0x72, 0x99, 0xfd, 0x1b, 0x87, 0xe5, 0xf0, 0xdf, 0x38, 0x2c, 0xdf, 0xb0, 0x6c, 0x7c, 0x8f, 0x67, - 0x41, 0xfe, 0x47, 0x61, 0xc8, 0xab, 0xbc, 0xe8, 0xca, 0x5a, 0xe3, 0xff, 0x49, 0xe2, 0x9d, 0x47, - 0xc1, 0xbd, 0xcd, 0x8f, 0xaf, 0x19, 0x9f, 0x5d, 0x29, 0x40, 0x6e, 0x65, 0xf9, 0xe5, 0xe5, 0x97, - 0xa0, 0x66, 0x45, 0xe8, 0x6d, 0xaf, 0xdb, 0xba, 0x56, 0x66, 0x8d, 0xd6, 0x49, 0x3f, 0xeb, 0xca, - 0xcf, 0x5e, 0x6c, 0x5b, 0xc1, 0x76, 0x6f, 0x93, 0x2c, 0xc1, 0x05, 0x86, 0xf6, 0xa2, 0xe5, 0xf2, - 0x5f, 0x17, 0x2c, 0x27, 0xc0, 0x9e, 0x63, 0xd8, 0xec, 0x3f, 0x4c, 0x70, 0x68, 0x77, 0xf3, 0xf7, - 0x14, 0x65, 0x33, 0x4f, 0x41, 0x17, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xff, 0xb6, 0x47, 0x70, - 0xc3, 0x62, 0x00, 0x00, + 0xeb, 0x4a, 0x82, 0x09, 0xb7, 0xb6, 0x0c, 0xcb, 0x8e, 0xd0, 0xd8, 0x0d, 0x65, 0x0c, 0x36, 0xc0, + 0x6e, 0x02, 0xf6, 0x0f, 0xc2, 0xee, 0x7f, 0x56, 0x12, 0xec, 0xe6, 0x3d, 0x1c, 0x15, 0xbb, 0x6f, + 0x01, 0x74, 0xb0, 0xd7, 0xc6, 0x6b, 0x74, 0xcb, 0x60, 0x57, 0x07, 0x4b, 0xd2, 0x2d, 0xa3, 0xdf, + 0xc1, 0x9d, 0xb0, 0x81, 0x26, 0xb4, 0x55, 0x6f, 0xc2, 0x8c, 0x04, 0x85, 0x58, 0x43, 0xdf, 0xed, + 0x79, 0x2d, 0x1c, 0x5e, 0x43, 0x85, 0x45, 0xb2, 0x7b, 0x06, 0x86, 0xd7, 0xc6, 0x01, 0x17, 0x6c, + 0x5e, 0x52, 0x2f, 0xd1, 0xa0, 0x13, 0xbd, 0xa9, 0x88, 0x49, 0x73, 0x3c, 0xb6, 0xae, 0x0c, 0xc4, + 0xd6, 0xb7, 0x68, 0x60, 0x47, 0x6c, 0x37, 0x66, 0x5e, 0xc4, 0x16, 0xe9, 0x0a, 0x9b, 0xfc, 0x29, + 0x4e, 0x58, 0x54, 0xff, 0x57, 0x81, 0xea, 0x5a, 0xa7, 0xeb, 0xf6, 0x43, 0x19, 0x23, 0x1f, 0x61, + 0x07, 0x6f, 0x80, 0x33, 0xb2, 0x1b, 0xe0, 0x67, 0xa0, 0x1a, 0x7f, 0xb4, 0xc1, 0x6e, 0x98, 0x2a, + 0x2d, 0xf1, 0xb1, 0xc6, 0x09, 0x28, 0x79, 0xee, 0xae, 0x4e, 0x0c, 0xb0, 0xc9, 0x33, 0x30, 0x8a, + 0x9e, 0xbb, 0x4b, 0xcc, 0xb2, 0x89, 0x66, 0x21, 0xb7, 0x65, 0xd9, 0x51, 0xf2, 0x10, 0x2b, 0xa0, + 0x37, 0xc8, 0x01, 0x8f, 0xc5, 0x63, 0xf3, 0xa3, 0x9e, 0xb3, 0xc2, 0x16, 0xcc, 0xce, 0xa1, 0x86, + 0xa2, 0x7e, 0x08, 0xb5, 0x70, 0xfa, 0x63, 0x3e, 0x46, 0x0a, 0x0c, 0xff, 0x41, 0x98, 0x25, 0xc1, + 0x0a, 0xea, 0x79, 0x16, 0x9d, 0xa3, 0xfd, 0xc7, 0x56, 0x1f, 0xc1, 0x24, 0xc1, 0xe0, 0x4a, 0x45, + 0x7f, 0xab, 0x7f, 0x97, 0x81, 0xf9, 0x24, 0xf6, 0x38, 0x24, 0x5d, 0x8a, 0x2b, 0x92, 0xfc, 0x6d, + 0x89, 0x38, 0x1a, 0x57, 0x22, 0xbe, 0x14, 0x2d, 0xb7, 0xe7, 0x04, 0xdc, 0x5a, 0x91, 0xa5, 0xb8, + 0x4e, 0xca, 0x68, 0x01, 0x0a, 0x96, 0xa9, 0xdb, 0xe4, 0x50, 0xc8, 0xb6, 0xb4, 0xbc, 0x65, 0xde, + 0x26, 0x07, 0xc6, 0xd7, 0x42, 0x47, 0x6d, 0xe4, 0xd4, 0x0a, 0x86, 0x8f, 0x6a, 0x90, 0xb1, 0x4c, + 0x6e, 0x9e, 0x32, 0x96, 0x49, 0xa4, 0x8a, 0xde, 0x26, 0xd0, 0x34, 0x60, 0x9e, 0x17, 0x4c, 0xc4, + 0xa1, 0x4a, 0xa0, 0xef, 0x85, 0x40, 0xe2, 0xcb, 0x51, 0x34, 0x1e, 0x00, 0xa6, 0xfe, 0x76, 0x51, + 0x2b, 0x13, 0xd8, 0x1a, 0x03, 0xa9, 0x0d, 0x98, 0x27, 0xa4, 0xb1, 0x29, 0xde, 0x27, 0x0b, 0x12, + 0x7a, 0x68, 0xdf, 0x53, 0x60, 0x61, 0xa0, 0x6a, 0x1c, 0x5e, 0x5f, 0x15, 0x97, 0xbf, 0xbc, 0x72, + 0x5e, 0x6a, 0x73, 0xe4, 0x8b, 0x1b, 0xca, 0xca, 0xaf, 0x31, 0x77, 0x4a, 0x63, 0xa9, 0x9f, 0x8f, + 0x39, 0x91, 0x68, 0x09, 0xea, 0xbb, 0x56, 0xb0, 0xad, 0xd3, 0xd7, 0x4a, 0xd4, 0x97, 0x61, 0x01, + 0xf3, 0xa2, 0x56, 0x23, 0xf0, 0x0d, 0x02, 0x26, 0xfe, 0x8c, 0xaf, 0x7e, 0x4b, 0x81, 0x99, 0x18, + 0x59, 0xe3, 0xb0, 0xe9, 0x4d, 0xe2, 0xe6, 0xb1, 0x8e, 0x38, 0xa7, 0x16, 0xa5, 0x9c, 0xe2, 0xa3, + 0x51, 0xab, 0x1c, 0xb5, 0x50, 0x7f, 0xac, 0x40, 0x59, 0xa8, 0x21, 0xe7, 0x47, 0x5e, 0xd7, 0x3f, + 0x3f, 0x46, 0x80, 0x91, 0xd8, 0xf0, 0x0c, 0xf4, 0x6d, 0x95, 0x90, 0x4a, 0x2f, 0xe4, 0xf2, 0x99, + 0x3e, 0xba, 0x05, 0x35, 0xc6, 0xa6, 0x88, 0x74, 0xe9, 0xb5, 0x4e, 0x94, 0xa5, 0x68, 0x78, 0x26, + 0xa7, 0x52, 0xab, 0xfa, 0x42, 0x89, 0xc5, 0x4a, 0x5d, 0x13, 0xd3, 0x91, 0x72, 0x03, 0xa7, 0xb9, + 0x8a, 0xd8, 0x94, 0x78, 0xc4, 0x36, 0x36, 0x4c, 0xec, 0x45, 0x73, 0x8b, 0xca, 0xc4, 0x05, 0x65, + 0xbf, 0x75, 0x72, 0x42, 0xe0, 0x56, 0x17, 0x18, 0x88, 0x1c, 0x1e, 0xd0, 0x73, 0x30, 0x65, 0x76, + 0x62, 0x4f, 0xe5, 0x42, 0x9f, 0xd9, 0xec, 0x08, 0x6f, 0xe4, 0x62, 0x04, 0x4d, 0xc6, 0x09, 0xfa, + 0x46, 0xff, 0xf1, 0xb1, 0x87, 0x4d, 0xec, 0x04, 0x96, 0x61, 0x1f, 0x5e, 0x26, 0x9b, 0x50, 0xec, + 0xf9, 0xd8, 0x13, 0x36, 0x89, 0xa8, 0x4c, 0xea, 0xba, 0x86, 0xef, 0xef, 0xba, 0x9e, 0xc9, 0xa9, + 0x8c, 0xca, 0x43, 0x12, 0x23, 0xd9, 0x83, 0x55, 0x79, 0x62, 0xe4, 0x25, 0x58, 0xe8, 0xb8, 0xa6, + 0xb5, 0x65, 0xc9, 0xf2, 0x29, 0x49, 0xb3, 0xb9, 0xb0, 0x3a, 0xd6, 0x2e, 0x7c, 0xea, 0x31, 0x23, + 0x3e, 0xf5, 0xf8, 0x41, 0x06, 0x16, 0xde, 0xef, 0x9a, 0x9f, 0x03, 0x1f, 0x16, 0xa1, 0xec, 0xda, + 0xe6, 0x7a, 0x9c, 0x15, 0x22, 0x88, 0x60, 0x38, 0x78, 0x37, 0xc2, 0x60, 0x17, 0xfd, 0x22, 0x68, + 0x68, 0x22, 0xe9, 0xa1, 0xf8, 0x95, 0x1f, 0xc6, 0xaf, 0xd2, 0x67, 0x57, 0xf2, 0xc5, 0x4c, 0x7d, + 0xb6, 0x91, 0x51, 0x7f, 0x1e, 0x16, 0x58, 0x48, 0xfa, 0x31, 0x73, 0x29, 0x5c, 0xa3, 0x39, 0x71, + 0x8d, 0x3e, 0x86, 0x39, 0x62, 0xcd, 0xc9, 0xd0, 0xef, 0xfb, 0xd8, 0x1b, 0xd3, 0x48, 0x9d, 0x84, + 0x52, 0x38, 0x5a, 0x98, 0x02, 0xdc, 0x07, 0xa8, 0x3f, 0x07, 0xb3, 0x89, 0xb1, 0x0e, 0x39, 0xcb, + 0x70, 0x26, 0xf3, 0xe2, 0x4c, 0x16, 0x01, 0x34, 0xd7, 0xc6, 0xef, 0x38, 0x81, 0x15, 0xec, 0x11, + 0x2f, 0x41, 0x70, 0xbf, 0xe8, 0x6f, 0x82, 0x41, 0xc6, 0x1d, 0x82, 0xf1, 0x2b, 0x0a, 0x4c, 0x33, + 0xcd, 0x25, 0x5d, 0x1d, 0x7e, 0x15, 0x5e, 0x83, 0x3c, 0xa6, 0xa3, 0xf0, 0x5b, 0x87, 0xd3, 0x72, + 0x53, 0x1d, 0x91, 0xab, 0x71, 0x74, 0xa9, 0x1a, 0x05, 0x30, 0xb5, 0xea, 0xb9, 0xdd, 0xf1, 0x28, + 0xa2, 0x9e, 0x89, 0x8d, 0x45, 0x5f, 0xb3, 0x48, 0x00, 0x77, 0xd3, 0x04, 0xe3, 0x9f, 0x14, 0x98, + 0xbf, 0xd7, 0xc5, 0x9e, 0x11, 0x60, 0xc2, 0xb4, 0xf1, 0x46, 0x1f, 0xa6, 0xbb, 0x31, 0xca, 0xb2, + 0x71, 0xca, 0xd0, 0x9b, 0xb1, 0xf7, 0x69, 0xf2, 0xf3, 0x48, 0x82, 0xca, 0x7e, 0x9e, 0x7b, 0x38, + 0xaf, 0x05, 0x71, 0x5e, 0x3f, 0x52, 0x60, 0x7a, 0x03, 0x93, 0x7d, 0x6c, 0xbc, 0x29, 0x5d, 0x84, + 0x49, 0x42, 0xe5, 0xa8, 0x0b, 0x4c, 0x91, 0xd1, 0x39, 0x98, 0xb6, 0x9c, 0x96, 0xdd, 0x33, 0xb1, + 0x4e, 0xe6, 0xaf, 0x13, 0x37, 0x8e, 0x3b, 0x0f, 0x53, 0xbc, 0x82, 0x4c, 0x83, 0x6c, 0xd1, 0x52, + 0x19, 0x7f, 0xc4, 0x64, 0x3c, 0x4a, 0x04, 0x62, 0x24, 0x28, 0x07, 0x21, 0xe1, 0x55, 0xc8, 0x91, + 0xa1, 0x43, 0x27, 0x42, 0xde, 0xaa, 0xaf, 0x26, 0x1a, 0xc3, 0x56, 0x7f, 0x41, 0x01, 0x24, 0xb2, + 0x6d, 0x1c, 0x2b, 0xf1, 0xba, 0x98, 0x00, 0x90, 0x1d, 0x4a, 0x3a, 0x9b, 0x69, 0x14, 0xfa, 0x57, + 0x3f, 0x8d, 0x56, 0x8f, 0x2e, 0xf7, 0x38, 0xab, 0x47, 0xe6, 0x35, 0x74, 0xf5, 0x04, 0x26, 0x50, + 0x64, 0x71, 0xf5, 0xa8, 0xc4, 0x4a, 0x56, 0x8f, 0xd0, 0x4c, 0x57, 0x8f, 0xdb, 0xf7, 0x46, 0x23, + 0x43, 0x16, 0x8d, 0x11, 0x1b, 0x2e, 0x1a, 0x1d, 0x59, 0x39, 0xc8, 0xc8, 0xaf, 0x42, 0x8e, 0x8c, + 0xb8, 0x3f, 0xbf, 0xc2, 0x45, 0xa3, 0xd8, 0xc2, 0xa2, 0x71, 0x02, 0x1e, 0xff, 0xa2, 0xf5, 0x67, + 0xda, 0x5f, 0x34, 0x15, 0x2a, 0xf7, 0x36, 0x3f, 0xc6, 0xad, 0x60, 0x88, 0xe5, 0x3d, 0x0b, 0x53, + 0xeb, 0x9e, 0xb5, 0x63, 0xd9, 0xb8, 0x3d, 0xcc, 0x84, 0x7f, 0x4b, 0x81, 0xea, 0x4d, 0xcf, 0x70, + 0x02, 0x37, 0x34, 0xe3, 0x87, 0xe2, 0xe7, 0x35, 0x28, 0x75, 0xc3, 0xd1, 0xb8, 0x0c, 0x3c, 0x2b, + 0x8f, 0xcc, 0xc4, 0x69, 0xd2, 0xfa, 0xcd, 0xd4, 0x0f, 0x60, 0x96, 0x52, 0x92, 0x24, 0xfb, 0x0a, + 0x14, 0xa9, 0x31, 0xb7, 0xf8, 0x45, 0x47, 0x79, 0x45, 0x95, 0x1f, 0x69, 0xc4, 0x69, 0x68, 0x51, + 0x1b, 0xf5, 0xdf, 0x14, 0x28, 0xd3, 0xba, 0xfe, 0x04, 0x0f, 0xae, 0xe5, 0xaf, 0x43, 0xde, 0xa5, + 0x2c, 0x1f, 0x1a, 0xc0, 0x15, 0x57, 0x45, 0xe3, 0x0d, 0x88, 0x87, 0xcc, 0x7e, 0x89, 0x16, 0x19, + 0x18, 0x88, 0xdb, 0xe4, 0x42, 0x9b, 0xd1, 0x4e, 0xcd, 0xf2, 0x68, 0xf3, 0x0b, 0x9b, 0xd0, 0xb3, + 0x1a, 0x93, 0x49, 0x8a, 0x70, 0x78, 0x15, 0xfe, 0x72, 0x62, 0x8f, 0x5d, 0x4c, 0xa7, 0x42, 0xbe, + 0xc9, 0xc6, 0x2c, 0x2b, 0x39, 0xab, 0xc5, 0xc8, 0x1a, 0xf3, 0xac, 0x16, 0x89, 0xc0, 0xb0, 0xb3, + 0x9a, 0x48, 0x5c, 0x5f, 0x00, 0xfe, 0x45, 0x81, 0x05, 0xbe, 0xa7, 0x45, 0xb2, 0x75, 0x04, 0x6c, + 0x42, 0x5f, 0xe1, 0x7b, 0x6f, 0x96, 0xee, 0xbd, 0x2f, 0x0c, 0xdb, 0x7b, 0x23, 0x3a, 0xf7, 0xd9, + 0x7c, 0xcf, 0x42, 0xe9, 0x0e, 0x6d, 0xf8, 0xce, 0xa3, 0x00, 0x35, 0xa0, 0xb0, 0x83, 0x3d, 0xdf, + 0x72, 0x1d, 0xae, 0xe2, 0x61, 0xf1, 0xdc, 0x19, 0x28, 0x86, 0x2f, 0xd6, 0x50, 0x01, 0xb2, 0x57, + 0x6d, 0xbb, 0x3e, 0x81, 0x2a, 0x50, 0x5c, 0xe3, 0xcf, 0xb2, 0xea, 0xca, 0xb9, 0xb7, 0x61, 0x46, + 0xb2, 0xef, 0xa3, 0x69, 0xa8, 0x5e, 0x35, 0xa9, 0x77, 0x79, 0xdf, 0x25, 0xc0, 0xfa, 0x04, 0x9a, + 0x07, 0xa4, 0xe1, 0x8e, 0xbb, 0x43, 0x11, 0x6f, 0x78, 0x6e, 0x87, 0xc2, 0x95, 0x73, 0x2f, 0xc2, + 0xac, 0x8c, 0x7a, 0x54, 0x82, 0x1c, 0xe5, 0x46, 0x7d, 0x02, 0x01, 0xe4, 0x35, 0xbc, 0xe3, 0x3e, + 0xc0, 0x75, 0x65, 0xe5, 0xcf, 0xcf, 0x41, 0x95, 0xd1, 0xce, 0xdf, 0x57, 0x23, 0x1d, 0xea, 0xc9, + 0x4f, 0x4c, 0xa1, 0x2f, 0xc9, 0x6f, 0x4c, 0xe5, 0x5f, 0xa2, 0x6a, 0x0e, 0x13, 0x26, 0x75, 0x02, + 0x7d, 0x08, 0xb5, 0xf8, 0x47, 0x99, 0x90, 0x3c, 0x7c, 0x2c, 0xfd, 0x72, 0xd3, 0x7e, 0x9d, 0xeb, + 0x50, 0x8d, 0x7d, 0x4f, 0x09, 0xc9, 0x17, 0x58, 0xf6, 0xcd, 0xa5, 0xa6, 0xdc, 0x9a, 0x88, 0xdf, + 0x3c, 0x62, 0xd4, 0xc7, 0x3f, 0x70, 0x92, 0x42, 0xbd, 0xf4, 0x2b, 0x28, 0xfb, 0x51, 0x6f, 0xc0, + 0xf4, 0xc0, 0xf7, 0x47, 0xd0, 0x8b, 0x29, 0x17, 0x22, 0xf2, 0xef, 0x94, 0xec, 0x37, 0xc4, 0x2e, + 0xa0, 0xc1, 0x6f, 0x04, 0xa1, 0x65, 0xf9, 0x0a, 0xa4, 0x7d, 0x35, 0xa9, 0x79, 0x61, 0x64, 0xfc, + 0x88, 0x71, 0xdf, 0x54, 0x60, 0x21, 0xe5, 0x53, 0x15, 0xe8, 0x62, 0xda, 0xed, 0xd8, 0x90, 0x0f, + 0x6f, 0x34, 0x5f, 0x39, 0x58, 0xa3, 0x88, 0x10, 0x07, 0xa6, 0x12, 0x5f, 0x6a, 0x40, 0xe7, 0x53, + 0x9f, 0x97, 0x0e, 0x7e, 0xc6, 0xa2, 0xf9, 0xa5, 0xd1, 0x90, 0xa3, 0xf1, 0x3e, 0x82, 0xa9, 0xc4, + 0x67, 0x0a, 0x52, 0xc6, 0x93, 0x7f, 0xcc, 0x60, 0xbf, 0x05, 0xfd, 0x2a, 0x54, 0x63, 0xdf, 0x13, + 0x48, 0x91, 0x78, 0xd9, 0x37, 0x07, 0xf6, 0xeb, 0xfa, 0x23, 0xa8, 0x88, 0xcf, 0xfe, 0xd1, 0x52, + 0x9a, 0x2e, 0x0d, 0x74, 0x7c, 0x10, 0x55, 0xea, 0x3f, 0xd7, 0x1d, 0xa2, 0x4a, 0x03, 0x2f, 0x9c, + 0x47, 0x57, 0x25, 0xa1, 0xff, 0xa1, 0xaa, 0x74, 0xe0, 0x21, 0xbe, 0xae, 0xd0, 0xeb, 0x79, 0xc9, + 0x73, 0x70, 0xb4, 0x92, 0x26, 0x9b, 0xe9, 0x0f, 0xdf, 0x9b, 0x17, 0x0f, 0xd4, 0x26, 0xe2, 0xe2, + 0x03, 0xa8, 0xc5, 0x1f, 0x3d, 0xa7, 0x70, 0x51, 0xfa, 0x4e, 0xbc, 0x79, 0x7e, 0x24, 0xdc, 0x68, + 0xb0, 0xf7, 0xa1, 0x2c, 0x7c, 0x35, 0x12, 0x3d, 0x3f, 0x44, 0x8e, 0xc5, 0x4f, 0x28, 0xee, 0xc7, + 0xc9, 0xf7, 0xa0, 0x14, 0x7d, 0xec, 0x11, 0x9d, 0x4d, 0x95, 0xdf, 0x83, 0x74, 0xb9, 0x01, 0xd0, + 0xff, 0x92, 0x23, 0x7a, 0x4e, 0xda, 0xe7, 0xc0, 0xa7, 0x1e, 0xf7, 0xeb, 0x34, 0x9a, 0x3e, 0x7b, + 0x15, 0x32, 0x6c, 0xfa, 0xe2, 0xc3, 0xa6, 0xfd, 0xba, 0xdd, 0x86, 0x6a, 0xec, 0x81, 0x62, 0x9a, + 0x0a, 0x4b, 0x1e, 0x90, 0x36, 0xcf, 0x8d, 0x82, 0x1a, 0xad, 0xdf, 0x36, 0x54, 0x63, 0x8f, 0xc3, + 0x52, 0x46, 0x92, 0x3d, 0x8a, 0x4b, 0x19, 0x49, 0xfa, 0xd6, 0x4c, 0x9d, 0x40, 0x5f, 0x13, 0xde, + 0xa1, 0xc5, 0x1e, 0xfd, 0xa1, 0x97, 0x87, 0xf6, 0x23, 0x7b, 0xfc, 0xd8, 0x5c, 0x39, 0x48, 0x93, + 0x88, 0x04, 0x2e, 0x55, 0x8c, 0xa5, 0xe9, 0x52, 0x75, 0x90, 0x95, 0xda, 0x80, 0x3c, 0x7b, 0xe5, + 0x85, 0xd4, 0x94, 0xa7, 0x9e, 0xc2, 0x13, 0xb0, 0xe6, 0x33, 0x52, 0x9c, 0xf8, 0xbb, 0x27, 0xd6, + 0x29, 0xbb, 0x29, 0x4d, 0xe9, 0x34, 0xf6, 0xb2, 0x67, 0xd4, 0x4e, 0x35, 0xc8, 0xb3, 0xa7, 0x06, + 0x29, 0x9d, 0xc6, 0xde, 0xd1, 0x34, 0x87, 0xe3, 0xb0, 0xf3, 0xee, 0x04, 0x5a, 0x87, 0x1c, 0x0d, + 0x3f, 0xa3, 0x33, 0xc3, 0x92, 0xef, 0x87, 0xf5, 0x18, 0xcb, 0xcf, 0x57, 0x27, 0xd0, 0x3d, 0xc8, + 0xd1, 0x00, 0x5e, 0x4a, 0x8f, 0x62, 0x06, 0x7d, 0x73, 0x28, 0x4a, 0x48, 0xa2, 0x09, 0x15, 0x31, + 0x5b, 0x36, 0x65, 0xcb, 0x92, 0xe4, 0x13, 0x37, 0x47, 0xc1, 0x0c, 0x47, 0x61, 0x6a, 0xd4, 0x0f, + 0xc5, 0xa7, 0xab, 0xd1, 0x40, 0x98, 0x3f, 0x5d, 0x8d, 0x06, 0x23, 0xfb, 0xea, 0x04, 0xfa, 0x45, + 0x05, 0x1a, 0x69, 0x29, 0x9c, 0x28, 0xd5, 0x03, 0x1a, 0x96, 0x87, 0xda, 0x7c, 0xf5, 0x80, 0xad, + 0x22, 0x5a, 0x3e, 0xa1, 0x71, 0xbf, 0x81, 0xa4, 0xcd, 0x0b, 0x69, 0xfd, 0xa5, 0x24, 0x22, 0x36, + 0x5f, 0x1a, 0xbd, 0x41, 0x34, 0xf6, 0x26, 0x94, 0x85, 0x98, 0x63, 0x8a, 0xe5, 0x1d, 0x0c, 0x96, + 0xa6, 0xac, 0xaa, 0x24, 0x7c, 0xc9, 0xc4, 0x9b, 0x66, 0xfa, 0xa5, 0x08, 0xa3, 0x98, 0x38, 0x98, + 0x22, 0xde, 0xb1, 0x44, 0x41, 0x75, 0x02, 0x61, 0xa8, 0x88, 0x69, 0x7f, 0x29, 0xd2, 0x28, 0xc9, + 0x18, 0x6c, 0xbe, 0x30, 0x02, 0x66, 0x34, 0x8c, 0x0e, 0xd0, 0x4f, 0xbb, 0x4b, 0xd9, 0xeb, 0x06, + 0x32, 0xff, 0x9a, 0xcf, 0xef, 0x8b, 0x27, 0x6e, 0xfb, 0x42, 0x22, 0x5d, 0x0a, 0xf7, 0x07, 0x53, + 0xed, 0x46, 0x38, 0x8b, 0x0c, 0xa6, 0x66, 0xa5, 0x9c, 0x45, 0x52, 0xb3, 0xc0, 0x9a, 0x17, 0x46, + 0xc6, 0x8f, 0xe6, 0xf3, 0x10, 0xea, 0xc9, 0x54, 0xb6, 0x94, 0x33, 0x6e, 0x4a, 0x66, 0x5d, 0xf3, + 0xc5, 0x11, 0xb1, 0xc5, 0xfd, 0xf0, 0xc4, 0x20, 0x4d, 0x3f, 0x63, 0x05, 0xdb, 0x34, 0x43, 0x6a, + 0x94, 0x59, 0x8b, 0xc9, 0x58, 0xa3, 0xcc, 0x3a, 0x96, 0x7a, 0xc5, 0x37, 0x2f, 0x9a, 0x6d, 0x90, + 0xb6, 0x79, 0x89, 0x49, 0x3f, 0x29, 0xfb, 0x4c, 0x3c, 0x33, 0x86, 0xb9, 0x9f, 0xf1, 0x2c, 0x06, + 0x74, 0x6e, 0xa4, 0x54, 0x87, 0x61, 0xee, 0xa7, 0x3c, 0x2d, 0x82, 0x1d, 0xdd, 0x12, 0x49, 0x1a, + 0x29, 0x47, 0x29, 0x79, 0x96, 0x47, 0xca, 0xd1, 0x2d, 0x25, 0xef, 0x83, 0x2a, 0x56, 0x3d, 0x19, + 0xf1, 0x1e, 0x7e, 0x17, 0x92, 0x0c, 0x75, 0xee, 0x7f, 0x5d, 0x51, 0x4f, 0x86, 0x92, 0x53, 0x06, + 0x48, 0x89, 0x38, 0x8f, 0x30, 0x40, 0x32, 0x0a, 0x9b, 0x32, 0x40, 0x4a, 0xb0, 0x76, 0x04, 0xdf, + 0x35, 0x16, 0xfd, 0x4c, 0xd9, 0x0a, 0x65, 0x11, 0xd2, 0x94, 0xad, 0x50, 0x1a, 0xb8, 0x65, 0x1e, + 0x7d, 0x3f, 0x88, 0x99, 0x62, 0xe5, 0x06, 0xa2, 0x9c, 0xfb, 0x91, 0x7f, 0x0f, 0x8a, 0x61, 0x14, + 0x12, 0x3d, 0x9b, 0xea, 0x22, 0x1e, 0xa0, 0xc3, 0x8f, 0x60, 0x2a, 0x71, 0x83, 0x97, 0x22, 0xa2, + 0xf2, 0x28, 0xe4, 0xfe, 0xeb, 0x09, 0xfd, 0x78, 0x55, 0x0a, 0x13, 0x06, 0xe2, 0x80, 0x29, 0xa6, + 0x7e, 0x30, 0xf0, 0x25, 0x0e, 0x40, 0x08, 0x1b, 0x3a, 0x80, 0x10, 0xaa, 0x1a, 0x3a, 0x80, 0x18, + 0xa4, 0x61, 0x12, 0x99, 0xbc, 0xa0, 0x4c, 0x91, 0xc8, 0x94, 0xdb, 0xe2, 0xfd, 0x58, 0xb4, 0x09, + 0x65, 0xe1, 0xca, 0x1b, 0x0d, 0x23, 0x4d, 0xbc, 0xab, 0x4f, 0x71, 0x15, 0x24, 0xb7, 0xe7, 0xea, + 0xc4, 0x4a, 0x0f, 0x2a, 0xeb, 0x9e, 0xfb, 0x28, 0xfc, 0x28, 0xe5, 0xe7, 0xb4, 0xd1, 0x5f, 0x6e, + 0x41, 0x8d, 0x21, 0xe8, 0xf8, 0x51, 0xa0, 0xbb, 0x9b, 0x1f, 0xa3, 0x93, 0xcb, 0xec, 0x5f, 0x3d, + 0x2c, 0x87, 0xff, 0xea, 0x61, 0xf9, 0x86, 0x65, 0xe3, 0x7b, 0x3c, 0x0b, 0xf2, 0x3f, 0x0a, 0x43, + 0x5e, 0xee, 0x45, 0x57, 0xd6, 0x1a, 0xff, 0x6f, 0x13, 0xef, 0x3c, 0x0a, 0xee, 0x6d, 0x7e, 0x7c, + 0xcd, 0xf8, 0xec, 0x4a, 0x01, 0x72, 0x2b, 0xcb, 0x2f, 0x2f, 0xbf, 0x04, 0x35, 0x2b, 0x42, 0x6f, + 0x7b, 0xdd, 0xd6, 0xb5, 0x32, 0x6b, 0xb4, 0x4e, 0xfa, 0x59, 0x57, 0x7e, 0xf6, 0x62, 0xdb, 0x0a, + 0xb6, 0x7b, 0x9b, 0x64, 0x09, 0x2e, 0x30, 0xb4, 0x17, 0x2d, 0x97, 0xff, 0xba, 0x60, 0x39, 0x01, + 0xf6, 0x1c, 0xc3, 0x66, 0xff, 0x85, 0x82, 0x43, 0xbb, 0x9b, 0xbf, 0xab, 0x28, 0x9b, 0x79, 0x0a, + 0xba, 0xf8, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd9, 0xc9, 0x1c, 0xd6, 0xe7, 0x62, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/internal/types/types.go b/internal/types/types.go index c1529dfa03..6f762aff1c 100644 --- a/internal/types/types.go +++ b/internal/types/types.go @@ -64,12 +64,15 @@ type DataNode interface { // Log an info log if a segment is under flushing FlushSegments(ctx context.Context, req *datapb.FlushSegmentsRequest) (*commonpb.Status, error) - // ShowConfigurations gets specified configurations para of DataNode + // ShowConfigurations gets specified configurations param of DataNode ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) // GetMetrics gets the metrics about DataNode. GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) + // Compaction will add a compaction task according to the request plan Compaction(ctx context.Context, req *datapb.CompactionPlan) (*commonpb.Status, error) + // GetCompactionState get states of all compation tasks + GetCompactionState(ctx context.Context, req *datapb.CompactionStateRequest) (*datapb.CompactionStateResponse, error) // Import data files(json, numpy, etc.) on MinIO/S3 storage, read and parse them into sealed segments // @@ -249,8 +252,6 @@ type DataCoord interface { ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) // GetMetrics gets the metrics about DataCoord. GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) - // CompleteCompaction completes a compaction with the result - CompleteCompaction(ctx context.Context, req *datapb.CompactionResult) (*commonpb.Status, error) // ManualCompaction triggers a compaction for a collection ManualCompaction(ctx context.Context, req *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) // GetCompactionState gets the state of a compaction diff --git a/internal/util/mock/grpc_datanode_client.go b/internal/util/mock/grpc_datanode_client.go index dcef1da495..360e80c320 100644 --- a/internal/util/mock/grpc_datanode_client.go +++ b/internal/util/mock/grpc_datanode_client.go @@ -61,6 +61,10 @@ func (m *GrpcDataNodeClient) Compaction(ctx context.Context, req *datapb.Compact return &commonpb.Status{}, m.Err } +func (m *GrpcDataNodeClient) GetCompactionState(ctx context.Context, in *datapb.CompactionStateRequest, opts ...grpc.CallOption) (*datapb.CompactionStateResponse, error) { + return &datapb.CompactionStateResponse{}, m.Err +} + func (m *GrpcDataNodeClient) Import(ctx context.Context, req *datapb.ImportTaskRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { return &commonpb.Status{}, m.Err } diff --git a/internal/util/paramtable/component_param.go b/internal/util/paramtable/component_param.go index 42a7ab1275..5fc81f28ea 100644 --- a/internal/util/paramtable/component_param.go +++ b/internal/util/paramtable/component_param.go @@ -928,6 +928,7 @@ type dataCoordConfig struct { MaxSegmentToMerge int SegmentSmallProportion float64 CompactionTimeoutInSeconds int32 + CompactionCheckIntervalInSeconds int64 SingleCompactionRatioThreshold float32 SingleCompactionDeltaLogMaxSize int64 SingleCompactionExpiredLogMaxSize int64 @@ -957,6 +958,7 @@ func (p *dataCoordConfig) init(base *BaseTable) { p.initCompactionMaxSegment() p.initSegmentSmallProportion() p.initCompactionTimeoutInSeconds() + p.initCompactionCheckIntervalInSeconds() p.initSingleCompactionRatioThreshold() p.initSingleCompactionDeltaLogMaxSize() p.initSingleCompactionExpiredLogMaxSize() @@ -1016,6 +1018,10 @@ func (p *dataCoordConfig) initCompactionTimeoutInSeconds() { p.CompactionTimeoutInSeconds = p.Base.ParseInt32WithDefault("dataCoord.compaction.timeout", 60*3) } +func (p *dataCoordConfig) initCompactionCheckIntervalInSeconds() { + p.CompactionCheckIntervalInSeconds = p.Base.ParseInt64WithDefault("dataCoord.compaction.check.interval", 10) +} + // if total delete entities is large than a ratio of total entities, trigger single compaction. func (p *dataCoordConfig) initSingleCompactionRatioThreshold() { p.SingleCompactionRatioThreshold = float32(p.Base.ParseFloatWithDefault("dataCoord.compaction.single.ratio.threshold", 0.2)) diff --git a/tests/python_client/testcases/test_compaction.py b/tests/python_client/testcases/test_compaction.py index 7f2f19cb5c..ce04eb5607 100644 --- a/tests/python_client/testcases/test_compaction.py +++ b/tests/python_client/testcases/test_compaction.py @@ -838,6 +838,10 @@ class TestCompactionOperation(TestcaseBase): # create collection shard_num=1, insert 11 segments, each with one entity collection_w = self.collection_insert_multi_segments_one_shard(prefix, num_of_segment=num_of_segment) + # waiting for auto compaction finished + collection_w.collection.compaction_id = 0 + collection_w.wait_for_compaction_completed() + collection_w.compact() collection_w.wait_for_compaction_completed() c_plans, _ = collection_w.get_compaction_plans(check_task=CheckTasks.check_merge_compact, check_items={"segment_num": 2})