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

Acquiring the segment reference lock on task level (#17544) 

Signed-off-by: Cai.Zhang <cai.zhang@zilliz.com>
pull/17575/head
cai.zhang 2022-06-15 21:38:10 +08:00 committed by GitHub
parent 875b6f88b0
commit ea5041aec2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 576 additions and 473 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
internal/datacoord/garbage_collector_test.go
View File

@ -122,15 +122,18 @@ func Test_garbageCollector_scan(t *testing.T) {
t.Run("key is reference", func(t *testing.T) {
segReferManager := &SegmentReferenceManager{
etcdKV: etcdKV,
segmentsLock: map[UniqueID][]*SegmentLock{
2: {
{
segmentID: 2,
nodeID: 1,
locKey: "path",
segmentsLock: map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock{
1: {
1: {
TaskID: 1,
NodeID: 1,
SegmentIDs: []UniqueID{2},
},
},
},
segmentReferCnt: map[UniqueID]int{
2: 1,
},
}
gc := newGarbageCollector(meta, segRefer, GcOption{
cli: cli,
@ -149,7 +152,7 @@ func Test_garbageCollector_scan(t *testing.T) {
validateMinioPrefixElements(t, cli, bucketName, path.Join(rootPath, deltaLogPrefix), delta)
validateMinioPrefixElements(t, cli, bucketName, path.Join(rootPath, `indexes`), others)
err = gc.segRefer.ReleaseSegmentsLock([]UniqueID{2}, 1)
err = gc.segRefer.ReleaseSegmentsLock(1, 1)
assert.NoError(t, err)
gc.close()
})

244
internal/datacoord/segment_reference_manager.go
View File

@ -17,143 +17,135 @@
package datacoord
import (
"fmt"
"path"
"strconv"
"strings"
"sync"
"go.uber.org/zap"
"github.com/golang/protobuf/proto"
"github.com/milvus-io/milvus/internal/kv"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/datapb"
"go.uber.org/zap"
)
type SegmentLock struct {
segmentID UniqueID
nodeID UniqueID
locKey string
}
type SegmentReferenceManager struct {
etcdKV kv.BaseKV
segmentsLock map[UniqueID][]*SegmentLock
lock sync.RWMutex
}
func parseLockKey(key string) (segID UniqueID, nodeID UniqueID, err error) {
ss := strings.Split(key, "/")
// segment lock key consists of at least "meta/segmentRefer/nodeID/segID"
if len(ss) < 4 {
return 0, 0, fmt.Errorf("segment lock key is invalid with %s", key)
}
segID, err = strconv.ParseInt(ss[len(ss)-1], 10, 64)
if err != nil {
return 0, 0, err
}
nodeID, err = strconv.ParseInt(ss[len(ss)-2], 10, 64)
return segID, nodeID, err
// taskID -> (nodeID -> segmentReferenceLock), taskID must be globally unique in a component
segmentsLock map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock
segmentReferCnt map[UniqueID]int
lock sync.RWMutex
}
func NewSegmentReferenceManager(etcdKV kv.BaseKV, onlineIDs []UniqueID) (*SegmentReferenceManager, error) {
log.Info("New segment reference manager")
log.Info("create a new segment reference manager")
segReferManager := &SegmentReferenceManager{
etcdKV: etcdKV,
segmentsLock: make(map[UniqueID][]*SegmentLock),
etcdKV: etcdKV,
segmentsLock: make(map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock),
segmentReferCnt: map[UniqueID]int{},
lock: sync.RWMutex{},
}
keys, _, err := segReferManager.etcdKV.LoadWithPrefix(segmentReferPrefix)
_, values, err := segReferManager.etcdKV.LoadWithPrefix(segmentReferPrefix)
if err != nil {
log.Error("load segments lock from etcd failed", zap.Error(err))
return nil, err
}
for _, key := range keys {
segID, nodeID, err := parseLockKey(key)
if err != nil {
log.Error("parse segment lock key failed", zap.String("lock key", key), zap.Error(err))
for _, value := range values {
segReferLock := &datapb.SegmentReferenceLock{}
if err = proto.Unmarshal([]byte(value), segReferLock); err != nil {
log.Error("unmarshal segment reference lock failed", zap.Error(err))
return nil, err
}
segLock := &SegmentLock{
segmentID: segID,
nodeID: nodeID,
locKey: key,
if _, ok := segReferManager.segmentsLock[segReferLock.TaskID]; !ok {
segReferManager.segmentsLock[segReferLock.TaskID] = map[UniqueID]*datapb.SegmentReferenceLock{}
}
segReferManager.segmentsLock[segReferLock.TaskID][segReferLock.NodeID] = segReferLock
for _, segID := range segReferLock.SegmentIDs {
segReferManager.segmentReferCnt[segID]++
}
segReferManager.segmentsLock[segID] = append(segReferManager.segmentsLock[segID], segLock)
}
err = segReferManager.recoverySegReferManager(onlineIDs)
if err != nil {
log.Error("Recovery segment reference manager failed", zap.Error(err))
log.Error("recovery segment reference manager failed", zap.Error(err))
return nil, err
}
log.Info("New segment reference manager successfully")
log.Info("create new segment reference manager successfully")
return segReferManager, nil
}
func (srm *SegmentReferenceManager) AddSegmentsLock(segIDs []UniqueID, nodeID UniqueID) error {
func generateLocKey(taskID, nodeID UniqueID) string {
return path.Join(segmentReferPrefix, strconv.FormatInt(taskID, 10), strconv.FormatInt(nodeID, 10))
}
// AddSegmentsLock adds a reference lock on segments to ensure the segments does not compaction during the reference period.
func (srm *SegmentReferenceManager) AddSegmentsLock(taskID int64, segIDs []UniqueID, nodeID UniqueID) error {
srm.lock.Lock()
defer srm.lock.Unlock()
log.Info("Add reference lock on segments", zap.Int64s("segIDs", segIDs), zap.Int64("nodeID", nodeID))
locKVs := make(map[string]string)
segID2SegmentLock := make(map[UniqueID][]*SegmentLock)
for _, segID := range segIDs {
locKey := path.Join(segmentReferPrefix, strconv.FormatInt(nodeID, 10), strconv.FormatInt(segID, 10))
locKVs[locKey] = strconv.FormatInt(nodeID, 10)
segLock := &SegmentLock{
segmentID: segID,
nodeID: nodeID,
locKey: locKey,
}
segID2SegmentLock[segID] = append(segID2SegmentLock[segID], segLock)
log.Info("add reference lock on segments", zap.Int64s("segIDs", segIDs), zap.Int64("nodeID", nodeID))
segReferLock := &datapb.SegmentReferenceLock{
TaskID: taskID,
NodeID: nodeID,
SegmentIDs: segIDs,
}
if err := srm.etcdKV.MultiSave(locKVs); err != nil {
log.Error("AddSegmentsLock save segment lock to etcd failed", zap.Int64s("segIDs", segIDs), zap.Error(err))
value, err := proto.Marshal(segReferLock)
if err != nil {
log.Error("AddSegmentsLock marshal failed", zap.Int64("taskID", taskID), zap.Int64("nodeID", nodeID),
zap.Int64s("segIDs", segIDs), zap.Error(err))
return err
}
for segID, segLocks := range segID2SegmentLock {
srm.segmentsLock[segID] = append(srm.segmentsLock[segID], segLocks...)
if err = srm.etcdKV.Save(generateLocKey(taskID, nodeID), string(value)); err != nil {
log.Error("AddSegmentsLock save segment lock to etcd failed", zap.Int64("taskID", taskID),
zap.Int64("nodeID", nodeID), zap.Int64s("segIDs", segIDs), zap.Error(err))
return err
}
log.Info("Add reference lock on segments successfully", zap.Int64s("segIDs", segIDs), zap.Int64("nodeID", nodeID))
if _, ok := srm.segmentsLock[taskID]; !ok {
srm.segmentsLock[taskID] = map[UniqueID]*datapb.SegmentReferenceLock{}
}
srm.segmentsLock[taskID][nodeID] = segReferLock
for _, segID := range segIDs {
srm.segmentReferCnt[segID]++
}
log.Info("add reference lock on segments successfully", zap.Int64s("segIDs", segIDs), zap.Int64("nodeID", nodeID))
return nil
}
func (srm *SegmentReferenceManager) ReleaseSegmentsLock(segIDs []UniqueID, nodeID UniqueID) error {
func (srm *SegmentReferenceManager) ReleaseSegmentsLock(taskID int64, nodeID UniqueID) error {
srm.lock.Lock()
defer srm.lock.Unlock()
log.Info("Release reference lock on segments", zap.Int64s("segIDs", segIDs), zap.Int64("nodeID", nodeID))
locKeys := make([]string, 0)
for _, segID := range segIDs {
for _, segLock := range srm.segmentsLock[segID] {
if segLock.nodeID == nodeID {
locKeys = append(locKeys, segLock.locKey)
}
}
log.Info("release reference lock by taskID", zap.Int64("taskID", taskID), zap.Int64("nodeID", nodeID))
if _, ok := srm.segmentsLock[taskID]; !ok {
log.Warn("taskID has no reference lock on segment", zap.Int64("taskID", taskID), zap.Int64("nodeID", nodeID))
return nil
}
if err := srm.etcdKV.MultiRemove(locKeys); err != nil {
log.Error("Remove reference lock paths on segments failed", zap.Int64s("segIDs", segIDs),
if _, ok := srm.segmentsLock[taskID][nodeID]; !ok {
log.Warn("taskID has no reference lock on segment with the nodeID", zap.Int64("taskID", taskID), zap.Int64("nodeID", nodeID))
return nil
}
if err := srm.etcdKV.Remove(generateLocKey(taskID, nodeID)); err != nil {
log.Error("remove reference lock paths by taskID failed", zap.Int64("taskID", taskID),
zap.Int64("nodeID", nodeID), zap.Error(err))
return err
}
for _, segID := range segIDs {
if _, ok := srm.segmentsLock[segID]; !ok {
continue
}
for i := 0; i < len(srm.segmentsLock[segID]); i++ {
segLock := srm.segmentsLock[segID][i]
if segLock.nodeID == nodeID {
srm.segmentsLock[segID] = append(srm.segmentsLock[segID][:i], srm.segmentsLock[segID][i+1:]...)
i--
}
}
if len(srm.segmentsLock[segID]) == 0 {
delete(srm.segmentsLock, segID)
for _, segID := range srm.segmentsLock[taskID][nodeID].SegmentIDs {
srm.segmentReferCnt[segID]--
if srm.segmentReferCnt[segID] <= 0 {
delete(srm.segmentReferCnt, segID)
}
}
log.Info("Release reference lock on segments successfully", zap.Int64s("segIDs", segIDs), zap.Int64("nodeID", nodeID))
delete(srm.segmentsLock[taskID], nodeID)
if len(srm.segmentsLock[taskID]) == 0 {
delete(srm.segmentsLock, taskID)
}
log.Info("release reference lock by taskID successfully", zap.Int64("taskID", taskID), zap.Int64("nodeID", nodeID))
return nil
}
@ -161,62 +153,55 @@ func (srm *SegmentReferenceManager) ReleaseSegmentsLockByNodeID(nodeID UniqueID)
srm.lock.Lock()
defer srm.lock.Unlock()
log.Info("Release reference lock on segments by node", zap.Int64("nodeID", nodeID))
locKeys := make([]string, 0)
for segID := range srm.segmentsLock {
for _, segLock := range srm.segmentsLock[segID] {
if segLock.nodeID == nodeID {
locKeys = append(locKeys, segLock.locKey)
log.Info("release reference lock on segments by node", zap.Int64("nodeID", nodeID))
for taskID, segReferLock := range srm.segmentsLock {
if _, ok := segReferLock[nodeID]; !ok {
continue
}
// The reason for not using MultiRemove is to prevent too many keys.
if err := srm.etcdKV.Remove(generateLocKey(taskID, nodeID)); err != nil {
log.Warn("remove reference lock path by taskID failed, need to retry", zap.Int64("nodeID", nodeID),
zap.Int64("taskID", taskID), zap.Error(err))
return err
}
for _, segID := range segReferLock[nodeID].SegmentIDs {
srm.segmentReferCnt[segID]--
if srm.segmentReferCnt[segID] <= 0 {
delete(srm.segmentReferCnt, segID)
}
}
}
if err := srm.etcdKV.MultiRemove(locKeys); err != nil {
log.Error("Remove reference lock paths on segments by node failed",
zap.Int64("nodeID", nodeID), zap.Error(err))
return err
delete(srm.segmentsLock[taskID], nodeID)
if len(srm.segmentsLock[taskID]) == 0 {
delete(srm.segmentsLock, taskID)
}
}
for segID := range srm.segmentsLock {
for i := 0; i < len(srm.segmentsLock[segID]); i++ {
segLock := srm.segmentsLock[segID][i]
if segLock.nodeID == nodeID {
srm.segmentsLock[segID] = append(srm.segmentsLock[segID][:i], srm.segmentsLock[segID][i+1:]...)
i--
}
}
if len(srm.segmentsLock[segID]) == 0 {
delete(srm.segmentsLock, segID)
}
}
log.Info("Release reference lock on segments by node successfully", zap.Int64("nodeID", nodeID))
log.Info("release reference lock on segments by node successfully", zap.Int64("nodeID", nodeID))
return nil
}
func (srm *SegmentReferenceManager) recoverySegReferManager(nodeIDs []UniqueID) error {
log.Info("Recovery reference lock on segments by online nodes", zap.Int64s("online nodeIDs", nodeIDs))
log.Info("recovery reference lock on segments by online nodes", zap.Int64s("online nodeIDs", nodeIDs))
onlineIDs := make(map[UniqueID]struct{})
for _, nodeID := range nodeIDs {
onlineIDs[nodeID] = struct{}{}
}
offlineIDs := make(map[UniqueID]struct{})
for segID := range srm.segmentsLock {
for _, segLock := range srm.segmentsLock[segID] {
alive := false
for _, nodeID := range nodeIDs {
if segLock.nodeID == nodeID {
alive = true
break
}
}
if !alive {
offlineIDs[segLock.nodeID] = struct{}{}
for _, segLock := range srm.segmentsLock {
for nodeID := range segLock {
if _, ok := onlineIDs[nodeID]; !ok {
offlineIDs[nodeID] = struct{}{}
}
}
}
for nodeID := range offlineIDs {
if err := srm.ReleaseSegmentsLockByNodeID(nodeID); err != nil {
log.Error("Remove reference lock on segments by offline node failed",
log.Error("remove reference lock on segments by offline node failed",
zap.Int64("offline nodeID", nodeID), zap.Error(err))
return err
}
}
log.Info("Recovery reference lock on segments by online nodes successfully", zap.Int64s("online nodeIDs", nodeIDs),
log.Info("recovery reference lock on segments by online nodes successfully", zap.Int64s("online nodeIDs", nodeIDs),
zap.Any("offline nodeIDs", offlineIDs))
return nil
}
@ -225,17 +210,8 @@ func (srm *SegmentReferenceManager) HasSegmentLock(segID UniqueID) bool {
srm.lock.RLock()
defer srm.lock.RUnlock()
_, ok := srm.segmentsLock[segID]
return ok
}
func (srm *SegmentReferenceManager) GetHasReferLockSegmentIDs() []UniqueID {
srm.lock.RLock()
defer srm.lock.RUnlock()
segIDs := make([]UniqueID, 0)
for segID := range srm.segmentsLock {
segIDs = append(segIDs, segID)
if _, ok := srm.segmentReferCnt[segID]; !ok {
return false
}
return segIDs
return true
}

163
internal/datacoord/segment_reference_manager_test.go
View File

@ -22,6 +22,9 @@ import (
"strconv"
"testing"
"github.com/golang/protobuf/proto"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/kv"
etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
@ -42,62 +45,48 @@ func Test_SegmentReferenceManager(t *testing.T) {
var err error
var locKey string
nodeID := int64(1)
locKey = path.Join(segmentReferPrefix, strconv.FormatInt(nodeID, 10), strconv.FormatInt(2, 10))
err = etcdKV.Save(locKey, strconv.FormatInt(nodeID, 10))
taskID := int64(10)
locKey = path.Join(segmentReferPrefix, strconv.FormatInt(taskID, 10))
segReferLock1 := &datapb.SegmentReferenceLock{
TaskID: taskID,
NodeID: nodeID,
SegmentIDs: []UniqueID{1},
}
value, err := proto.Marshal(segReferLock1)
assert.NoError(t, err)
err = etcdKV.Save(locKey, string(value))
assert.NoError(t, err)
segRefer, err = NewSegmentReferenceManager(etcdKV, []UniqueID{nodeID})
assert.NoError(t, err)
assert.NotNil(t, segRefer)
err = etcdKV.Remove(locKey)
assert.NoError(t, err)
locKey = path.Join(segmentReferPrefix, strconv.FormatInt(nodeID, 10), "segID")
err = etcdKV.Save(locKey, strconv.FormatInt(nodeID, 10))
assert.NoError(t, err)
segRefer, err = NewSegmentReferenceManager(etcdKV, []UniqueID{nodeID})
assert.Error(t, err)
assert.Nil(t, segRefer)
err = etcdKV.Remove(locKey)
assert.NoError(t, err)
locKey = path.Join(segmentReferPrefix, "nodeID", strconv.FormatInt(3, 10))
err = etcdKV.Save(locKey, strconv.FormatInt(nodeID, 10))
assert.NoError(t, err)
segRefer, err = NewSegmentReferenceManager(etcdKV, []UniqueID{nodeID})
assert.Error(t, err)
assert.Nil(t, segRefer)
err = etcdKV.Remove(locKey)
assert.NoError(t, err)
locKey = path.Join(segmentReferPrefix, "nodeID")
err = etcdKV.Save(locKey, strconv.FormatInt(nodeID, 10))
assert.NoError(t, err)
segRefer, err = NewSegmentReferenceManager(etcdKV, nil)
assert.Error(t, err)
assert.Nil(t, segRefer)
err = etcdKV.Remove(locKey)
assert.NoError(t, err)
locKey = path.Join(segmentReferPrefix, strconv.FormatInt(nodeID, 10), strconv.FormatInt(2, 10))
err = etcdKV.Save(locKey, strconv.FormatInt(nodeID, 10))
assert.NoError(t, err)
segRefer, err = NewSegmentReferenceManager(etcdKV, nil)
segRefer, err = NewSegmentReferenceManager(etcdKV, []UniqueID{nodeID + 1})
assert.NoError(t, err)
assert.NotNil(t, segRefer)
has := segRefer.HasSegmentLock(2)
assert.False(t, has)
err = etcdKV.Remove(locKey)
assert.NoError(t, err)
locKey = path.Join(segmentReferPrefix, strconv.FormatInt(taskID, 10))
err = etcdKV.Save(locKey, strconv.FormatInt(nodeID, 10))
assert.NoError(t, err)
segRefer, err = NewSegmentReferenceManager(etcdKV, []UniqueID{nodeID})
assert.Error(t, err)
assert.Nil(t, segRefer)
err = etcdKV.Remove(locKey)
assert.NoError(t, err)
})
segIDs := []UniqueID{1, 2, 3, 4, 5}
nodeID := UniqueID(1)
taskID := UniqueID(10)
segRefer, err = NewSegmentReferenceManager(etcdKV, nil)
assert.NoError(t, err)
assert.NotNil(t, segRefer)
var has bool
t.Run("AddSegmentsLock", func(t *testing.T) {
err = segRefer.AddSegmentsLock(segIDs, nodeID)
err = segRefer.AddSegmentsLock(taskID, segIDs, nodeID)
assert.NoError(t, err)
for _, segID := range segIDs {
@ -107,7 +96,10 @@ func Test_SegmentReferenceManager(t *testing.T) {
})
t.Run("ReleaseSegmentsLock", func(t *testing.T) {
err = segRefer.ReleaseSegmentsLock(segIDs, nodeID)
err = segRefer.ReleaseSegmentsLock(taskID, nodeID+1)
assert.NoError(t, err)
err = segRefer.ReleaseSegmentsLock(taskID, nodeID)
assert.NoError(t, err)
for _, segID := range segIDs {
@ -115,7 +107,15 @@ func Test_SegmentReferenceManager(t *testing.T) {
assert.False(t, has)
}
err = segRefer.ReleaseSegmentsLock([]UniqueID{6}, nodeID)
taskID = UniqueID(11)
err = segRefer.ReleaseSegmentsLock(taskID, nodeID)
assert.NoError(t, err)
has = segRefer.HasSegmentLock(6)
assert.False(t, has)
err = segRefer.ReleaseSegmentsLock(taskID, nodeID)
assert.NoError(t, err)
has = segRefer.HasSegmentLock(6)
@ -125,7 +125,8 @@ func Test_SegmentReferenceManager(t *testing.T) {
t.Run("ReleaseSegmentsLockByNodeID", func(t *testing.T) {
segIDs = []UniqueID{10, 11, 12, 13, 14, 15}
nodeID = 2
err = segRefer.AddSegmentsLock(segIDs, nodeID)
taskID = UniqueID(12)
err = segRefer.AddSegmentsLock(taskID, segIDs, nodeID)
assert.NoError(t, err)
for _, segID := range segIDs {
@ -133,7 +134,15 @@ func Test_SegmentReferenceManager(t *testing.T) {
assert.True(t, has)
}
err = segRefer.ReleaseSegmentsLockByNodeID(UniqueID(2))
err = segRefer.ReleaseSegmentsLockByNodeID(nodeID)
assert.NoError(t, err)
for _, segID := range segIDs {
has = segRefer.HasSegmentLock(segID)
assert.False(t, has)
}
err = segRefer.ReleaseSegmentsLockByNodeID(nodeID)
assert.NoError(t, err)
for _, segID := range segIDs {
@ -147,7 +156,8 @@ func Test_SegmentReferenceManager(t *testing.T) {
t.Run("RecoverySegReferManager", func(t *testing.T) {
segIDs = []UniqueID{16, 17, 18, 19, 20}
err = segRefer.AddSegmentsLock(segIDs, UniqueID(3))
taskID = UniqueID(13)
err = segRefer.AddSegmentsLock(taskID, segIDs, UniqueID(3))
assert.NoError(t, err)
for _, segID := range segIDs {
@ -156,7 +166,7 @@ func Test_SegmentReferenceManager(t *testing.T) {
}
segIDs2 := []UniqueID{21, 22, 23, 24, 25}
err = segRefer.AddSegmentsLock(segIDs2, UniqueID(4))
err = segRefer.AddSegmentsLock(taskID, segIDs2, UniqueID(4))
assert.NoError(t, err)
for _, segID := range segIDs2 {
@ -188,7 +198,8 @@ func Test_SegmentReferenceManager(t *testing.T) {
t.Run("GetHasReferLockSegmentIDs", func(t *testing.T) {
segIDs = []UniqueID{26, 27, 28, 29, 30}
err = segRefer.AddSegmentsLock(segIDs, UniqueID(5))
taskID = UniqueID(14)
err = segRefer.AddSegmentsLock(taskID, segIDs, UniqueID(5))
assert.NoError(t, err)
for _, segID := range segIDs {
@ -196,10 +207,6 @@ func Test_SegmentReferenceManager(t *testing.T) {
assert.True(t, has)
}
segmentIDs := segRefer.GetHasReferLockSegmentIDs()
assert.Equal(t, 5, len(segmentIDs))
assert.ElementsMatch(t, segIDs, segmentIDs)
err = segRefer.ReleaseSegmentsLockByNodeID(UniqueID(5))
assert.NoError(t, err)
@ -207,9 +214,6 @@ func Test_SegmentReferenceManager(t *testing.T) {
has = segRefer.HasSegmentLock(segID)
assert.False(t, has)
}
segIDs = segRefer.GetHasReferLockSegmentIDs()
assert.Equal(t, 0, len(segIDs))
})
}
@ -219,14 +223,14 @@ type etcdKVMock struct {
Fail int
}
func (em *etcdKVMock) MultiSave(data map[string]string) error {
func (em *etcdKVMock) Save(key, value string) error {
if em.Fail > 0 {
return errors.New("error occurred")
}
return nil
}
func (em *etcdKVMock) MultiRemove(keys []string) error {
func (em *etcdKVMock) Remove(key string) error {
if em.Fail > 0 {
return errors.New("error occurred")
}
@ -240,7 +244,13 @@ func (em *etcdKVMock) LoadWithPrefix(prefix string) ([]string, []string, error)
if em.Fail > 1 {
return []string{"key"}, []string{"value"}, nil
}
return []string{"meta/segmentRefer/1/2"}, []string{"1"}, nil
referLock := &datapb.SegmentReferenceLock{
TaskID: 1,
NodeID: 1,
SegmentIDs: []UniqueID{1, 2, 3},
}
value, _ := proto.Marshal(referLock)
return []string{segmentReferPrefix + "/1/1"}, []string{string(value)}, nil
}
func TestSegmentReferenceManager_Error(t *testing.T) {
@ -268,28 +278,55 @@ func TestSegmentReferenceManager_Error(t *testing.T) {
etcdKV: emKV,
}
taskID := UniqueID(1)
t.Run("AddSegmentsLock", func(t *testing.T) {
err := segRefer.AddSegmentsLock([]UniqueID{1}, 1)
err := segRefer.AddSegmentsLock(taskID, []UniqueID{1}, 1)
assert.Error(t, err)
})
t.Run("ReleaseSegmentsLock", func(t *testing.T) {
err := segRefer.ReleaseSegmentsLock([]UniqueID{1}, 1)
nodeID := UniqueID(1)
segRefer = &SegmentReferenceManager{
etcdKV: emKV,
segmentsLock: map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock{
taskID: {
nodeID: {
TaskID: taskID,
NodeID: nodeID,
SegmentIDs: []UniqueID{1, 2, 3},
},
},
},
}
err := segRefer.ReleaseSegmentsLock(taskID, 1)
assert.Error(t, err)
})
t.Run("ReleaseSegmentsLockByNodeID", func(t *testing.T) {
err := segRefer.ReleaseSegmentsLockByNodeID(1)
nodeID := UniqueID(1)
segRefer = &SegmentReferenceManager{
etcdKV: emKV,
segmentsLock: map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock{
taskID: {
nodeID: {
TaskID: taskID,
NodeID: nodeID,
SegmentIDs: []UniqueID{1, 2, 3},
},
},
},
}
err := segRefer.ReleaseSegmentsLockByNodeID(nodeID)
assert.Error(t, err)
})
t.Run("recoverySegReferManager", func(t *testing.T) {
segRefer.segmentsLock = map[UniqueID][]*SegmentLock{
segRefer.segmentsLock = map[UniqueID]map[UniqueID]*datapb.SegmentReferenceLock{
2: {
{
segmentID: 2,
nodeID: 2,
locKey: "1/2/3",
3: {
TaskID: 2,
NodeID: 3,
SegmentIDs: []UniqueID{1, 2, 3},
},
},
}

4
internal/datacoord/server_test.go
View File

@ -2741,8 +2741,8 @@ func TestDataCoord_Import(t *testing.T) {
closeTestServer(t, svr)
status, err := svr.ReleaseSegmentLock(context.TODO(), &datapb.ReleaseSegmentLockRequest{
SegmentIDs: []UniqueID{1, 2},
NodeID: UniqueID(1),
TaskID: UniqueID(1),
NodeID: UniqueID(1),
})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, status.GetErrorCode())

8
internal/datacoord/services.go
View File

@ -1112,7 +1112,7 @@ func (s *Server) AcquireSegmentLock(ctx context.Context, req *datapb.AcquireSegm
return resp, nil
}
err = s.segReferManager.AddSegmentsLock(req.SegmentIDs, req.NodeID)
err = s.segReferManager.AddSegmentsLock(req.TaskID, req.SegmentIDs, req.NodeID)
if err != nil {
log.Warn("Add reference lock on segments failed", zap.Int64s("segIDs", req.SegmentIDs), zap.Error(err))
resp.Reason = err.Error()
@ -1122,7 +1122,7 @@ func (s *Server) AcquireSegmentLock(ctx context.Context, req *datapb.AcquireSegm
if !hasSegments || err != nil {
log.Error("AcquireSegmentLock failed, try to release reference lock", zap.Error(err))
if err2 := retry.Do(ctx, func() error {
return s.segReferManager.ReleaseSegmentsLock(req.SegmentIDs, req.NodeID)
return s.segReferManager.ReleaseSegmentsLock(req.TaskID, req.NodeID)
}, retry.Attempts(100)); err2 != nil {
panic(err)
}
@ -1145,9 +1145,9 @@ func (s *Server) ReleaseSegmentLock(ctx context.Context, req *datapb.ReleaseSegm
return resp, nil
}
err := s.segReferManager.ReleaseSegmentsLock(req.SegmentIDs, req.NodeID)
err := s.segReferManager.ReleaseSegmentsLock(req.TaskID, req.NodeID)
if err != nil {
log.Error("DataCoord ReleaseSegmentLock failed", zap.Int64s("segmentIDs", req.SegmentIDs), zap.Int64("nodeID", req.NodeID),
log.Error("DataCoord ReleaseSegmentLock failed", zap.Int64("taskID", req.TaskID), zap.Int64("nodeID", req.NodeID),
zap.Error(err))
resp.Reason = err.Error()
return resp, nil

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

@ -229,10 +229,10 @@ func TestGrpcService(t *testing.T) {
core.CallImportService = func(ctx context.Context, req *datapb.ImportTaskRequest) *datapb.ImportTaskResponse {
return nil
}
core.CallAddSegRefLock = func(context.Context, []int64) error {
core.CallAddSegRefLock = func(context.Context, int64, []int64) error {
return nil
}
core.CallReleaseSegRefLock = func(context.Context, []int64) error {
core.CallReleaseSegRefLock = func(context.Context, int64, []int64) error {
return nil
}

14
internal/indexcoord/index_coord.go
View File

@ -853,7 +853,7 @@ func (i *IndexCoord) watchMetaLoop() {
log.Debug("This task has finished", zap.Int64("indexBuildID", indexBuildID),
zap.Int64("Finish by IndexNode", indexMeta.NodeID),
zap.Int64("The version of the task", indexMeta.Version))
if err = i.tryReleaseSegmentReferLock(ctx, []UniqueID{indexMeta.Req.SegmentID}); err != nil {
if err = i.tryReleaseSegmentReferLock(ctx, indexBuildID, []UniqueID{indexMeta.Req.SegmentID}); err != nil {
panic(err)
}
i.nodeManager.pq.IncPriority(indexMeta.NodeID, -1)
@ -873,8 +873,10 @@ func (i *IndexCoord) watchMetaLoop() {
}
}
func (i *IndexCoord) tryAcquireSegmentReferLock(ctx context.Context, segIDs []UniqueID) error {
func (i *IndexCoord) tryAcquireSegmentReferLock(ctx context.Context, buildID UniqueID, segIDs []UniqueID) error {
// IndexCoord use buildID instead of taskID.
status, err := i.dataCoordClient.AcquireSegmentLock(ctx, &datapb.AcquireSegmentLockRequest{
TaskID: buildID,
NodeID: i.session.ServerID,
SegmentIDs: segIDs,
})
@ -891,11 +893,11 @@ func (i *IndexCoord) tryAcquireSegmentReferLock(ctx context.Context, segIDs []Un
return nil
}
func (i *IndexCoord) tryReleaseSegmentReferLock(ctx context.Context, segIDs []UniqueID) error {
func (i *IndexCoord) tryReleaseSegmentReferLock(ctx context.Context, buildID UniqueID, segIDs []UniqueID) error {
releaseLock := func() error {
status, err := i.dataCoordClient.ReleaseSegmentLock(ctx, &datapb.ReleaseSegmentLockRequest{
NodeID: i.session.ServerID,
SegmentIDs: segIDs,
TaskID: buildID,
NodeID: i.session.ServerID,
})
if err != nil {
return err
@ -964,7 +966,7 @@ func (i *IndexCoord) assignTaskLoop() {
for index, meta := range metas {
indexBuildID := meta.indexMeta.IndexBuildID
segID := meta.indexMeta.Req.SegmentID
if err := i.tryAcquireSegmentReferLock(ctx, []UniqueID{segID}); err != nil {
if err := i.tryAcquireSegmentReferLock(ctx, indexBuildID, []UniqueID{segID}); err != nil {
log.Warn("IndexCoord try to acquire segment reference lock failed, maybe this segment has been compacted",
zap.Int64("segID", segID), zap.Int64("buildID", indexBuildID), zap.Error(err))
continue

8
internal/indexcoord/index_coord_test.go
View File

@ -427,7 +427,7 @@ func Test_tryAcquireSegmentReferLock(t *testing.T) {
ic.chunkManager = cmm
t.Run("success", func(t *testing.T) {
err := ic.tryAcquireSegmentReferLock(context.Background(), []UniqueID{1})
err := ic.tryAcquireSegmentReferLock(context.Background(), 1, []UniqueID{1})
assert.Nil(t, err)
})
@ -437,7 +437,7 @@ func Test_tryAcquireSegmentReferLock(t *testing.T) {
Fail: false,
}
ic.dataCoordClient = dcmE
err := ic.tryAcquireSegmentReferLock(context.Background(), []UniqueID{1})
err := ic.tryAcquireSegmentReferLock(context.Background(), 1, []UniqueID{1})
assert.Error(t, err)
})
@ -447,7 +447,7 @@ func Test_tryAcquireSegmentReferLock(t *testing.T) {
Fail: true,
}
ic.dataCoordClient = dcmF
err := ic.tryAcquireSegmentReferLock(context.Background(), []UniqueID{1})
err := ic.tryAcquireSegmentReferLock(context.Background(), 1, []UniqueID{1})
assert.Error(t, err)
})
}
@ -466,7 +466,7 @@ func Test_tryReleaseSegmentReferLock(t *testing.T) {
ic.dataCoordClient = dcm
t.Run("success", func(t *testing.T) {
err := ic.tryReleaseSegmentReferLock(context.Background(), []UniqueID{1})
err := ic.tryReleaseSegmentReferLock(context.Background(), 1, []UniqueID{1})
assert.NoError(t, err)
})
}

8
internal/proto/data_coord.proto
View File

@ -187,12 +187,14 @@ message AcquireSegmentLockRequest {
common.MsgBase base = 1;
int64 nodeID = 2;
repeated int64 segmentIDs = 3;
int64 taskID = 4;
}
message ReleaseSegmentLockRequest {
common.MsgBase base = 1;
int64 nodeID = 2;
repeated int64 segmentIDs = 3;
int64 taskID = 4;
}
message VchannelInfo {
@ -526,3 +528,9 @@ message AddSegmentRequest {
int64 partition_id = 5;
int64 row_num = 6;
}
message SegmentReferenceLock {
int64 taskID = 1;
int64 nodeID = 2;
repeated int64 segmentIDs = 3;
}

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

@ -1128,6 +1128,7 @@ type AcquireSegmentLockRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
SegmentIDs []int64 `protobuf:"varint,3,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"`
TaskID int64 `protobuf:"varint,4,opt,name=taskID,proto3" json:"taskID,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1179,10 +1180,18 @@ func (m *AcquireSegmentLockRequest) GetSegmentIDs() []int64 {
return nil
}
func (m *AcquireSegmentLockRequest) GetTaskID() int64 {
if m != nil {
return m.TaskID
}
return 0
}
type ReleaseSegmentLockRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
SegmentIDs []int64 `protobuf:"varint,3,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"`
TaskID int64 `protobuf:"varint,4,opt,name=taskID,proto3" json:"taskID,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1234,6 +1243,13 @@ func (m *ReleaseSegmentLockRequest) GetSegmentIDs() []int64 {
return nil
}
func (m *ReleaseSegmentLockRequest) GetTaskID() int64 {
if m != nil {
return m.TaskID
}
return 0
}
type VchannelInfo struct {
CollectionID int64 `protobuf:"varint,1,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
ChannelName string `protobuf:"bytes,2,opt,name=channelName,proto3" json:"channelName,omitempty"`
@ -4004,6 +4020,61 @@ func (m *AddSegmentRequest) GetRowNum() int64 {
return 0
}
type SegmentReferenceLock struct {
TaskID int64 `protobuf:"varint,1,opt,name=taskID,proto3" json:"taskID,omitempty"`
NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
SegmentIDs []int64 `protobuf:"varint,3,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
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}
}
func (m *SegmentReferenceLock) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SegmentReferenceLock.Unmarshal(m, b)
}
func (m *SegmentReferenceLock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SegmentReferenceLock.Marshal(b, m, deterministic)
}
func (m *SegmentReferenceLock) XXX_Merge(src proto.Message) {
xxx_messageInfo_SegmentReferenceLock.Merge(m, src)
}
func (m *SegmentReferenceLock) XXX_Size() int {
return xxx_messageInfo_SegmentReferenceLock.Size(m)
}
func (m *SegmentReferenceLock) XXX_DiscardUnknown() {
xxx_messageInfo_SegmentReferenceLock.DiscardUnknown(m)
}
var xxx_messageInfo_SegmentReferenceLock proto.InternalMessageInfo
func (m *SegmentReferenceLock) GetTaskID() int64 {
if m != nil {
return m.TaskID
}
return 0
}
func (m *SegmentReferenceLock) GetNodeID() int64 {
if m != nil {
return m.NodeID
}
return 0
}
func (m *SegmentReferenceLock) GetSegmentIDs() []int64 {
if m != nil {
return m.SegmentIDs
}
return nil
}
func init() {
proto.RegisterEnum("milvus.proto.data.ChannelWatchState", ChannelWatchState_name, ChannelWatchState_value)
proto.RegisterEnum("milvus.proto.data.CompactionType", CompactionType_name, CompactionType_value)
@ -4071,239 +4142,242 @@ func init() {
proto.RegisterType((*ResendSegmentStatsRequest)(nil), "milvus.proto.data.ResendSegmentStatsRequest")
proto.RegisterType((*ResendSegmentStatsResponse)(nil), "milvus.proto.data.ResendSegmentStatsResponse")
proto.RegisterType((*AddSegmentRequest)(nil), "milvus.proto.data.AddSegmentRequest")
proto.RegisterType((*SegmentReferenceLock)(nil), "milvus.proto.data.SegmentReferenceLock")
}
func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
var fileDescriptor_82cd95f524594f49 = []byte{
// 3628 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x3b, 0x5d, 0x6f, 0x1b, 0xd7,
0x95, 0x1e, 0x7e, 0x89, 0x3c, 0xfc, 0x10, 0x75, 0xed, 0xc8, 0x34, 0x6d, 0xcb, 0xf2, 0x38, 0x76,
0x14, 0xc7, 0xb1, 0x13, 0x79, 0x83, 0x04, 0x9b, 0x2f, 0xd8, 0x96, 0xad, 0x10, 0x2b, 0x79, 0xe5,
0x91, 0x12, 0x2f, 0x36, 0x8b, 0x25, 0x46, 0x9c, 0x2b, 0x6a, 0x22, 0xce, 0x0c, 0x3d, 0x33, 0xb4,
0xac, 0xbc, 0xc4, 0xd8, 0x60, 0x17, 0xc8, 0x62, 0xb1, 0x2d, 0xd0, 0x97, 0x16, 0xe8, 0x43, 0xd1,
0xa7, 0x7e, 0xa0, 0x40, 0x81, 0xa0, 0x0f, 0x69, 0xd1, 0xf7, 0xa0, 0x7d, 0xe8, 0x0f, 0xe8, 0x0f,
0x68, 0x5f, 0xda, 0xdf, 0x50, 0xdc, 0x8f, 0xb9, 0xf3, 0x4d, 0x8e, 0x48, 0x3b, 0x7e, 0xd3, 0x3d,
0x3c, 0xe7, 0xdc, 0x73, 0xcf, 0x3d, 0xdf, 0x73, 0x05, 0x4d, 0x4d, 0x75, 0xd5, 0x6e, 0xcf, 0xb2,
0x6c, 0xed, 0xfa, 0xd0, 0xb6, 0x5c, 0x0b, 0x2d, 0x18, 0xfa, 0xe0, 0xf1, 0xc8, 0x61, 0xab, 0xeb,
0xe4, 0xe7, 0x76, 0xad, 0x67, 0x19, 0x86, 0x65, 0x32, 0x50, 0xbb, 0xa1, 0x9b, 0x2e, 0xb6, 0x4d,
0x75, 0xc0, 0xd7, 0xb5, 0x20, 0x41, 0xbb, 0xe6, 0xf4, 0xf6, 0xb1, 0xa1, 0xb2, 0x95, 0x3c, 0x07,
0xc5, 0xbb, 0xc6, 0xd0, 0x3d, 0x92, 0x7f, 0x28, 0x41, 0xed, 0xde, 0x60, 0xe4, 0xec, 0x2b, 0xf8,
0xd1, 0x08, 0x3b, 0x2e, 0x7a, 0x03, 0x0a, 0xbb, 0xaa, 0x83, 0x5b, 0xd2, 0xb2, 0xb4, 0x52, 0x5d,
0x3d, 0x77, 0x3d, 0xb4, 0x2b, 0xdf, 0x6f, 0xd3, 0xe9, 0xdf, 0x56, 0x1d, 0xac, 0x50, 0x4c, 0x84,
0xa0, 0xa0, 0xed, 0x76, 0xd6, 0x5a, 0xb9, 0x65, 0x69, 0x25, 0xaf, 0xd0, 0xbf, 0xd1, 0x12, 0x80,
0x83, 0xfb, 0x06, 0x36, 0xdd, 0xce, 0x9a, 0xd3, 0xca, 0x2f, 0xe7, 0x57, 0xf2, 0x4a, 0x00, 0x82,
0x64, 0xa8, 0xf5, 0xac, 0xc1, 0x00, 0xf7, 0x5c, 0xdd, 0x32, 0x3b, 0x6b, 0xad, 0x02, 0xa5, 0x0d,
0xc1, 0xe4, 0x1f, 0x4b, 0x50, 0xe7, 0xa2, 0x39, 0x43, 0xcb, 0x74, 0x30, 0xba, 0x09, 0x25, 0xc7,
0x55, 0xdd, 0x91, 0xc3, 0xa5, 0x3b, 0x9b, 0x28, 0xdd, 0x36, 0x45, 0x51, 0x38, 0x6a, 0xa2, 0x78,
0xd1, 0xed, 0xf3, 0xf1, 0xed, 0x23, 0x47, 0x28, 0x44, 0x8f, 0x20, 0xff, 0x4a, 0x82, 0xe6, 0xb6,
0xb7, 0xf4, 0xb4, 0x77, 0x0a, 0x8a, 0x3d, 0x6b, 0x64, 0xba, 0x54, 0xc0, 0xba, 0xc2, 0x16, 0xe8,
0x22, 0xd4, 0x7a, 0xfb, 0xaa, 0x69, 0xe2, 0x41, 0xd7, 0x54, 0x0d, 0x4c, 0x45, 0xa9, 0x28, 0x55,
0x0e, 0xbb, 0xaf, 0x1a, 0x38, 0x93, 0x44, 0xcb, 0x50, 0x1d, 0xaa, 0xb6, 0xab, 0x87, 0x74, 0x16,
0x04, 0xa1, 0x36, 0x94, 0x75, 0xa7, 0x63, 0x0c, 0x2d, 0xdb, 0x6d, 0x15, 0x97, 0xa5, 0x95, 0xb2,
0x22, 0xd6, 0xf2, 0x4f, 0x24, 0x58, 0xbc, 0xe5, 0x38, 0x7a, 0xdf, 0x8c, 0x49, 0xbd, 0x08, 0x25,
0xd3, 0xd2, 0x70, 0x67, 0x8d, 0x8a, 0x9d, 0x57, 0xf8, 0x0a, 0x9d, 0x85, 0xca, 0x10, 0x63, 0xbb,
0x6b, 0x5b, 0x03, 0x4f, 0xe8, 0x32, 0x01, 0x28, 0xd6, 0x00, 0xa3, 0x07, 0xb0, 0xe0, 0x44, 0x18,
0xb1, 0x9b, 0xae, 0xae, 0x5e, 0xba, 0x1e, 0xb3, 0xd5, 0xeb, 0xd1, 0x4d, 0x95, 0x38, 0xb5, 0xfc,
0x34, 0x07, 0x27, 0x05, 0x1e, 0x93, 0x95, 0xfc, 0x4d, 0xb4, 0xea, 0xe0, 0xbe, 0x10, 0x8f, 0x2d,
0xb2, 0x68, 0x55, 0x5c, 0x47, 0x3e, 0x78, 0x1d, 0x19, 0x8c, 0x2f, 0xaa, 0xeb, 0x62, 0x5c, 0xd7,
0x17, 0xa0, 0x8a, 0x9f, 0x0c, 0x75, 0x1b, 0x77, 0x5d, 0xdd, 0xc0, 0xad, 0xd2, 0xb2, 0xb4, 0x52,
0x50, 0x80, 0x81, 0x76, 0x74, 0x23, 0x68, 0xad, 0x73, 0x99, 0xad, 0x55, 0xfe, 0xa9, 0x04, 0xa7,
0x63, 0xb7, 0xc4, 0xcd, 0x5f, 0x81, 0x26, 0x3d, 0xb9, 0xaf, 0x19, 0xe2, 0x08, 0x44, 0xe1, 0x57,
0xc6, 0x29, 0xdc, 0x47, 0x57, 0x62, 0xf4, 0x01, 0x21, 0x73, 0xd9, 0x85, 0x3c, 0x80, 0xd3, 0xeb,
0xd8, 0xe5, 0x1b, 0x90, 0xdf, 0xb0, 0x33, 0x7d, 0xf8, 0x08, 0xfb, 0x59, 0x2e, 0xe6, 0x67, 0xbf,
0xce, 0x09, 0x3f, 0xa3, 0x5b, 0x75, 0xcc, 0x3d, 0x0b, 0x9d, 0x83, 0x8a, 0x40, 0xe1, 0x56, 0xe1,
0x03, 0xd0, 0xdb, 0x50, 0x24, 0x92, 0x32, 0x93, 0x68, 0xac, 0x5e, 0x4c, 0x3e, 0x53, 0x80, 0xa7,
0xc2, 0xf0, 0x51, 0x07, 0x1a, 0x8e, 0xab, 0xda, 0x6e, 0x77, 0x68, 0x39, 0xf4, 0x9e, 0xa9, 0xe1,
0x54, 0x57, 0xe5, 0x30, 0x07, 0x11, 0x68, 0x37, 0x9d, 0xfe, 0x16, 0xc7, 0x54, 0xea, 0x94, 0xd2,
0x5b, 0xa2, 0xbb, 0x50, 0xc3, 0xa6, 0xe6, 0x33, 0x2a, 0x64, 0x66, 0x54, 0xc5, 0xa6, 0x26, 0xd8,
0xf8, 0xf7, 0x53, 0xcc, 0x7e, 0x3f, 0xff, 0x27, 0x41, 0x2b, 0x7e, 0x41, 0xb3, 0x04, 0xd1, 0x77,
0x19, 0x11, 0x66, 0x17, 0x34, 0xd6, 0xc3, 0xc5, 0x25, 0x29, 0x9c, 0x44, 0xd6, 0xe1, 0x25, 0x5f,
0x1a, 0xfa, 0xcb, 0x73, 0x33, 0x96, 0x2f, 0x25, 0x58, 0x8c, 0xee, 0x35, 0xcb, 0xb9, 0xff, 0x09,
0x8a, 0xba, 0xb9, 0x67, 0x79, 0xc7, 0x5e, 0x1a, 0xe3, 0x67, 0x64, 0x2f, 0x86, 0x2c, 0x1b, 0x70,
0x76, 0x1d, 0xbb, 0x1d, 0xd3, 0xc1, 0xb6, 0x7b, 0x5b, 0x37, 0x07, 0x56, 0x7f, 0x4b, 0x75, 0xf7,
0x67, 0xf0, 0x91, 0x90, 0xb9, 0xe7, 0x22, 0xe6, 0x2e, 0xff, 0x4c, 0x82, 0x73, 0xc9, 0xfb, 0xf1,
0xa3, 0xb7, 0xa1, 0xbc, 0xa7, 0xe3, 0x81, 0x46, 0x74, 0x26, 0x51, 0x9d, 0x89, 0x35, 0xf1, 0x95,
0x21, 0x41, 0xe6, 0x27, 0xbc, 0x98, 0x62, 0xa0, 0xdb, 0xae, 0xad, 0x9b, 0xfd, 0x0d, 0xdd, 0x71,
0x15, 0x86, 0x1f, 0xd0, 0x67, 0x3e, 0xbb, 0x65, 0xfe, 0xaf, 0x04, 0x4b, 0xeb, 0xd8, 0xbd, 0x23,
0x42, 0x2d, 0xf9, 0x5d, 0x77, 0x5c, 0xbd, 0xe7, 0x3c, 0xdb, 0x02, 0x24, 0x43, 0x3e, 0x95, 0xbf,
0x27, 0xc1, 0x85, 0x54, 0x61, 0xb8, 0xea, 0x78, 0x28, 0xf1, 0x02, 0x6d, 0x72, 0x28, 0xf9, 0x17,
0x7c, 0xf4, 0x89, 0x3a, 0x18, 0xe1, 0x2d, 0x55, 0xb7, 0x59, 0x28, 0x99, 0x32, 0xb0, 0xfe, 0x52,
0x82, 0xf3, 0xeb, 0xd8, 0xdd, 0xf2, 0xd2, 0xcc, 0x0b, 0xd4, 0xce, 0xe4, 0x6a, 0x43, 0xfe, 0x7f,
0x76, 0x99, 0x89, 0xd2, 0xbe, 0x10, 0xf5, 0x2d, 0x51, 0x3f, 0x08, 0x38, 0xe4, 0x1d, 0x56, 0x0b,
0x70, 0xe5, 0xc9, 0xff, 0x2d, 0xc1, 0x99, 0x5b, 0xbd, 0x47, 0x23, 0xdd, 0xc6, 0x1c, 0x69, 0xc3,
0xea, 0x1d, 0x4c, 0xaf, 0x5a, 0xbf, 0x6e, 0xca, 0x85, 0xea, 0xa6, 0x09, 0xd5, 0x2f, 0x95, 0x43,
0xc1, 0x03, 0xac, 0x3a, 0x2f, 0x56, 0x8e, 0xa7, 0x79, 0xa8, 0x7d, 0xc2, 0xeb, 0x25, 0x9a, 0x56,
0xa3, 0x76, 0x21, 0x25, 0xdb, 0x45, 0xa0, 0xc4, 0x4a, 0xaa, 0xba, 0xd6, 0xa1, 0xee, 0x60, 0x7c,
0x30, 0x4d, 0x12, 0xad, 0x11, 0x42, 0x91, 0xfc, 0x36, 0x60, 0x61, 0x64, 0xee, 0x91, 0x16, 0x00,
0x6b, 0x5c, 0x51, 0xac, 0x12, 0x9f, 0x1c, 0x89, 0xe3, 0x84, 0xe8, 0x23, 0x98, 0x8f, 0xf2, 0x2a,
0x66, 0xe2, 0x15, 0x25, 0x43, 0x1d, 0x68, 0x6a, 0xb6, 0x35, 0x1c, 0x62, 0xad, 0xeb, 0x78, 0xac,
0x4a, 0xd9, 0x58, 0x71, 0x3a, 0x8f, 0x95, 0xfc, 0x95, 0x04, 0x8b, 0x0f, 0x55, 0xb7, 0xb7, 0xbf,
0x66, 0x70, 0x63, 0x9d, 0xc1, 0xd5, 0xdf, 0x87, 0xca, 0x63, 0x7e, 0x11, 0x5e, 0x3c, 0xbf, 0x90,
0x20, 0x50, 0xf0, 0xca, 0x15, 0x9f, 0x42, 0xfe, 0x56, 0x82, 0x53, 0xb4, 0xe1, 0xf2, 0xa4, 0xfb,
0xee, 0x83, 0xce, 0x84, 0xa6, 0x0b, 0x5d, 0x81, 0x86, 0xa1, 0xda, 0x07, 0xdb, 0x3e, 0x4e, 0x91,
0xe2, 0x44, 0xa0, 0xf2, 0x13, 0x00, 0xbe, 0xda, 0x74, 0xfa, 0x53, 0xc8, 0xff, 0x0e, 0xcc, 0xf1,
0x5d, 0x79, 0xfc, 0x99, 0x74, 0xb1, 0x1e, 0xba, 0xfc, 0x07, 0x09, 0x1a, 0x7e, 0x46, 0xa1, 0x5e,
0xd5, 0x80, 0x9c, 0xf0, 0xa5, 0x5c, 0x67, 0x0d, 0xbd, 0x0f, 0x25, 0xd6, 0x8c, 0x73, 0xde, 0x97,
0xc3, 0xbc, 0x79, 0xa3, 0x1e, 0x48, 0x4b, 0x14, 0xa0, 0x70, 0x22, 0xa2, 0x23, 0x11, 0x85, 0x85,
0x57, 0xfb, 0x10, 0xd4, 0x81, 0xf9, 0x70, 0x11, 0xeb, 0xf9, 0xcc, 0x72, 0x5a, 0xf4, 0x5d, 0x53,
0x5d, 0x95, 0x06, 0xdf, 0x46, 0xa8, 0x86, 0x75, 0xe4, 0xbf, 0x17, 0xa1, 0x1a, 0x38, 0x65, 0xec,
0x24, 0xd1, 0x2b, 0xcd, 0x4d, 0xce, 0x23, 0xf9, 0x78, 0x27, 0x75, 0x19, 0x1a, 0x3a, 0xad, 0x5d,
0xba, 0xdc, 0x14, 0x69, 0xb2, 0xa9, 0x28, 0x75, 0x06, 0xe5, 0x7e, 0x81, 0x96, 0xa0, 0x6a, 0x8e,
0x8c, 0xae, 0xb5, 0xd7, 0xb5, 0xad, 0x43, 0x87, 0xb7, 0x64, 0x15, 0x73, 0x64, 0xfc, 0xeb, 0x9e,
0x62, 0x1d, 0x3a, 0x7e, 0xd5, 0x5f, 0x3a, 0x66, 0xd5, 0xbf, 0x04, 0x55, 0x43, 0x7d, 0x42, 0xb8,
0x76, 0xcd, 0x91, 0x41, 0xbb, 0xb5, 0xbc, 0x52, 0x31, 0xd4, 0x27, 0x8a, 0x75, 0x78, 0x7f, 0x64,
0xa0, 0x15, 0x68, 0x0e, 0x54, 0xc7, 0xed, 0x06, 0xdb, 0xbd, 0x32, 0x6d, 0xf7, 0x1a, 0x04, 0x7e,
0xd7, 0x6f, 0xf9, 0xe2, 0xfd, 0x43, 0x65, 0x86, 0xfe, 0x41, 0x33, 0x06, 0x3e, 0x23, 0xc8, 0xde,
0x3f, 0x68, 0xc6, 0x40, 0xb0, 0x79, 0x07, 0xe6, 0x76, 0x69, 0x45, 0xe8, 0xb4, 0xaa, 0xa9, 0x11,
0xea, 0x1e, 0x29, 0x06, 0x59, 0xe1, 0xa8, 0x78, 0xe8, 0xe8, 0x3d, 0xa8, 0xd0, 0x54, 0x4c, 0x69,
0x6b, 0x99, 0x68, 0x7d, 0x02, 0x42, 0xad, 0xe1, 0x81, 0xab, 0x52, 0xea, 0x7a, 0x36, 0x6a, 0x41,
0x80, 0xde, 0x80, 0x93, 0x3d, 0x1b, 0xab, 0x2e, 0xd6, 0x6e, 0x1f, 0xdd, 0xb1, 0x8c, 0xa1, 0x4a,
0x8d, 0xa9, 0xd5, 0xa0, 0x23, 0x8d, 0xa4, 0x9f, 0x48, 0x60, 0xe8, 0x89, 0xd5, 0x3d, 0xdb, 0x32,
0x5a, 0xf3, 0x2c, 0x30, 0x84, 0xa1, 0xe8, 0x3c, 0x80, 0x17, 0xba, 0x55, 0xb7, 0xd5, 0xa4, 0xb7,
0x58, 0xe1, 0x90, 0x5b, 0xae, 0xfc, 0x05, 0x9c, 0xf2, 0x2d, 0x24, 0x70, 0x1b, 0xf1, 0x8b, 0x95,
0xa6, 0xbd, 0xd8, 0xf1, 0xb5, 0xfc, 0x9f, 0x0a, 0xb0, 0xb8, 0xad, 0x3e, 0xc6, 0xcf, 0xbf, 0x6d,
0xc8, 0x14, 0x8f, 0x37, 0x60, 0x81, 0x76, 0x0a, 0xab, 0x01, 0x79, 0xc6, 0x64, 0xe0, 0xe0, 0x75,
0xc6, 0x09, 0xd1, 0x87, 0xa4, 0x74, 0xc0, 0xbd, 0x83, 0x2d, 0x4b, 0xf7, 0xb3, 0xef, 0xf9, 0x04,
0x3e, 0x77, 0x04, 0x96, 0x12, 0xa4, 0x40, 0x5b, 0xf1, 0xd0, 0xc6, 0xf2, 0xee, 0x2b, 0x63, 0xfb,
0x51, 0x5f, 0xfb, 0xd1, 0x08, 0x87, 0x5a, 0x30, 0xc7, 0xb3, 0x3b, 0xf5, 0xfb, 0xb2, 0xe2, 0x2d,
0xd1, 0x16, 0x9c, 0x64, 0x27, 0xd8, 0xe6, 0x46, 0xcd, 0x0e, 0x5f, 0xce, 0x74, 0xf8, 0x24, 0xd2,
0xb0, 0x4f, 0x54, 0x8e, 0xeb, 0x13, 0x2d, 0x98, 0xe3, 0x76, 0x4a, 0x63, 0x41, 0x59, 0xf1, 0x96,
0xe4, 0x9a, 0x75, 0x3a, 0xe3, 0xd3, 0xcd, 0x7e, 0xab, 0x4a, 0x7f, 0xf3, 0x01, 0xa4, 0xe5, 0x02,
0x5f, 0x9f, 0x13, 0x26, 0x27, 0x1f, 0x40, 0x59, 0x58, 0x78, 0x2e, 0xb3, 0x85, 0x0b, 0x9a, 0x68,
0x8c, 0xce, 0x47, 0x62, 0xb4, 0xfc, 0x47, 0x09, 0x6a, 0x6b, 0xe4, 0x48, 0x1b, 0x56, 0x9f, 0x66,
0x94, 0xcb, 0xd0, 0xb0, 0x71, 0xcf, 0xb2, 0xb5, 0x2e, 0x36, 0x5d, 0x5b, 0xc7, 0xac, 0x3b, 0x2f,
0x28, 0x75, 0x06, 0xbd, 0xcb, 0x80, 0x04, 0x8d, 0x84, 0x5d, 0xc7, 0x55, 0x8d, 0x61, 0x77, 0x8f,
0xb8, 0x77, 0x8e, 0xa1, 0x09, 0x28, 0xf5, 0xee, 0x8b, 0x50, 0xf3, 0xd1, 0x5c, 0x8b, 0xee, 0x5f,
0x50, 0xaa, 0x02, 0xb6, 0x63, 0xa1, 0x97, 0xa1, 0x41, 0x75, 0xda, 0x1d, 0x58, 0xfd, 0x2e, 0xe9,
0x64, 0x79, 0xb2, 0xa9, 0x69, 0x5c, 0x2c, 0x72, 0x57, 0x61, 0x2c, 0x47, 0xff, 0x1c, 0xf3, 0x74,
0x23, 0xb0, 0xb6, 0xf5, 0xcf, 0x31, 0xc9, 0xf5, 0x75, 0x92, 0x3b, 0xef, 0x5b, 0x1a, 0xde, 0x99,
0xb2, 0xd2, 0xc8, 0x30, 0xc5, 0x3c, 0x07, 0x15, 0x71, 0x02, 0x7e, 0x24, 0x1f, 0x80, 0xee, 0x41,
0xc3, 0x2b, 0x42, 0xbb, 0xac, 0xd7, 0x2a, 0xa4, 0x56, 0x7e, 0x81, 0xec, 0xe7, 0x28, 0x75, 0x8f,
0x8c, 0x2e, 0xe5, 0x7b, 0x50, 0x0b, 0xfe, 0x4c, 0x76, 0xdd, 0x8e, 0x1a, 0x8a, 0x00, 0x10, 0x6b,
0xbc, 0x3f, 0x32, 0xc8, 0x9d, 0xf2, 0xc0, 0xe2, 0x2d, 0xe5, 0x2f, 0x25, 0xa8, 0xf3, 0x94, 0xbd,
0x2d, 0x26, 0xf0, 0xf4, 0x68, 0x12, 0x3d, 0x1a, 0xfd, 0x1b, 0xfd, 0x73, 0x78, 0x44, 0xf7, 0x72,
0x62, 0x10, 0xa0, 0x4c, 0x68, 0x75, 0x1c, 0xca, 0xd7, 0x59, 0x7a, 0xfb, 0xa7, 0xc4, 0xd0, 0xf8,
0xd5, 0x50, 0x43, 0x6b, 0xc1, 0x9c, 0xaa, 0x69, 0x36, 0x76, 0x1c, 0x2e, 0x87, 0xb7, 0x24, 0xbf,
0x3c, 0xc6, 0xb6, 0xe3, 0x99, 0x7c, 0x5e, 0xf1, 0x96, 0xe8, 0x3d, 0x28, 0x8b, 0x72, 0x3a, 0x9f,
0x54, 0x42, 0x05, 0xe5, 0xe4, 0xbd, 0xa8, 0xa0, 0x90, 0x7f, 0x93, 0x83, 0x06, 0x57, 0xd8, 0x6d,
0x9e, 0x53, 0xc7, 0x3b, 0xdf, 0x6d, 0xa8, 0xed, 0xf9, 0xbe, 0x3f, 0x6e, 0xe6, 0x14, 0x0c, 0x11,
0x21, 0x9a, 0x49, 0x0e, 0x18, 0xce, 0xea, 0x85, 0x99, 0xb2, 0x7a, 0xf1, 0xb8, 0x11, 0x2c, 0x5e,
0xe7, 0x95, 0x12, 0xea, 0x3c, 0xf9, 0x3f, 0xa0, 0x1a, 0x60, 0x40, 0x23, 0x34, 0x1b, 0x56, 0x71,
0x8d, 0x79, 0x4b, 0x74, 0xd3, 0xaf, 0x6d, 0x98, 0xaa, 0xce, 0x24, 0xc8, 0x12, 0x29, 0x6b, 0xe4,
0x9f, 0x4b, 0x50, 0xe2, 0x9c, 0x2f, 0x40, 0x95, 0x07, 0x1d, 0x5a, 0xf7, 0x31, 0xee, 0xc0, 0x41,
0xa4, 0xf0, 0x7b, 0x76, 0x51, 0xe7, 0x0c, 0x94, 0x23, 0xf1, 0x66, 0x8e, 0xa7, 0x05, 0xef, 0xa7,
0x40, 0x90, 0x21, 0x3f, 0xd1, 0xf8, 0xf2, 0xad, 0x44, 0x07, 0xed, 0x0a, 0xee, 0x59, 0x8f, 0xb1,
0x7d, 0x34, 0xfb, 0x38, 0xf3, 0xdd, 0x80, 0x41, 0x67, 0xec, 0x0f, 0x05, 0x01, 0x7a, 0xd7, 0x57,
0x77, 0x3e, 0x69, 0x9a, 0x13, 0x8c, 0x30, 0xdc, 0x1c, 0x7d, 0xb5, 0x7f, 0x9f, 0x0d, 0x66, 0xc3,
0x47, 0x99, 0xb6, 0xae, 0x79, 0x26, 0x6d, 0x87, 0xfc, 0x03, 0x09, 0xce, 0xac, 0x63, 0xf7, 0x5e,
0xb8, 0xb9, 0x7f, 0xd1, 0x52, 0x19, 0xd0, 0x4e, 0x12, 0x6a, 0x96, 0x5b, 0x6f, 0x43, 0x59, 0x8c,
0x29, 0xd8, 0xc8, 0x5c, 0xac, 0xe5, 0xff, 0x91, 0xa0, 0xc5, 0x77, 0xa1, 0x7b, 0x92, 0x92, 0x7a,
0x80, 0x5d, 0xac, 0x7d, 0xd7, 0x7d, 0xf3, 0xef, 0x25, 0x68, 0x06, 0x23, 0x3e, 0x0d, 0xda, 0x6f,
0x41, 0x91, 0x8e, 0x27, 0xb8, 0x04, 0x13, 0x8d, 0x95, 0x61, 0x93, 0x90, 0x41, 0xcb, 0xbc, 0x1d,
0x91, 0x9c, 0xf8, 0xd2, 0x4f, 0x3b, 0xf9, 0xe3, 0xa7, 0x1d, 0x9e, 0x86, 0xad, 0x11, 0xe1, 0xcb,
0xc6, 0xa1, 0x3e, 0x40, 0xfe, 0x3a, 0x07, 0x2d, 0xbf, 0x1f, 0xf9, 0xce, 0xe3, 0x7e, 0x4a, 0xb5,
0x9a, 0x7f, 0x46, 0xd5, 0x6a, 0x61, 0xf6, 0x58, 0x5f, 0x4c, 0x8a, 0xf5, 0xbf, 0xcb, 0x41, 0xc3,
0xd7, 0xda, 0xd6, 0x40, 0x35, 0xd1, 0x22, 0x94, 0x86, 0x03, 0xd5, 0x9f, 0x3e, 0xf2, 0x15, 0xda,
0x16, 0x75, 0x4e, 0x58, 0x4f, 0xaf, 0x25, 0xdd, 0x61, 0xca, 0x45, 0x28, 0x11, 0x16, 0xa4, 0x1d,
0x64, 0x0d, 0x05, 0x6d, 0xea, 0x79, 0x6d, 0xc5, 0x8c, 0x85, 0xf4, 0xf3, 0xd7, 0x00, 0xf1, 0x1b,
0xee, 0xea, 0x66, 0xd7, 0xc1, 0x3d, 0xcb, 0xd4, 0xd8, 0xdd, 0x17, 0x95, 0x26, 0xff, 0xa5, 0x63,
0x6e, 0x33, 0x38, 0x7a, 0x0b, 0x0a, 0xee, 0xd1, 0x90, 0x45, 0xf1, 0x46, 0x62, 0x74, 0xf4, 0xe5,
0xda, 0x39, 0x1a, 0x62, 0x85, 0xa2, 0xa3, 0x25, 0x00, 0xc2, 0xca, 0xb5, 0xd5, 0xc7, 0x3c, 0x25,
0x16, 0x94, 0x00, 0x84, 0x58, 0xb3, 0xa7, 0xc3, 0x39, 0x96, 0x3a, 0xf8, 0x52, 0xfe, 0x26, 0x07,
0x4d, 0x9f, 0xa5, 0x82, 0x9d, 0xd1, 0xc0, 0x4d, 0xd5, 0xdf, 0xf8, 0x66, 0x70, 0x52, 0xdd, 0xf0,
0x21, 0x54, 0xf9, 0x7d, 0x1e, 0xc3, 0x1e, 0x80, 0x91, 0x6c, 0x8c, 0x31, 0xd0, 0xe2, 0x33, 0x32,
0xd0, 0xd2, 0x31, 0x0d, 0x54, 0xde, 0x86, 0x45, 0x2f, 0xee, 0xf9, 0x08, 0x9b, 0xd8, 0x55, 0xc7,
0x14, 0x1c, 0x17, 0xa0, 0xca, 0xf2, 0x19, 0x4b, 0xe4, 0xac, 0x54, 0x87, 0x5d, 0xd1, 0xe1, 0xca,
0xff, 0x09, 0xa7, 0x68, 0xdc, 0x88, 0x8e, 0x72, 0xb3, 0xcc, 0xd5, 0x65, 0xd1, 0x08, 0x90, 0xa2,
0x9f, 0x59, 0x77, 0x45, 0x09, 0xc1, 0xe4, 0x0d, 0x78, 0x29, 0xc2, 0x7f, 0x86, 0xbc, 0x40, 0x4a,
0xa1, 0xc5, 0xed, 0xf0, 0x67, 0xe2, 0xe9, 0xb3, 0xdf, 0x79, 0x31, 0xb9, 0xed, 0xea, 0x5a, 0xd4,
0xbe, 0x34, 0xf4, 0x01, 0x54, 0x4c, 0x7c, 0xd8, 0x0d, 0x06, 0xdf, 0x0c, 0x03, 0xba, 0xb2, 0x89,
0x0f, 0xe9, 0x5f, 0xf2, 0x7d, 0x38, 0x1d, 0x13, 0x75, 0x96, 0xb3, 0xff, 0x56, 0x82, 0x33, 0x6b,
0xb6, 0x35, 0xfc, 0x44, 0xb7, 0xdd, 0x91, 0x3a, 0x08, 0x7f, 0x28, 0x7a, 0x3e, 0x6d, 0xdc, 0x47,
0x81, 0x34, 0xcc, 0xe2, 0xf2, 0xb5, 0x04, 0x73, 0x8d, 0x0b, 0xc5, 0x0f, 0x1d, 0x48, 0xda, 0x7f,
0xc9, 0x27, 0x09, 0xcf, 0xf1, 0x26, 0x24, 0x9b, 0x2c, 0x55, 0x4a, 0xe2, 0xd4, 0x27, 0x3f, 0xed,
0xd4, 0x27, 0xc5, 0xf3, 0x0b, 0xcf, 0xc8, 0xf3, 0x8f, 0xdd, 0x86, 0x7c, 0x04, 0xe1, 0x89, 0x1c,
0x0d, 0xb9, 0x53, 0x8d, 0xf2, 0x6e, 0x03, 0xf8, 0xd3, 0x29, 0xfe, 0xca, 0x27, 0x0b, 0x9b, 0x00,
0x15, 0xb9, 0x2d, 0x11, 0x65, 0xe9, 0x54, 0x39, 0x34, 0x2f, 0x79, 0x00, 0xed, 0x24, 0x2b, 0x9d,
0xc5, 0xf2, 0xbf, 0xce, 0x01, 0xb0, 0x27, 0x61, 0x3b, 0xaa, 0x73, 0x30, 0x5d, 0x45, 0x79, 0x09,
0xea, 0xbe, 0xc1, 0xf8, 0xfe, 0x1e, 0xb4, 0x22, 0x8d, 0xb8, 0x84, 0x28, 0x6c, 0x09, 0x4e, 0xac,
0xd8, 0xd5, 0x28, 0x9f, 0x80, 0xd7, 0x30, 0xa3, 0x88, 0x04, 0x3d, 0x74, 0x16, 0x2a, 0xb6, 0x75,
0xd8, 0x25, 0x6e, 0xa6, 0x79, 0xaf, 0xda, 0x6c, 0xeb, 0x90, 0x38, 0x9f, 0x86, 0x4e, 0xc3, 0x9c,
0xab, 0x3a, 0x07, 0x84, 0x7f, 0x89, 0xa5, 0x3b, 0xb2, 0xec, 0x68, 0xe8, 0x14, 0x14, 0xf7, 0xf4,
0x01, 0x76, 0x5a, 0x73, 0x94, 0x25, 0x5b, 0xa0, 0xb7, 0xbd, 0xf7, 0x1c, 0xe5, 0xcc, 0xdf, 0xa3,
0xd9, 0x93, 0x8e, 0x6f, 0x25, 0x98, 0xf7, 0xb5, 0x46, 0x03, 0x10, 0x89, 0x69, 0x34, 0x9e, 0xdd,
0xb1, 0x34, 0x16, 0x2a, 0x1a, 0x29, 0x9f, 0x58, 0x18, 0x21, 0x8b, 0x5a, 0x3e, 0xc9, 0xb8, 0xba,
0x9c, 0x9c, 0x8b, 0x1c, 0x5a, 0xd7, 0xbc, 0x2f, 0x3c, 0x25, 0xdb, 0x3a, 0xec, 0x68, 0x42, 0x1b,
0xec, 0x59, 0x1b, 0xab, 0x42, 0x89, 0x36, 0xee, 0xd0, 0x97, 0x6d, 0x97, 0xa0, 0x8e, 0x6d, 0xdb,
0xb2, 0xbb, 0x06, 0x76, 0x1c, 0xb5, 0x8f, 0x79, 0xd1, 0x55, 0xa3, 0xc0, 0x4d, 0x06, 0x93, 0xbf,
0xc9, 0x43, 0xc3, 0x3f, 0x8a, 0xf7, 0x5d, 0x47, 0xd7, 0xbc, 0xef, 0x3a, 0xba, 0x46, 0x82, 0xb9,
0xcd, 0x42, 0x61, 0x20, 0x98, 0x73, 0x48, 0x47, 0x23, 0x79, 0x90, 0x38, 0x98, 0x69, 0x69, 0xd8,
0xbf, 0x58, 0xf0, 0x40, 0xfc, 0x5e, 0x43, 0xf6, 0x51, 0xc8, 0x60, 0x1f, 0xc5, 0x0c, 0xf6, 0x51,
0x4a, 0xb0, 0x8f, 0x45, 0x28, 0xed, 0x8e, 0x7a, 0x07, 0xd8, 0xe5, 0xe5, 0x11, 0x5f, 0x85, 0xed,
0xa6, 0x1c, 0xb1, 0x1b, 0x61, 0x1e, 0x95, 0xa0, 0x79, 0x9c, 0x85, 0x0a, 0xfb, 0xb8, 0xd0, 0x75,
0x1d, 0x3a, 0x65, 0xcd, 0x2b, 0x65, 0x06, 0xd8, 0x71, 0xd0, 0x3b, 0x5e, 0xef, 0x50, 0x4d, 0x72,
0x74, 0x1a, 0x71, 0x22, 0x16, 0xe2, 0x75, 0x0e, 0x97, 0xa1, 0x41, 0x9f, 0xf3, 0x3e, 0x1a, 0x61,
0xfb, 0x48, 0xdd, 0x1d, 0xe0, 0x56, 0x8d, 0x8a, 0x53, 0x27, 0xd0, 0x07, 0x1e, 0x90, 0x28, 0x84,
0xa2, 0xe9, 0xa6, 0x86, 0x9f, 0x60, 0xad, 0x55, 0xa7, 0x48, 0x54, 0xd5, 0x1d, 0x06, 0x92, 0x3f,
0x03, 0xe4, 0xef, 0x31, 0x5b, 0x57, 0x18, 0xb9, 0xc4, 0x5c, 0xf4, 0x12, 0xe5, 0x5f, 0x48, 0xb0,
0x10, 0xdc, 0x6c, 0xda, 0xd4, 0xf8, 0x01, 0x54, 0xd9, 0x34, 0xba, 0x4b, 0x5c, 0x93, 0xf7, 0x85,
0xe7, 0xc7, 0x6a, 0x4f, 0x01, 0xdd, 0x8f, 0x50, 0x97, 0xa0, 0x7e, 0x68, 0xd9, 0x07, 0xba, 0xd9,
0xef, 0x12, 0xc9, 0x3c, 0x87, 0xa8, 0x71, 0xe0, 0x7d, 0x02, 0x93, 0xbf, 0x92, 0x60, 0xe9, 0xe3,
0xa1, 0xa6, 0xba, 0x38, 0x50, 0x23, 0xcc, 0xfa, 0x74, 0xe6, 0x2d, 0xef, 0xf5, 0x4a, 0x2e, 0xdb,
0x44, 0x95, 0x61, 0xcb, 0x9b, 0x70, 0x46, 0xc1, 0x0e, 0x36, 0xb5, 0xd0, 0x8f, 0xd3, 0x4a, 0x21,
0x0f, 0xa1, 0x9d, 0xc4, 0x6e, 0x96, 0xbb, 0x67, 0xc5, 0x5a, 0xd7, 0x26, 0x6c, 0x5d, 0x1e, 0x7b,
0x48, 0x8d, 0x40, 0xf7, 0x71, 0xe5, 0xbf, 0x4a, 0xb0, 0x70, 0x4b, 0xf3, 0xf6, 0x7b, 0x6e, 0x35,
0x61, 0xb4, 0x66, 0xca, 0xc7, 0x6b, 0xa6, 0x67, 0x15, 0x48, 0x78, 0x38, 0x35, 0x47, 0x86, 0x97,
0x26, 0x6c, 0xfa, 0x6d, 0xf7, 0xea, 0x8f, 0x24, 0x58, 0x88, 0x75, 0xfc, 0xa8, 0x01, 0xf0, 0xb1,
0xd9, 0xe3, 0xa3, 0x90, 0xe6, 0x09, 0x54, 0x83, 0xb2, 0x37, 0x18, 0x69, 0x4a, 0xa8, 0x0a, 0x73,
0x3b, 0x16, 0xc5, 0x6e, 0xe6, 0x50, 0x13, 0x6a, 0x8c, 0x70, 0xd4, 0xeb, 0x61, 0xc7, 0x69, 0xe6,
0x05, 0xe4, 0x9e, 0xaa, 0x0f, 0x46, 0x36, 0x6e, 0x16, 0x50, 0x1d, 0x2a, 0x3b, 0x16, 0x7f, 0xf0,
0xd3, 0x2c, 0x22, 0x04, 0x0d, 0xef, 0xf5, 0x0f, 0x27, 0x2a, 0x05, 0x60, 0x1e, 0xd9, 0xdc, 0xd5,
0xbd, 0x60, 0x6f, 0x4c, 0x1a, 0x46, 0x74, 0x1a, 0x4e, 0x7e, 0x6c, 0x6a, 0x78, 0x4f, 0x37, 0xb1,
0xe6, 0xff, 0xd4, 0x3c, 0x81, 0x4e, 0xc2, 0x7c, 0xc7, 0x34, 0xb1, 0x1d, 0x00, 0x4a, 0x04, 0xb8,
0x89, 0xed, 0x3e, 0x0e, 0x00, 0x73, 0x68, 0x01, 0xea, 0x9b, 0xfa, 0x93, 0x00, 0x28, 0xbf, 0xfa,
0xe7, 0xd3, 0x50, 0x59, 0x53, 0x5d, 0xf5, 0x8e, 0x65, 0xd9, 0x1a, 0x1a, 0x02, 0xa2, 0x8f, 0xe2,
0x8c, 0xa1, 0x65, 0x8a, 0xd7, 0xa3, 0xe8, 0x8d, 0x94, 0xb2, 0x26, 0x8e, 0xca, 0xcd, 0xa5, 0x7d,
0x25, 0x85, 0x22, 0x82, 0x2e, 0x9f, 0x40, 0x06, 0xdd, 0x91, 0x34, 0xdc, 0x3b, 0x7a, 0xef, 0xc0,
0xfb, 0xdc, 0x3f, 0x66, 0xc7, 0x08, 0xaa, 0xb7, 0x63, 0xe4, 0x51, 0x2a, 0x5f, 0xb0, 0x97, 0x8b,
0x9e, 0xbf, 0xc8, 0x27, 0xd0, 0x23, 0x38, 0xb5, 0x8e, 0x03, 0xf1, 0xc1, 0xdb, 0x70, 0x35, 0x7d,
0xc3, 0x18, 0xf2, 0x31, 0xb7, 0xdc, 0x80, 0x22, 0x9d, 0xae, 0xa1, 0xa4, 0x10, 0x12, 0xfc, 0xf7,
0x8b, 0xf6, 0x72, 0x3a, 0x82, 0xe0, 0xf6, 0x19, 0xcc, 0x47, 0x9e, 0x88, 0xa3, 0x57, 0x13, 0xc8,
0x92, 0x1f, 0xfb, 0xb7, 0xaf, 0x66, 0x41, 0x15, 0x7b, 0xf5, 0xa1, 0x11, 0x7e, 0x52, 0x87, 0x56,
0x12, 0xe8, 0x13, 0x9f, 0xf7, 0xb6, 0x5f, 0xcd, 0x80, 0x29, 0x36, 0x32, 0xa0, 0x19, 0x7d, 0xb2,
0x8c, 0xae, 0x8e, 0x65, 0x10, 0x36, 0xb7, 0xd7, 0x32, 0xe1, 0x8a, 0xed, 0x8e, 0xa8, 0x11, 0xc4,
0x9e, 0xcc, 0xa2, 0xeb, 0xc9, 0x6c, 0xd2, 0xde, 0xf2, 0xb6, 0x6f, 0x64, 0xc6, 0x17, 0x5b, 0xff,
0x17, 0x9b, 0xea, 0x27, 0x3d, 0x3b, 0x45, 0x6f, 0x26, 0xb3, 0x1b, 0xf3, 0x5e, 0xb6, 0xbd, 0x7a,
0x1c, 0x12, 0x21, 0xc4, 0x17, 0x74, 0x1c, 0x9f, 0xf0, 0x74, 0x33, 0xea, 0x77, 0x1e, 0xbf, 0xf4,
0x37, 0xa9, 0xed, 0x37, 0x8f, 0x41, 0x21, 0x04, 0xb0, 0xa2, 0x8f, 0xc2, 0x3d, 0x37, 0xbc, 0x31,
0xd1, 0x6a, 0xa6, 0xf3, 0xc1, 0x4f, 0x61, 0x3e, 0xf2, 0xb0, 0x22, 0xd1, 0x6b, 0x92, 0x1f, 0x5f,
0xb4, 0xc7, 0xa5, 0x55, 0xe6, 0x92, 0x91, 0xaf, 0x1b, 0x28, 0xc5, 0xfa, 0x13, 0xbe, 0x80, 0xb4,
0xaf, 0x66, 0x41, 0x15, 0x07, 0x71, 0x68, 0xb8, 0x8c, 0x7c, 0x21, 0x40, 0xd7, 0x92, 0x79, 0x24,
0x7f, 0xdd, 0x68, 0xbf, 0x9e, 0x11, 0x5b, 0x6c, 0xda, 0x05, 0x58, 0xc7, 0xee, 0x26, 0x76, 0x6d,
0x62, 0x23, 0x57, 0x12, 0x55, 0xee, 0x23, 0x78, 0xdb, 0xbc, 0x32, 0x11, 0x4f, 0x6c, 0xf0, 0x6f,
0x80, 0xbc, 0x14, 0x1b, 0x78, 0xd6, 0x73, 0x69, 0xec, 0x10, 0x95, 0x4d, 0x3c, 0x27, 0xdd, 0xcd,
0x23, 0x68, 0x6e, 0xaa, 0x26, 0x69, 0x9f, 0x7d, 0xbe, 0xd7, 0x12, 0x05, 0x8b, 0xa2, 0xa5, 0x68,
0x2b, 0x15, 0x5b, 0x1c, 0xe6, 0x50, 0xe4, 0x50, 0x55, 0xb8, 0x20, 0x8e, 0xc6, 0x16, 0x5f, 0x1b,
0x11, 0xc4, 0x94, 0xd8, 0x32, 0x06, 0x5f, 0x6c, 0xfc, 0x54, 0xa2, 0xff, 0x7a, 0x10, 0x41, 0x78,
0xa8, 0xbb, 0xfb, 0x5b, 0x03, 0xd5, 0x74, 0xb2, 0x88, 0x40, 0x11, 0x8f, 0x21, 0x02, 0xc7, 0x17,
0x22, 0x68, 0x50, 0x0f, 0xcd, 0x28, 0x51, 0xd2, 0xdb, 0x9c, 0xa4, 0x29, 0x69, 0x7b, 0x65, 0x32,
0xa2, 0xd8, 0x65, 0x1f, 0xea, 0x9e, 0xbd, 0x32, 0xe5, 0xbe, 0x9a, 0x26, 0xa9, 0x8f, 0x93, 0xe2,
0x6e, 0xc9, 0xa8, 0x41, 0x77, 0x8b, 0x8f, 0x60, 0x50, 0xb6, 0xd1, 0xdd, 0x38, 0x77, 0x4b, 0x9f,
0xeb, 0xb0, 0x78, 0x12, 0x19, 0x77, 0x26, 0x07, 0xab, 0xc4, 0xe9, 0x6d, 0x62, 0x3c, 0x49, 0x99,
0x9e, 0xca, 0x27, 0xd0, 0x43, 0x28, 0xb1, 0xce, 0x0b, 0xbd, 0x3c, 0xbe, 0x29, 0xe3, 0xdc, 0x2f,
0x4f, 0xc0, 0x12, 0x8c, 0x0f, 0xe0, 0x74, 0x4a, 0x4b, 0x96, 0x98, 0xe7, 0xc6, 0xb7, 0x6f, 0x93,
0xbc, 0x5c, 0x05, 0x14, 0x7f, 0xda, 0x9f, 0x78, 0x4d, 0xa9, 0xff, 0x01, 0x90, 0x61, 0x8b, 0xf8,
0xab, 0xfd, 0xc4, 0x2d, 0x52, 0x1f, 0xf7, 0x4f, 0xda, 0xe2, 0x01, 0x80, 0xdf, 0x78, 0x25, 0xde,
0x47, 0xac, 0x2f, 0x9b, 0xc0, 0x72, 0xf5, 0x6f, 0x25, 0x28, 0x7b, 0x2f, 0x61, 0x5e, 0x40, 0x71,
0xff, 0x02, 0xaa, 0xed, 0x4f, 0x61, 0x3e, 0xf2, 0xa4, 0x3e, 0xd1, 0x79, 0x92, 0x9f, 0xdd, 0x4f,
0xba, 0xa1, 0x87, 0xfc, 0x9f, 0x92, 0x45, 0xe2, 0x7d, 0x25, 0xad, 0x62, 0x8f, 0xe6, 0xdc, 0x09,
0x8c, 0x9f, 0x7b, 0x86, 0xbd, 0x0f, 0x10, 0xc8, 0x80, 0xe3, 0x3f, 0x4f, 0x92, 0xa0, 0x3e, 0x49,
0xe0, 0xcd, 0x63, 0xc6, 0x8d, 0x09, 0xec, 0x1c, 0xe2, 0x5d, 0xd1, 0x31, 0x47, 0x8a, 0x77, 0xa5,
0x0c, 0x57, 0x12, 0xe3, 0x6c, 0xfa, 0xec, 0xe4, 0xb9, 0xf8, 0xdb, 0xed, 0x9b, 0xff, 0xfe, 0x66,
0x5f, 0x77, 0xf7, 0x47, 0xbb, 0xe4, 0x97, 0x1b, 0x0c, 0xf5, 0x75, 0xdd, 0xe2, 0x7f, 0xdd, 0xf0,
0x0c, 0xfd, 0x06, 0xa5, 0xbe, 0x41, 0xf6, 0x18, 0xee, 0xee, 0x96, 0xe8, 0xea, 0xe6, 0x3f, 0x02,
0x00, 0x00, 0xff, 0xff, 0xa0, 0x19, 0x51, 0xc3, 0xf7, 0x3f, 0x00, 0x00,
// 3659 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x1b, 0xdb, 0x6e, 0x1b, 0xc7,
0xd5, 0xcb, 0x9b, 0xc8, 0xc3, 0x8b, 0xa8, 0xb1, 0x23, 0xd3, 0xb4, 0x2d, 0xcb, 0xeb, 0xd8, 0x51,
0x1c, 0xc7, 0x4e, 0xe4, 0x06, 0x09, 0x9a, 0x1b, 0x6c, 0xcb, 0x56, 0x88, 0x4a, 0xae, 0xbc, 0x52,
0xe2, 0xa2, 0x29, 0x4a, 0xac, 0xb8, 0x23, 0x6a, 0x23, 0xee, 0x2e, 0xbd, 0xbb, 0xb4, 0xac, 0xbc,
0xc4, 0x68, 0x80, 0x02, 0x29, 0x8a, 0xb6, 0x40, 0x5f, 0x5a, 0xa0, 0x05, 0x8a, 0x3e, 0xf5, 0x82,
0x02, 0x05, 0x82, 0x3e, 0xa4, 0x45, 0xdf, 0x83, 0xf6, 0xa1, 0x1f, 0xd0, 0x0f, 0x68, 0x5f, 0xda,
0x6f, 0x28, 0xe6, 0xb2, 0xb3, 0x77, 0x72, 0x45, 0xd9, 0x71, 0xdf, 0x38, 0x67, 0xcf, 0x9c, 0x39,
0x73, 0xe6, 0xdc, 0x67, 0x08, 0x4d, 0x4d, 0x75, 0xd5, 0x6e, 0xcf, 0xb2, 0x6c, 0xed, 0xea, 0xd0,
0xb6, 0x5c, 0x0b, 0xcd, 0x19, 0xfa, 0xe0, 0xe1, 0xc8, 0x61, 0xa3, 0xab, 0xe4, 0x73, 0xbb, 0xd6,
0xb3, 0x0c, 0xc3, 0x32, 0x19, 0xa8, 0xdd, 0xd0, 0x4d, 0x17, 0xdb, 0xa6, 0x3a, 0xe0, 0xe3, 0x5a,
0x70, 0x42, 0xbb, 0xe6, 0xf4, 0x76, 0xb1, 0xa1, 0xb2, 0x91, 0x3c, 0x03, 0xc5, 0xdb, 0xc6, 0xd0,
0x3d, 0x90, 0x7f, 0x26, 0x41, 0xed, 0xce, 0x60, 0xe4, 0xec, 0x2a, 0xf8, 0xc1, 0x08, 0x3b, 0x2e,
0x7a, 0x05, 0x0a, 0xdb, 0xaa, 0x83, 0x5b, 0xd2, 0xa2, 0xb4, 0x54, 0x5d, 0x3e, 0x73, 0x35, 0xb4,
0x2a, 0x5f, 0x6f, 0xdd, 0xe9, 0xdf, 0x54, 0x1d, 0xac, 0x50, 0x4c, 0x84, 0xa0, 0xa0, 0x6d, 0x77,
0x56, 0x5a, 0xb9, 0x45, 0x69, 0x29, 0xaf, 0xd0, 0xdf, 0x68, 0x01, 0xc0, 0xc1, 0x7d, 0x03, 0x9b,
0x6e, 0x67, 0xc5, 0x69, 0xe5, 0x17, 0xf3, 0x4b, 0x79, 0x25, 0x00, 0x41, 0x32, 0xd4, 0x7a, 0xd6,
0x60, 0x80, 0x7b, 0xae, 0x6e, 0x99, 0x9d, 0x95, 0x56, 0x81, 0xce, 0x0d, 0xc1, 0xe4, 0x5f, 0x48,
0x50, 0xe7, 0xac, 0x39, 0x43, 0xcb, 0x74, 0x30, 0xba, 0x0e, 0x25, 0xc7, 0x55, 0xdd, 0x91, 0xc3,
0xb9, 0x3b, 0x9d, 0xc8, 0xdd, 0x26, 0x45, 0x51, 0x38, 0x6a, 0x22, 0x7b, 0xd1, 0xe5, 0xf3, 0xf1,
0xe5, 0x23, 0x5b, 0x28, 0x44, 0xb7, 0x20, 0xff, 0x41, 0x82, 0xe6, 0xa6, 0x37, 0xf4, 0xa4, 0x77,
0x02, 0x8a, 0x3d, 0x6b, 0x64, 0xba, 0x94, 0xc1, 0xba, 0xc2, 0x06, 0xe8, 0x3c, 0xd4, 0x7a, 0xbb,
0xaa, 0x69, 0xe2, 0x41, 0xd7, 0x54, 0x0d, 0x4c, 0x59, 0xa9, 0x28, 0x55, 0x0e, 0xbb, 0xab, 0x1a,
0x38, 0x13, 0x47, 0x8b, 0x50, 0x1d, 0xaa, 0xb6, 0xab, 0x87, 0x64, 0x16, 0x04, 0xa1, 0x36, 0x94,
0x75, 0xa7, 0x63, 0x0c, 0x2d, 0xdb, 0x6d, 0x15, 0x17, 0xa5, 0xa5, 0xb2, 0x22, 0xc6, 0xf2, 0xaf,
0x24, 0x98, 0xbf, 0xe1, 0x38, 0x7a, 0xdf, 0x8c, 0x71, 0x3d, 0x0f, 0x25, 0xd3, 0xd2, 0x70, 0x67,
0x85, 0xb2, 0x9d, 0x57, 0xf8, 0x08, 0x9d, 0x86, 0xca, 0x10, 0x63, 0xbb, 0x6b, 0x5b, 0x03, 0x8f,
0xe9, 0x32, 0x01, 0x28, 0xd6, 0x00, 0xa3, 0x7b, 0x30, 0xe7, 0x44, 0x08, 0xb1, 0x93, 0xae, 0x2e,
0x5f, 0xb8, 0x1a, 0xd3, 0xd5, 0xab, 0xd1, 0x45, 0x95, 0xf8, 0x6c, 0xf9, 0x71, 0x0e, 0x8e, 0x0b,
0x3c, 0xc6, 0x2b, 0xf9, 0x4d, 0xa4, 0xea, 0xe0, 0xbe, 0x60, 0x8f, 0x0d, 0xb2, 0x48, 0x55, 0x1c,
0x47, 0x3e, 0x78, 0x1c, 0x19, 0x94, 0x2f, 0x2a, 0xeb, 0x62, 0x5c, 0xd6, 0xe7, 0xa0, 0x8a, 0x1f,
0x0d, 0x75, 0x1b, 0x77, 0x5d, 0xdd, 0xc0, 0xad, 0xd2, 0xa2, 0xb4, 0x54, 0x50, 0x80, 0x81, 0xb6,
0x74, 0x23, 0xa8, 0xad, 0x33, 0x99, 0xb5, 0x55, 0xfe, 0xb5, 0x04, 0x27, 0x63, 0xa7, 0xc4, 0xd5,
0x5f, 0x81, 0x26, 0xdd, 0xb9, 0x2f, 0x19, 0x62, 0x08, 0x44, 0xe0, 0x97, 0xc6, 0x09, 0xdc, 0x47,
0x57, 0x62, 0xf3, 0x03, 0x4c, 0xe6, 0xb2, 0x33, 0xb9, 0x07, 0x27, 0x57, 0xb1, 0xcb, 0x17, 0x20,
0xdf, 0xb0, 0x33, 0xbd, 0xfb, 0x08, 0xdb, 0x59, 0x2e, 0x66, 0x67, 0x7f, 0xcc, 0x09, 0x3b, 0xa3,
0x4b, 0x75, 0xcc, 0x1d, 0x0b, 0x9d, 0x81, 0x8a, 0x40, 0xe1, 0x5a, 0xe1, 0x03, 0xd0, 0xeb, 0x50,
0x24, 0x9c, 0x32, 0x95, 0x68, 0x2c, 0x9f, 0x4f, 0xde, 0x53, 0x80, 0xa6, 0xc2, 0xf0, 0x51, 0x07,
0x1a, 0x8e, 0xab, 0xda, 0x6e, 0x77, 0x68, 0x39, 0xf4, 0x9c, 0xa9, 0xe2, 0x54, 0x97, 0xe5, 0x30,
0x05, 0xe1, 0x68, 0xd7, 0x9d, 0xfe, 0x06, 0xc7, 0x54, 0xea, 0x74, 0xa6, 0x37, 0x44, 0xb7, 0xa1,
0x86, 0x4d, 0xcd, 0x27, 0x54, 0xc8, 0x4c, 0xa8, 0x8a, 0x4d, 0x4d, 0x90, 0xf1, 0xcf, 0xa7, 0x98,
0xfd, 0x7c, 0x7e, 0x28, 0x41, 0x2b, 0x7e, 0x40, 0x47, 0x71, 0xa2, 0x6f, 0xb2, 0x49, 0x98, 0x1d,
0xd0, 0x58, 0x0b, 0x17, 0x87, 0xa4, 0xf0, 0x29, 0xb2, 0x0e, 0xcf, 0xf9, 0xdc, 0xd0, 0x2f, 0x4f,
0x4d, 0x59, 0x3e, 0x95, 0x60, 0x3e, 0xba, 0xd6, 0x51, 0xf6, 0xfd, 0x35, 0x28, 0xea, 0xe6, 0x8e,
0xe5, 0x6d, 0x7b, 0x61, 0x8c, 0x9d, 0x91, 0xb5, 0x18, 0xb2, 0x6c, 0xc0, 0xe9, 0x55, 0xec, 0x76,
0x4c, 0x07, 0xdb, 0xee, 0x4d, 0xdd, 0x1c, 0x58, 0xfd, 0x0d, 0xd5, 0xdd, 0x3d, 0x82, 0x8d, 0x84,
0xd4, 0x3d, 0x17, 0x51, 0x77, 0xf9, 0x37, 0x12, 0x9c, 0x49, 0x5e, 0x8f, 0x6f, 0xbd, 0x0d, 0xe5,
0x1d, 0x1d, 0x0f, 0x34, 0x22, 0x33, 0x89, 0xca, 0x4c, 0x8c, 0x89, 0xad, 0x0c, 0x09, 0x32, 0xdf,
0xe1, 0xf9, 0x14, 0x05, 0xdd, 0x74, 0x6d, 0xdd, 0xec, 0xaf, 0xe9, 0x8e, 0xab, 0x30, 0xfc, 0x80,
0x3c, 0xf3, 0xd9, 0x35, 0xf3, 0x07, 0x12, 0x2c, 0xac, 0x62, 0xf7, 0x96, 0x70, 0xb5, 0xe4, 0xbb,
0xee, 0xb8, 0x7a, 0xcf, 0x79, 0xb2, 0x09, 0x48, 0x86, 0x78, 0x2a, 0xff, 0x58, 0x82, 0x73, 0xa9,
0xcc, 0x70, 0xd1, 0x71, 0x57, 0xe2, 0x39, 0xda, 0x64, 0x57, 0xf2, 0x0d, 0x7c, 0xf0, 0x81, 0x3a,
0x18, 0xe1, 0x0d, 0x55, 0xb7, 0x99, 0x2b, 0x99, 0xd2, 0xb1, 0xfe, 0x5e, 0x82, 0xb3, 0xab, 0xd8,
0xdd, 0xf0, 0xc2, 0xcc, 0x33, 0x94, 0xce, 0xe4, 0x6c, 0x43, 0xfe, 0x11, 0x3b, 0xcc, 0x44, 0x6e,
0x9f, 0x89, 0xf8, 0x16, 0xa8, 0x1d, 0x04, 0x0c, 0xf2, 0x16, 0xcb, 0x05, 0xb8, 0xf0, 0xe4, 0x5f,
0x4a, 0x70, 0xea, 0x46, 0xef, 0xc1, 0x48, 0xb7, 0x31, 0x47, 0x5a, 0xb3, 0x7a, 0x7b, 0xd3, 0x8b,
0xd6, 0xcf, 0x9b, 0x72, 0xa1, 0xbc, 0x69, 0x52, 0xf6, 0x3b, 0x0f, 0x25, 0x57, 0x75, 0xf6, 0x84,
0x54, 0xf9, 0x88, 0xf2, 0xa7, 0xe0, 0x01, 0x56, 0x9d, 0xff, 0x4f, 0xfe, 0x1e, 0xe7, 0xa1, 0xf6,
0x01, 0xcf, 0xaf, 0x68, 0x18, 0x8e, 0xea, 0x91, 0x94, 0xac, 0x47, 0x81, 0x94, 0x2c, 0x29, 0x4b,
0x5b, 0x85, 0xba, 0x83, 0xf1, 0xde, 0x34, 0x41, 0xb7, 0x46, 0x26, 0x8a, 0x60, 0xb9, 0x06, 0x73,
0x23, 0x73, 0x87, 0x94, 0x0c, 0x58, 0xe3, 0x02, 0x64, 0x99, 0xfb, 0x64, 0xcf, 0x1d, 0x9f, 0x88,
0xde, 0x83, 0xd9, 0x28, 0xad, 0x62, 0x26, 0x5a, 0xd1, 0x69, 0xa8, 0x03, 0x4d, 0xcd, 0xb6, 0x86,
0x43, 0xac, 0x75, 0x1d, 0x8f, 0x54, 0x29, 0x1b, 0x29, 0x3e, 0xcf, 0x23, 0x25, 0x7f, 0x26, 0xc1,
0xfc, 0x7d, 0xd5, 0xed, 0xed, 0xae, 0x18, 0x5c, 0xb9, 0x8f, 0xe0, 0x1a, 0xde, 0x86, 0xca, 0x43,
0x7e, 0x10, 0x9e, 0xff, 0x3f, 0x97, 0xc0, 0x50, 0xf0, 0xc8, 0x15, 0x7f, 0x86, 0xfc, 0xa5, 0x04,
0x27, 0x68, 0x81, 0xe6, 0x71, 0xf7, 0xd5, 0x3b, 0xa9, 0x09, 0x45, 0x1a, 0xba, 0x04, 0x0d, 0x43,
0xb5, 0xf7, 0x36, 0x7d, 0x9c, 0x22, 0xc5, 0x89, 0x40, 0xe5, 0x47, 0x00, 0x7c, 0xb4, 0xee, 0xf4,
0xa7, 0xe0, 0xff, 0x0d, 0x98, 0xe1, 0xab, 0x72, 0x7f, 0x35, 0xe9, 0x60, 0x3d, 0x74, 0xf9, 0x6f,
0x12, 0x34, 0xfc, 0x08, 0x44, 0xad, 0xaa, 0x01, 0x39, 0x61, 0x4b, 0xb9, 0xce, 0x0a, 0x7a, 0x1b,
0x4a, 0xac, 0x78, 0xe7, 0xb4, 0x2f, 0x86, 0x69, 0xf3, 0xc2, 0x3e, 0x10, 0xc6, 0x28, 0x40, 0xe1,
0x93, 0x88, 0x8c, 0x84, 0xd7, 0x16, 0xd6, 0xee, 0x43, 0x50, 0x07, 0x66, 0xc3, 0x49, 0xaf, 0x67,
0x33, 0x8b, 0x69, 0xde, 0x7a, 0x45, 0x75, 0x55, 0xea, 0xac, 0x1b, 0xa1, 0x9c, 0xd7, 0x91, 0xff,
0x5b, 0x84, 0x6a, 0x60, 0x97, 0xb1, 0x9d, 0x44, 0x8f, 0x34, 0x37, 0x39, 0xee, 0xe4, 0xe3, 0x95,
0xd7, 0x45, 0x68, 0xe8, 0x34, 0xd7, 0xe9, 0x72, 0x55, 0xa4, 0x6e, 0xaa, 0xa2, 0xd4, 0x19, 0x94,
0xdb, 0x05, 0x5a, 0x80, 0xaa, 0x39, 0x32, 0xba, 0xd6, 0x4e, 0xd7, 0xb6, 0xf6, 0x1d, 0x5e, 0xc2,
0x55, 0xcc, 0x91, 0xf1, 0xcd, 0x1d, 0xc5, 0xda, 0x77, 0xfc, 0x2a, 0xa1, 0x74, 0xc8, 0x2a, 0x61,
0x01, 0xaa, 0x86, 0xfa, 0x88, 0x50, 0xed, 0x9a, 0x23, 0x83, 0x56, 0x77, 0x79, 0xa5, 0x62, 0xa8,
0x8f, 0x14, 0x6b, 0xff, 0xee, 0xc8, 0x40, 0x4b, 0xd0, 0x1c, 0xa8, 0x8e, 0xdb, 0x0d, 0x96, 0x87,
0x65, 0x5a, 0x1e, 0x36, 0x08, 0xfc, 0xb6, 0x5f, 0x22, 0xc6, 0xeb, 0x8d, 0xca, 0x11, 0xea, 0x0d,
0xcd, 0x18, 0xf8, 0x84, 0x20, 0x7b, 0xbd, 0xa1, 0x19, 0x03, 0x41, 0xe6, 0x0d, 0x98, 0xd9, 0xa6,
0x19, 0xa4, 0xd3, 0xaa, 0xa6, 0x7a, 0xa8, 0x3b, 0x24, 0x79, 0x64, 0x89, 0xa6, 0xe2, 0xa1, 0xa3,
0xb7, 0xa0, 0x42, 0x43, 0x37, 0x9d, 0x5b, 0xcb, 0x34, 0xd7, 0x9f, 0x40, 0x66, 0x6b, 0x78, 0xe0,
0xaa, 0x74, 0x76, 0x3d, 0xdb, 0x6c, 0x31, 0x01, 0xbd, 0x02, 0xc7, 0x7b, 0x36, 0x56, 0x5d, 0xac,
0xdd, 0x3c, 0xb8, 0x65, 0x19, 0x43, 0x95, 0x2a, 0x53, 0xab, 0x41, 0x5b, 0x20, 0x49, 0x9f, 0x88,
0x63, 0xe8, 0x89, 0xd1, 0x1d, 0xdb, 0x32, 0x5a, 0xb3, 0xcc, 0x31, 0x84, 0xa1, 0xe8, 0x2c, 0x80,
0xe7, 0xba, 0x55, 0xb7, 0xd5, 0xa4, 0xa7, 0x58, 0xe1, 0x90, 0x1b, 0xae, 0xfc, 0x09, 0x9c, 0xf0,
0x35, 0x24, 0x70, 0x1a, 0xf1, 0x83, 0x95, 0xa6, 0x3d, 0xd8, 0xf1, 0xb9, 0xff, 0x3f, 0x0a, 0x30,
0xbf, 0xa9, 0x3e, 0xc4, 0x4f, 0xbf, 0xcc, 0xc8, 0xe4, 0x8f, 0xd7, 0x60, 0x8e, 0x56, 0x16, 0xcb,
0x01, 0x7e, 0xc6, 0x44, 0xe0, 0xe0, 0x71, 0xc6, 0x27, 0xa2, 0x77, 0x49, 0xea, 0x80, 0x7b, 0x7b,
0x1b, 0x96, 0xee, 0x47, 0xdf, 0xb3, 0x09, 0x74, 0x6e, 0x09, 0x2c, 0x25, 0x38, 0x03, 0x6d, 0xc4,
0x5d, 0x1b, 0x8b, 0xbb, 0x2f, 0x8c, 0xad, 0x5f, 0x7d, 0xe9, 0x47, 0x3d, 0x1c, 0x6a, 0xc1, 0x0c,
0x8f, 0xee, 0xd4, 0xee, 0xcb, 0x8a, 0x37, 0x44, 0x1b, 0x70, 0x9c, 0xed, 0x60, 0x93, 0x2b, 0x35,
0xdb, 0x7c, 0x39, 0xd3, 0xe6, 0x93, 0xa6, 0x86, 0x6d, 0xa2, 0x72, 0x58, 0x9b, 0x68, 0xc1, 0x0c,
0xd7, 0x53, 0xea, 0x0b, 0xca, 0x8a, 0x37, 0x24, 0xc7, 0xac, 0xd3, 0x9e, 0xa0, 0x6e, 0xf6, 0x5b,
0x55, 0xfa, 0xcd, 0x07, 0x90, 0x12, 0x0d, 0x7c, 0x79, 0x4e, 0xe8, 0xb4, 0xbc, 0x03, 0x65, 0xa1,
0xe1, 0xb9, 0xcc, 0x1a, 0x2e, 0xe6, 0x44, 0x7d, 0x74, 0x3e, 0xe2, 0xa3, 0xe5, 0xbf, 0x4b, 0x50,
0x5b, 0x21, 0x5b, 0x5a, 0xb3, 0xfa, 0x34, 0xa2, 0x5c, 0x84, 0x86, 0x8d, 0x7b, 0x96, 0xad, 0x75,
0xb1, 0xe9, 0xda, 0x3a, 0x66, 0xd5, 0x7c, 0x41, 0xa9, 0x33, 0xe8, 0x6d, 0x06, 0x24, 0x68, 0xc4,
0xed, 0x3a, 0xae, 0x6a, 0x0c, 0xbb, 0x3b, 0xc4, 0xbc, 0x73, 0x0c, 0x4d, 0x40, 0xa9, 0x75, 0x9f,
0x87, 0x9a, 0x8f, 0xe6, 0x5a, 0x74, 0xfd, 0x82, 0x52, 0x15, 0xb0, 0x2d, 0x0b, 0x3d, 0x0f, 0x0d,
0x2a, 0xd3, 0xee, 0xc0, 0xea, 0x77, 0x49, 0xe5, 0xcb, 0x83, 0x4d, 0x4d, 0xe3, 0x6c, 0x91, 0xb3,
0x0a, 0x63, 0x39, 0xfa, 0xc7, 0x98, 0x87, 0x1b, 0x81, 0xb5, 0xa9, 0x7f, 0x8c, 0x49, 0xac, 0xaf,
0x93, 0xd8, 0x79, 0xd7, 0xd2, 0xf0, 0xd6, 0x94, 0x99, 0x46, 0x86, 0xae, 0xe7, 0x19, 0xa8, 0x88,
0x1d, 0xf0, 0x2d, 0xf9, 0x00, 0x74, 0x07, 0x1a, 0x5e, 0x12, 0xda, 0x65, 0xb5, 0x59, 0x21, 0x35,
0xf3, 0x0b, 0x44, 0x3f, 0x47, 0xa9, 0x7b, 0xd3, 0xe8, 0x50, 0xbe, 0x03, 0xb5, 0xe0, 0x67, 0xb2,
0xea, 0x66, 0x54, 0x51, 0x04, 0x80, 0x68, 0xe3, 0xdd, 0x91, 0x41, 0xce, 0x94, 0x3b, 0x16, 0x6f,
0x28, 0x7f, 0x2a, 0x41, 0x9d, 0x87, 0xec, 0x4d, 0xd1, 0xb1, 0xa7, 0x5b, 0x93, 0xe8, 0xd6, 0xe8,
0x6f, 0xf4, 0xf5, 0x70, 0x4b, 0xef, 0xf9, 0x44, 0x27, 0x40, 0x89, 0xd0, 0xec, 0x38, 0x14, 0xaf,
0xb3, 0xf4, 0x02, 0x1e, 0x13, 0x45, 0xe3, 0x47, 0x43, 0x15, 0xad, 0x05, 0x33, 0xaa, 0xa6, 0xd9,
0xd8, 0x71, 0x38, 0x1f, 0xde, 0x90, 0x7c, 0x79, 0x88, 0x6d, 0xc7, 0x53, 0xf9, 0xbc, 0xe2, 0x0d,
0xd1, 0x5b, 0x50, 0x16, 0xe9, 0x74, 0x3e, 0x29, 0x85, 0x0a, 0xf2, 0xc9, 0x6b, 0x57, 0x31, 0x43,
0xfe, 0x53, 0x0e, 0x1a, 0x5c, 0x60, 0x37, 0x79, 0x4c, 0x1d, 0x6f, 0x7c, 0x37, 0xa1, 0xb6, 0xe3,
0xdb, 0xfe, 0xb8, 0x1e, 0x55, 0xd0, 0x45, 0x84, 0xe6, 0x4c, 0x32, 0xc0, 0x70, 0x54, 0x2f, 0x1c,
0x29, 0xaa, 0x17, 0x0f, 0xeb, 0xc1, 0xe2, 0x79, 0x5e, 0x29, 0x21, 0xcf, 0x93, 0xbf, 0x03, 0xd5,
0x00, 0x01, 0xea, 0xa1, 0x59, 0x73, 0x8b, 0x4b, 0xcc, 0x1b, 0xa2, 0xeb, 0x7e, 0x6e, 0xc3, 0x44,
0x75, 0x2a, 0x81, 0x97, 0x48, 0x5a, 0x23, 0xff, 0x56, 0x82, 0x12, 0xa7, 0x7c, 0x0e, 0xaa, 0xdc,
0xe9, 0xd0, 0xbc, 0x8f, 0x51, 0x07, 0x0e, 0x22, 0x89, 0xdf, 0x93, 0xf3, 0x3a, 0xa7, 0xa0, 0x1c,
0xf1, 0x37, 0x33, 0x3c, 0x2c, 0x78, 0x9f, 0x02, 0x4e, 0x86, 0x7c, 0xa2, 0xfe, 0xe5, 0x4b, 0x89,
0x36, 0xe6, 0x15, 0xdc, 0xb3, 0x1e, 0x62, 0xfb, 0xe0, 0xe8, 0xed, 0xcf, 0x37, 0x03, 0x0a, 0x9d,
0xb1, 0x3e, 0x14, 0x13, 0xd0, 0x9b, 0xbe, 0xb8, 0xf3, 0x49, 0xdd, 0x9f, 0xa0, 0x87, 0xe1, 0xea,
0xe8, 0x8b, 0xfd, 0x27, 0xac, 0x91, 0x1b, 0xde, 0xca, 0xb4, 0x79, 0xcd, 0x13, 0x29, 0x3b, 0xe4,
0x9f, 0x4a, 0x70, 0x6a, 0x15, 0xbb, 0x77, 0xc2, 0xc5, 0xfd, 0xb3, 0xe6, 0xca, 0x80, 0x76, 0x12,
0x53, 0x47, 0x39, 0xf5, 0x36, 0x94, 0x45, 0x9b, 0x82, 0xb5, 0xd8, 0xc5, 0x58, 0xfe, 0xbe, 0x04,
0x2d, 0xbe, 0x0a, 0x5d, 0x93, 0xa4, 0xd4, 0x03, 0xec, 0x62, 0xed, 0xab, 0xae, 0x9b, 0xff, 0x2a,
0x41, 0x33, 0xe8, 0xf1, 0xa9, 0xd3, 0x7e, 0x0d, 0x8a, 0xb4, 0x3d, 0xc1, 0x39, 0x98, 0xa8, 0xac,
0x0c, 0x9b, 0xb8, 0x0c, 0x9a, 0xe6, 0x6d, 0x89, 0xe0, 0xc4, 0x87, 0x7e, 0xd8, 0xc9, 0x1f, 0x3e,
0xec, 0xf0, 0x30, 0x6c, 0x8d, 0x08, 0x5d, 0xd6, 0x48, 0xf3, 0x01, 0xf2, 0xe7, 0x39, 0x68, 0xf9,
0xf5, 0xc8, 0x57, 0xee, 0xf7, 0x53, 0xb2, 0xd5, 0xfc, 0x13, 0xca, 0x56, 0x0b, 0x47, 0xf7, 0xf5,
0xc5, 0x24, 0x5f, 0xff, 0x97, 0x1c, 0x34, 0x7c, 0xa9, 0x6d, 0x0c, 0x54, 0x13, 0xcd, 0x43, 0x69,
0x38, 0x50, 0xfd, 0xee, 0x23, 0x1f, 0xa1, 0x4d, 0x91, 0xe7, 0x84, 0xe5, 0xf4, 0x52, 0xd2, 0x19,
0xa6, 0x1c, 0x84, 0x12, 0x21, 0x41, 0xca, 0x41, 0x56, 0x50, 0xd0, 0xa2, 0x9e, 0xe7, 0x56, 0x4c,
0x59, 0x48, 0x3d, 0x7f, 0x05, 0x10, 0x3f, 0xe1, 0xae, 0x6e, 0x76, 0x1d, 0xdc, 0xb3, 0x4c, 0x8d,
0x9d, 0x7d, 0x51, 0x69, 0xf2, 0x2f, 0x1d, 0x73, 0x93, 0xc1, 0xd1, 0x6b, 0x50, 0x70, 0x0f, 0x86,
0xcc, 0x8b, 0x37, 0x12, 0xbd, 0xa3, 0xcf, 0xd7, 0xd6, 0xc1, 0x10, 0x2b, 0x14, 0x1d, 0x2d, 0x00,
0x10, 0x52, 0xae, 0xad, 0x3e, 0xe4, 0x21, 0xb1, 0xa0, 0x04, 0x20, 0x44, 0x9b, 0x3d, 0x19, 0xce,
0xb0, 0xd0, 0xc1, 0x87, 0xf2, 0x17, 0x39, 0x68, 0xfa, 0x24, 0x15, 0xec, 0x8c, 0x06, 0x6e, 0xaa,
0xfc, 0xc6, 0x17, 0x83, 0x93, 0xf2, 0x86, 0x77, 0xa1, 0xca, 0xcf, 0xf3, 0x10, 0xfa, 0x00, 0x6c,
0xca, 0xda, 0x18, 0x05, 0x2d, 0x3e, 0x21, 0x05, 0x2d, 0x1d, 0x52, 0x41, 0xe5, 0x4d, 0x98, 0xf7,
0xfc, 0x9e, 0x8f, 0xb0, 0x8e, 0x5d, 0x75, 0x4c, 0xc2, 0x71, 0x0e, 0xaa, 0x2c, 0x9e, 0xb1, 0x40,
0xce, 0x52, 0x75, 0xd8, 0x16, 0x15, 0xae, 0xfc, 0x5d, 0x38, 0x41, 0xfd, 0x46, 0xb4, 0x95, 0x9b,
0xa5, 0xaf, 0x2e, 0x8b, 0x42, 0x80, 0x24, 0xfd, 0x4c, 0xbb, 0x2b, 0x4a, 0x08, 0x26, 0xaf, 0xc1,
0x73, 0x11, 0xfa, 0x47, 0x88, 0x0b, 0x24, 0x15, 0x9a, 0xdf, 0x0c, 0x5f, 0x2b, 0x4f, 0x1f, 0xfd,
0xce, 0x8a, 0xce, 0x6d, 0x57, 0xd7, 0xa2, 0xfa, 0xa5, 0xa1, 0x77, 0xa0, 0x62, 0xe2, 0xfd, 0x6e,
0xd0, 0xf9, 0x66, 0x68, 0xd0, 0x95, 0x4d, 0xbc, 0x4f, 0x7f, 0xc9, 0x77, 0xe1, 0x64, 0x8c, 0xd5,
0xa3, 0xec, 0xfd, 0xcf, 0x12, 0x9c, 0x5a, 0xb1, 0xad, 0xe1, 0x07, 0xba, 0xed, 0x8e, 0xd4, 0x41,
0xf8, 0x62, 0xe9, 0xe9, 0x94, 0x71, 0xef, 0x05, 0xc2, 0x30, 0xf3, 0xcb, 0x57, 0x12, 0xd4, 0x35,
0xce, 0x14, 0xdf, 0x74, 0x20, 0x68, 0xff, 0x2b, 0x9f, 0xc4, 0x3c, 0xc7, 0x9b, 0x10, 0x6c, 0xb2,
0x64, 0x29, 0x89, 0x5d, 0x9f, 0xfc, 0xb4, 0x5d, 0x9f, 0x14, 0xcb, 0x2f, 0x3c, 0x21, 0xcb, 0x3f,
0x74, 0x19, 0xf2, 0x1e, 0x84, 0x3b, 0x72, 0xd4, 0xe5, 0x4e, 0xd5, 0xca, 0xbb, 0x09, 0xe0, 0x77,
0xa7, 0xf8, 0xab, 0xa0, 0x2c, 0x64, 0x02, 0xb3, 0xc8, 0x69, 0x09, 0x2f, 0x4b, 0xbb, 0xca, 0xa1,
0x7e, 0xc9, 0x3d, 0x68, 0x27, 0x69, 0xe9, 0x51, 0x34, 0xff, 0xf3, 0x1c, 0x00, 0x7b, 0x42, 0xb6,
0xa5, 0x3a, 0x7b, 0xd3, 0x65, 0x94, 0x17, 0xa0, 0xee, 0x2b, 0x8c, 0x6f, 0xef, 0x41, 0x2d, 0xd2,
0x88, 0x49, 0x88, 0xc4, 0x96, 0xe0, 0xc4, 0x92, 0x5d, 0x8d, 0xd2, 0x09, 0x58, 0x0d, 0x53, 0x8a,
0x88, 0xd3, 0x43, 0xa7, 0xa1, 0x62, 0x5b, 0xfb, 0x5d, 0x62, 0x66, 0x9a, 0xf7, 0x0a, 0xce, 0xb6,
0xf6, 0x89, 0xf1, 0x69, 0xe8, 0x24, 0xcc, 0xb8, 0xaa, 0xb3, 0x47, 0xe8, 0x97, 0x02, 0x77, 0x9b,
0x1a, 0x3a, 0x01, 0xc5, 0x1d, 0x7d, 0x80, 0x9d, 0xd6, 0x0c, 0x25, 0xc9, 0x06, 0xe8, 0x75, 0xef,
0xfd, 0x47, 0x39, 0xf3, 0xfd, 0x35, 0x7b, 0x02, 0xf2, 0xa5, 0x04, 0xb3, 0xbe, 0xd4, 0xa8, 0x03,
0x22, 0x3e, 0x8d, 0xfa, 0xb3, 0x5b, 0x96, 0xc6, 0x5c, 0x45, 0x23, 0xe5, 0x8a, 0x85, 0x4d, 0x64,
0x5e, 0xcb, 0x9f, 0x32, 0x2e, 0x2f, 0x27, 0xfb, 0x22, 0x9b, 0xd6, 0x35, 0xef, 0x86, 0xa7, 0x64,
0x5b, 0xfb, 0x1d, 0x4d, 0x48, 0x83, 0x3d, 0x83, 0x63, 0x59, 0x28, 0x91, 0xc6, 0x2d, 0xfa, 0x12,
0xee, 0x02, 0xd4, 0xb1, 0x6d, 0x5b, 0x76, 0xd7, 0xc0, 0x8e, 0xa3, 0xf6, 0x31, 0x4f, 0xba, 0x6a,
0x14, 0xb8, 0xce, 0x60, 0xf2, 0x17, 0x79, 0x68, 0xf8, 0x5b, 0xf1, 0xee, 0x75, 0x74, 0xcd, 0xbb,
0xd7, 0xd1, 0x35, 0xe2, 0xcc, 0x6d, 0xe6, 0x0a, 0x03, 0xce, 0x9c, 0x43, 0x3a, 0x1a, 0x89, 0x83,
0xc4, 0xc0, 0x4c, 0x4b, 0xc3, 0xfe, 0xc1, 0x82, 0x07, 0xe2, 0xe7, 0x1a, 0xd2, 0x8f, 0x42, 0x06,
0xfd, 0x28, 0x66, 0xd0, 0x8f, 0x52, 0x82, 0x7e, 0xcc, 0x43, 0x69, 0x7b, 0xd4, 0xdb, 0xc3, 0x2e,
0x4f, 0x8f, 0xf8, 0x28, 0xac, 0x37, 0xe5, 0x88, 0xde, 0x08, 0xf5, 0xa8, 0x04, 0xd5, 0xe3, 0x34,
0x54, 0xd8, 0xe5, 0x42, 0xd7, 0x75, 0x68, 0x97, 0x35, 0xaf, 0x94, 0x19, 0x60, 0xcb, 0x41, 0x6f,
0x78, 0xb5, 0x43, 0x35, 0xc9, 0xd0, 0xa9, 0xc7, 0x89, 0x68, 0x88, 0x57, 0x39, 0x5c, 0x84, 0x06,
0x7d, 0xfe, 0xfb, 0x60, 0x84, 0xed, 0x03, 0x75, 0x7b, 0x80, 0x5b, 0x35, 0xca, 0x4e, 0x9d, 0x40,
0xef, 0x79, 0x40, 0x22, 0x10, 0x8a, 0xa6, 0x9b, 0x1a, 0x7e, 0x84, 0xb5, 0x56, 0x9d, 0x22, 0x51,
0x51, 0x77, 0x18, 0x48, 0xfe, 0x08, 0x90, 0xbf, 0xc6, 0xd1, 0xaa, 0xc2, 0xc8, 0x21, 0xe6, 0xa2,
0x87, 0x28, 0xff, 0x4e, 0x82, 0xb9, 0xe0, 0x62, 0xd3, 0x86, 0xc6, 0x77, 0xa0, 0xca, 0xba, 0xd1,
0x5d, 0x62, 0x9a, 0xbc, 0x2e, 0x3c, 0x3b, 0x56, 0x7a, 0x0a, 0xe8, 0xbe, 0x87, 0xba, 0x00, 0xf5,
0x7d, 0xcb, 0xde, 0xd3, 0xcd, 0x7e, 0x97, 0x70, 0xe6, 0x19, 0x44, 0x8d, 0x03, 0xef, 0x12, 0x98,
0xfc, 0x99, 0x04, 0x0b, 0xef, 0x0f, 0x35, 0xd5, 0xc5, 0x81, 0x1c, 0xe1, 0xa8, 0x4f, 0x6d, 0x5e,
0xf3, 0x5e, 0xbb, 0xe4, 0xb2, 0x75, 0x54, 0x19, 0xb6, 0xbc, 0x0e, 0xa7, 0x14, 0xec, 0x60, 0x53,
0x0b, 0x7d, 0x9c, 0x96, 0x0b, 0x79, 0x08, 0xed, 0x24, 0x72, 0x47, 0x39, 0x7b, 0x96, 0xac, 0x75,
0x6d, 0x42, 0xd6, 0xe5, 0xbe, 0x87, 0xe4, 0x08, 0x74, 0x1d, 0x57, 0xfe, 0xb7, 0x04, 0x73, 0x37,
0x34, 0x6f, 0xbd, 0xa7, 0x96, 0x13, 0x46, 0x73, 0xa6, 0x7c, 0x3c, 0x67, 0x7a, 0x52, 0x8e, 0x84,
0xbb, 0x53, 0x73, 0x64, 0x78, 0x61, 0xc2, 0xa6, 0x77, 0xbb, 0xf2, 0x8e, 0xb8, 0xf0, 0x53, 0xf0,
0x0e, 0xb6, 0xb1, 0xd9, 0xc3, 0x6b, 0x56, 0x6f, 0x2f, 0xf0, 0x64, 0x46, 0x0a, 0x3e, 0x99, 0x99,
0xf6, 0x09, 0xce, 0xe5, 0x9f, 0x4b, 0x30, 0x17, 0xeb, 0x2c, 0xa0, 0x06, 0xc0, 0xfb, 0x66, 0x8f,
0xb7, 0x5c, 0x9a, 0xc7, 0x50, 0x0d, 0xca, 0x5e, 0x03, 0xa6, 0x29, 0xa1, 0x2a, 0xcc, 0x6c, 0x59,
0x14, 0xbb, 0x99, 0x43, 0x4d, 0xa8, 0xb1, 0x89, 0xa3, 0x5e, 0x0f, 0x3b, 0x4e, 0x33, 0x2f, 0x20,
0x77, 0x54, 0x7d, 0x30, 0xb2, 0x71, 0xb3, 0x80, 0xea, 0x50, 0xd9, 0xb2, 0xf8, 0x83, 0xa3, 0x66,
0x11, 0x21, 0x68, 0x78, 0xaf, 0x8f, 0xf8, 0xa4, 0x52, 0x00, 0xe6, 0x4d, 0x9b, 0xb9, 0xbc, 0x13,
0xac, 0xc1, 0x49, 0x61, 0x8a, 0x4e, 0xc2, 0xf1, 0xf7, 0x4d, 0x0d, 0xef, 0xe8, 0x26, 0xd6, 0xfc,
0x4f, 0xcd, 0x63, 0xe8, 0x38, 0xcc, 0x76, 0x4c, 0x13, 0xdb, 0x01, 0xa0, 0x44, 0x80, 0xeb, 0xd8,
0xee, 0xe3, 0x00, 0x30, 0x87, 0xe6, 0xa0, 0xbe, 0xae, 0x3f, 0x0a, 0x80, 0xf2, 0xcb, 0xff, 0x3c,
0x09, 0x95, 0x15, 0xd5, 0x55, 0x6f, 0x59, 0x96, 0xad, 0xa1, 0x21, 0x20, 0xfa, 0x58, 0xcf, 0x18,
0x5a, 0xa6, 0x78, 0xd5, 0x8a, 0x5e, 0x49, 0x49, 0x9f, 0xe2, 0xa8, 0x5c, 0x2d, 0xdb, 0x97, 0x52,
0x66, 0x44, 0xd0, 0xe5, 0x63, 0xc8, 0xa0, 0x2b, 0x92, 0xc2, 0x7e, 0x4b, 0xef, 0xed, 0x79, 0xcf,
0x0a, 0xc6, 0xac, 0x18, 0x41, 0xf5, 0x56, 0x8c, 0x3c, 0x96, 0xe5, 0x03, 0xf6, 0xa2, 0xd2, 0xb3,
0x4b, 0xf9, 0x18, 0x7a, 0x00, 0x27, 0x56, 0x71, 0xc0, 0x0f, 0x79, 0x0b, 0x2e, 0xa7, 0x2f, 0x18,
0x43, 0x3e, 0xe4, 0x92, 0x6b, 0x50, 0xa4, 0x5d, 0x3c, 0x94, 0xe4, 0xaa, 0x82, 0x7f, 0x0b, 0x69,
0x2f, 0xa6, 0x23, 0x08, 0x6a, 0x1f, 0xc1, 0x6c, 0xe4, 0xe9, 0x3a, 0x7a, 0x31, 0x61, 0x5a, 0xf2,
0x9f, 0x10, 0xda, 0x97, 0xb3, 0xa0, 0x8a, 0xb5, 0xfa, 0xd0, 0x08, 0x3f, 0xf5, 0x43, 0x4b, 0x09,
0xf3, 0x13, 0x9f, 0x1d, 0xb7, 0x5f, 0xcc, 0x80, 0x29, 0x16, 0x32, 0xa0, 0x19, 0x7d, 0x4a, 0x8d,
0x2e, 0x8f, 0x25, 0x10, 0x56, 0xb7, 0x97, 0x32, 0xe1, 0x8a, 0xe5, 0x0e, 0xa8, 0x12, 0xc4, 0x9e,
0xf2, 0xa2, 0xab, 0xc9, 0x64, 0xd2, 0xde, 0x18, 0xb7, 0xaf, 0x65, 0xc6, 0x17, 0x4b, 0x7f, 0x8f,
0xdd, 0x1e, 0x24, 0x3d, 0x87, 0x45, 0xaf, 0x26, 0x93, 0x1b, 0xf3, 0x8e, 0xb7, 0xbd, 0x7c, 0x98,
0x29, 0x82, 0x89, 0x4f, 0x68, 0xdb, 0x3f, 0xe1, 0x49, 0x69, 0xd4, 0xee, 0x3c, 0x7a, 0xe9, 0x6f,
0x65, 0xdb, 0xaf, 0x1e, 0x62, 0x86, 0x60, 0xc0, 0x8a, 0x3e, 0x56, 0xf7, 0xcc, 0xf0, 0xda, 0x44,
0xad, 0x99, 0xce, 0x06, 0x3f, 0x84, 0xd9, 0xc8, 0x03, 0x8e, 0x44, 0xab, 0x49, 0x7e, 0xe4, 0xd1,
0x1e, 0x17, 0xbe, 0x99, 0x49, 0x46, 0x6e, 0x51, 0x50, 0x8a, 0xf6, 0x27, 0xdc, 0xb4, 0xb4, 0x2f,
0x67, 0x41, 0x15, 0x1b, 0x71, 0xa8, 0xbb, 0x8c, 0xdc, 0x44, 0xa0, 0x2b, 0xc9, 0x34, 0x92, 0x6f,
0x51, 0xda, 0x2f, 0x67, 0xc4, 0x16, 0x8b, 0x76, 0x01, 0x56, 0xb1, 0xbb, 0x8e, 0x5d, 0x9b, 0xe8,
0xc8, 0xa5, 0x44, 0x91, 0xfb, 0x08, 0xde, 0x32, 0x2f, 0x4c, 0xc4, 0x13, 0x0b, 0x7c, 0x0b, 0x90,
0x17, 0x62, 0x03, 0xcf, 0x87, 0x2e, 0x8c, 0x6d, 0xd6, 0xb2, 0xce, 0xea, 0xa4, 0xb3, 0x79, 0x00,
0xcd, 0x75, 0xd5, 0x24, 0x65, 0xba, 0x4f, 0xf7, 0x4a, 0x22, 0x63, 0x51, 0xb4, 0x14, 0x69, 0xa5,
0x62, 0x8b, 0xcd, 0xec, 0x8b, 0x18, 0xaa, 0x0a, 0x13, 0xc4, 0x51, 0xdf, 0xe2, 0x4b, 0x23, 0x82,
0x98, 0xe2, 0x5b, 0xc6, 0xe0, 0x8b, 0x85, 0x1f, 0x4b, 0xf4, 0x2f, 0x11, 0x11, 0x84, 0xfb, 0xba,
0xbb, 0xbb, 0x31, 0x50, 0x4d, 0x27, 0x0b, 0x0b, 0x14, 0xf1, 0x10, 0x2c, 0x70, 0x7c, 0xc1, 0x82,
0x06, 0xf5, 0x50, 0x2f, 0x14, 0x25, 0xbd, 0x01, 0x4a, 0xea, 0xc6, 0xb6, 0x97, 0x26, 0x23, 0x8a,
0x55, 0x76, 0xa1, 0xee, 0xe9, 0x2b, 0x13, 0xee, 0x8b, 0x69, 0x9c, 0xfa, 0x38, 0x29, 0xe6, 0x96,
0x8c, 0x1a, 0x34, 0xb7, 0x78, 0xab, 0x07, 0x65, 0x6b, 0x11, 0x8e, 0x33, 0xb7, 0xf4, 0xfe, 0x11,
0xf3, 0x27, 0x91, 0xb6, 0x6a, 0xb2, 0xb3, 0x4a, 0xec, 0x12, 0x27, 0xfa, 0x93, 0x94, 0x2e, 0xad,
0x7c, 0x0c, 0xdd, 0x87, 0x12, 0xab, 0xf0, 0xd0, 0xf3, 0xe3, 0x8b, 0x3f, 0x4e, 0xfd, 0xe2, 0x04,
0x2c, 0x41, 0x78, 0x0f, 0x4e, 0xa6, 0x94, 0x7e, 0x89, 0x71, 0x6e, 0x7c, 0x99, 0x38, 0xc9, 0xca,
0x55, 0x40, 0xf1, 0xbf, 0x1c, 0x24, 0x1e, 0x53, 0xea, 0x3f, 0x13, 0x32, 0x2c, 0x11, 0xff, 0xd7,
0x40, 0xe2, 0x12, 0xa9, 0x7f, 0x2e, 0x98, 0xb4, 0xc4, 0x3d, 0x00, 0xbf, 0xc0, 0x4b, 0x3c, 0x8f,
0x58, 0xfd, 0x37, 0x81, 0xe4, 0xf2, 0x7f, 0x4a, 0x50, 0xf6, 0x5e, 0xdc, 0x3c, 0x83, 0xe4, 0xfe,
0x19, 0x64, 0xdb, 0x1f, 0xc2, 0x6c, 0xe4, 0xe9, 0x7e, 0xa2, 0xf1, 0x24, 0x3f, 0xef, 0x9f, 0x74,
0x42, 0xf7, 0xf9, 0x9f, 0xa5, 0x45, 0xe0, 0x7d, 0x21, 0x2d, 0x63, 0x8f, 0xc6, 0xdc, 0x09, 0x84,
0x9f, 0x7a, 0x84, 0xbd, 0x0b, 0x10, 0x88, 0x80, 0xe3, 0xaf, 0x41, 0x89, 0x53, 0x9f, 0xc4, 0xf0,
0xfa, 0x21, 0xfd, 0xc6, 0x04, 0x72, 0x0e, 0xb1, 0xae, 0x68, 0x3b, 0x25, 0xc5, 0xba, 0x52, 0x9a,
0x38, 0x89, 0x7e, 0x36, 0xbd, 0x47, 0xf3, 0x54, 0xec, 0xed, 0xe6, 0xf5, 0x6f, 0xbf, 0xda, 0xd7,
0xdd, 0xdd, 0xd1, 0x36, 0xf9, 0x72, 0x8d, 0xa1, 0xbe, 0xac, 0x5b, 0xfc, 0xd7, 0x35, 0x4f, 0xd1,
0xaf, 0xd1, 0xd9, 0xd7, 0xc8, 0x1a, 0xc3, 0xed, 0xed, 0x12, 0x1d, 0x5d, 0xff, 0x5f, 0x00, 0x00,
0x00, 0xff, 0xff, 0x49, 0xff, 0x1b, 0x78, 0x8f, 0x40, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

9
internal/querycoord/global_meta_broker.go
View File

@ -479,10 +479,11 @@ func (broker *globalMetaBroker) getSegmentStates(ctx context.Context, segmentID
return resp.States[0], nil
}
func (broker *globalMetaBroker) acquireSegmentsReferLock(ctx context.Context, segmentIDs []UniqueID) error {
func (broker *globalMetaBroker) acquireSegmentsReferLock(ctx context.Context, taskID int64, segmentIDs []UniqueID) error {
ctx, cancel := context.WithTimeout(ctx, timeoutForRPC)
defer cancel()
acquireSegLockReq := &datapb.AcquireSegmentLockRequest{
TaskID: taskID,
SegmentIDs: segmentIDs,
NodeID: Params.QueryCoordCfg.GetNodeID(),
}
@ -501,13 +502,13 @@ func (broker *globalMetaBroker) acquireSegmentsReferLock(ctx context.Context, se
return nil
}
func (broker *globalMetaBroker) releaseSegmentReferLock(ctx context.Context, segmentIDs []UniqueID) error {
func (broker *globalMetaBroker) releaseSegmentReferLock(ctx context.Context, taskID int64, segmentIDs []UniqueID) error {
ctx, cancel := context.WithTimeout(ctx, timeoutForRPC)
defer cancel()
releaseSegReferLockReq := &datapb.ReleaseSegmentLockRequest{
SegmentIDs: segmentIDs,
NodeID: Params.QueryCoordCfg.GetNodeID(),
TaskID: taskID,
NodeID: Params.QueryCoordCfg.GetNodeID(),
}
if err := retry.Do(ctx, func() error {

4
internal/querycoord/task.go
View File

@ -1239,7 +1239,7 @@ func (lst *loadSegmentTask) preExecute(ctx context.Context) error {
zap.Int64("loaded nodeID", lst.DstNodeID),
zap.Int64("taskID", lst.getTaskID()))
if err := lst.broker.acquireSegmentsReferLock(ctx, segmentIDs); err != nil {
if err := lst.broker.acquireSegmentsReferLock(ctx, lst.taskID, segmentIDs); err != nil {
log.Error("acquire reference lock on segments failed", zap.Int64s("segmentIDs", segmentIDs),
zap.Error(err))
return err
@ -1267,7 +1267,7 @@ func (lst *loadSegmentTask) postExecute(context.Context) error {
for _, info := range lst.Infos {
segmentIDs = append(segmentIDs, info.SegmentID)
}
if err := lst.broker.releaseSegmentReferLock(lst.ctx, segmentIDs); err != nil {
if err := lst.broker.releaseSegmentReferLock(lst.ctx, lst.taskID, segmentIDs); err != nil {
panic(err)
}

8
internal/rootcoord/import_manager.go
View File

@ -135,7 +135,7 @@ func (m *importManager) sendOutTasksLoop(wg *sync.WaitGroup) {
}
// expireOldTasksLoop starts a loop that checks and expires old tasks every `ImportTaskExpiration` seconds.
func (m *importManager) expireOldTasksLoop(wg *sync.WaitGroup, releaseLockFunc func(context.Context, []int64) error) {
func (m *importManager) expireOldTasksLoop(wg *sync.WaitGroup, releaseLockFunc func(context.Context, int64, []int64) error) {
defer wg.Done()
ticker := time.NewTicker(time.Duration(expireOldTasksInterval) * time.Millisecond)
defer ticker.Stop()
@ -607,7 +607,7 @@ func (m *importManager) updateImportTaskStore(ti *datapb.ImportTaskInfo) error {
}
// expireOldTasks marks expires tasks as failed.
func (m *importManager) expireOldTasks(releaseLockFunc func(context.Context, []int64) error) {
func (m *importManager) expireOldTasks(releaseLockFunc func(context.Context, int64, []int64) error) {
// Expire old pending tasks, if any.
func() {
m.pendingLock.Lock()
@ -622,7 +622,7 @@ func (m *importManager) expireOldTasks(releaseLockFunc func(context.Context, []i
log.Info("releasing seg ref locks on expired import task",
zap.Int64s("segment IDs", t.GetState().GetSegments()))
err := retry.Do(m.ctx, func() error {
return releaseLockFunc(m.ctx, t.GetState().GetSegments())
return releaseLockFunc(m.ctx, t.GetId(), t.GetState().GetSegments())
}, retry.Attempts(100))
if err != nil {
log.Error("failed to release lock, about to panic!")
@ -646,7 +646,7 @@ func (m *importManager) expireOldTasks(releaseLockFunc func(context.Context, []i
log.Info("releasing seg ref locks on expired import task",
zap.Int64s("segment IDs", v.GetState().GetSegments()))
err := retry.Do(m.ctx, func() error {
return releaseLockFunc(m.ctx, v.GetState().GetSegments())
return releaseLockFunc(m.ctx, v.GetId(), v.GetState().GetSegments())
}, retry.Attempts(100))
if err != nil {
log.Error("failed to release lock, about to panic!")

8
internal/rootcoord/import_manager_test.go
View File

@ -93,7 +93,7 @@ func TestImportManager_NewImportManager(t *testing.T) {
mgr.init(ctx)
var wgLoop sync.WaitGroup
wgLoop.Add(2)
mgr.expireOldTasksLoop(&wgLoop, func(ctx context.Context, int64s []int64) error {
mgr.expireOldTasksLoop(&wgLoop, func(ctx context.Context, int64 int64, int64s []int64) error {
return nil
})
mgr.sendOutTasksLoop(&wgLoop)
@ -110,7 +110,7 @@ func TestImportManager_NewImportManager(t *testing.T) {
mgr.init(context.TODO())
var wgLoop sync.WaitGroup
wgLoop.Add(2)
mgr.expireOldTasksLoop(&wgLoop, func(ctx context.Context, int64s []int64) error {
mgr.expireOldTasksLoop(&wgLoop, func(ctx context.Context, int64 int64, int64s []int64) error {
return nil
})
mgr.sendOutTasksLoop(&wgLoop)
@ -134,7 +134,7 @@ func TestImportManager_NewImportManager(t *testing.T) {
mgr.loadFromTaskStore()
var wgLoop sync.WaitGroup
wgLoop.Add(2)
mgr.expireOldTasksLoop(&wgLoop, func(ctx context.Context, int64s []int64) error {
mgr.expireOldTasksLoop(&wgLoop, func(ctx context.Context, int64 int64, int64s []int64) error {
return nil
})
mgr.sendOutTasksLoop(&wgLoop)
@ -151,7 +151,7 @@ func TestImportManager_NewImportManager(t *testing.T) {
mgr.init(ctx)
var wgLoop sync.WaitGroup
wgLoop.Add(2)
mgr.expireOldTasksLoop(&wgLoop, func(ctx context.Context, int64s []int64) error {
mgr.expireOldTasksLoop(&wgLoop, func(ctx context.Context, int64 int64, int64s []int64) error {
return nil
})
mgr.sendOutTasksLoop(&wgLoop)

16
internal/rootcoord/root_coord.go
View File

@ -155,10 +155,10 @@ type Core struct {
CallFlushOnCollection func(ctx context.Context, cID int64, segIDs []int64) error
// CallAddSegRefLock triggers AcquireSegmentLock method on DataCoord.
CallAddSegRefLock func(ctx context.Context, segIDs []int64) (retErr error)
CallAddSegRefLock func(ctx context.Context, taskID int64, segIDs []int64) (retErr error)
// CallReleaseSegRefLock triggers ReleaseSegmentLock method on DataCoord.
CallReleaseSegRefLock func(ctx context.Context, segIDs []int64) (retErr error)
CallReleaseSegRefLock func(ctx context.Context, taskID int64, segIDs []int64) (retErr error)
//Proxy manager
proxyManager *proxyManager
@ -697,7 +697,7 @@ func (c *Core) SetDataCoord(ctx context.Context, s types.DataCoord) error {
return nil
}
c.CallAddSegRefLock = func(ctx context.Context, segIDs []int64) (retErr error) {
c.CallAddSegRefLock = func(ctx context.Context, taskID int64, segIDs []int64) (retErr error) {
defer func() {
if err := recover(); err != nil {
retErr = fmt.Errorf("add seg ref lock panic, msg = %v", err)
@ -710,6 +710,7 @@ func (c *Core) SetDataCoord(ctx context.Context, s types.DataCoord) error {
resp, _ := s.AcquireSegmentLock(ctx, &datapb.AcquireSegmentLockRequest{
SegmentIDs: segIDs,
NodeID: c.session.ServerID,
TaskID: taskID,
})
if resp.GetErrorCode() != commonpb.ErrorCode_Success {
return fmt.Errorf("failed to acquire segment lock %s", resp.GetReason())
@ -720,7 +721,7 @@ func (c *Core) SetDataCoord(ctx context.Context, s types.DataCoord) error {
return nil
}
c.CallReleaseSegRefLock = func(ctx context.Context, segIDs []int64) (retErr error) {
c.CallReleaseSegRefLock = func(ctx context.Context, taskID int64, segIDs []int64) (retErr error) {
defer func() {
if err := recover(); err != nil {
retErr = fmt.Errorf("release seg ref lock panic, msg = %v", err)
@ -733,6 +734,7 @@ func (c *Core) SetDataCoord(ctx context.Context, s types.DataCoord) error {
resp, _ := s.ReleaseSegmentLock(ctx, &datapb.ReleaseSegmentLockRequest{
SegmentIDs: segIDs,
NodeID: c.session.ServerID,
TaskID: taskID,
})
if resp.GetErrorCode() != commonpb.ErrorCode_Success {
return fmt.Errorf("failed to release segment lock %s", resp.GetReason())
@ -2409,7 +2411,7 @@ func (c *Core) ReportImport(ctx context.Context, ir *rootcoordpb.ImportResult) (
if ir.GetState() == commonpb.ImportState_ImportAllocSegment {
// Lock the segments, so we don't lose track of them when compaction happens.
// Note that these locks will be unlocked in c.postImportPersistLoop() -> checkSegmentLoadedLoop().
if err := c.CallAddSegRefLock(ctx, ir.GetSegments()); err != nil {
if err := c.CallAddSegRefLock(ctx, ir.GetTaskId(), ir.GetSegments()); err != nil {
log.Error("failed to acquire segment ref lock", zap.Error(err))
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
@ -2450,7 +2452,7 @@ func (c *Core) ReportImport(ctx context.Context, ir *rootcoordpb.ImportResult) (
// Release segments when task fails.
log.Info("task failed, release segment ref locks")
err := retry.Do(ctx, func() error {
return c.CallReleaseSegRefLock(ctx, ir.GetSegments())
return c.CallReleaseSegRefLock(ctx, ir.GetTaskId(), ir.GetSegments())
}, retry.Attempts(100))
if err != nil {
log.Error("failed to release lock, about to panic!")
@ -2630,7 +2632,7 @@ func (c *Core) checkSegmentLoadedLoop(ctx context.Context, taskID int64, colID i
defer func() {
log.Info("we are done checking segment loading state, release segment ref locks")
err := retry.Do(ctx, func() error {
return c.CallReleaseSegRefLock(ctx, segIDs)
return c.CallReleaseSegRefLock(ctx, taskID, segIDs)
}, retry.Attempts(100))
if err != nil {
log.Error("failed to release lock, about to panic!")

4
internal/rootcoord/root_coord_test.go
View File

@ -3074,13 +3074,13 @@ func TestCheckInit(t *testing.T) {
err = c.checkInit()
assert.Error(t, err)
c.CallAddSegRefLock = func(context.Context, []int64) error {
c.CallAddSegRefLock = func(context.Context, int64, []int64) error {
return nil
}
err = c.checkInit()
assert.Error(t, err)
c.CallReleaseSegRefLock = func(context.Context, []int64) error {
c.CallReleaseSegRefLock = func(context.Context, int64, []int64) error {
return nil
}
err = c.checkInit()