test/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2024-11-29 18:38:44 +08:00
Code Issues Actions 11 Packages Projects Releases Wiki Activity

Remove collection meta after GC finished (#21595)

Browse Source 
Signed-off-by: longjiquan <jiquan.long@zilliz.com>
This commit is contained in:
Jiquan Long 2023-01-12 09:55:42 +08:00 committed by GitHub
parent 6d09bbed68
commit 9fd9bed2b9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
37 changed files with 2494 additions and 467 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile
View File

@ -297,6 +297,9 @@ mock-datanode:
mock-rootcoord:
mockery --name=RootCoord --dir=$(PWD)/internal/types --output=$(PWD)/internal/mocks --filename=mock_rootcoord.go --with-expecter
mock-datacoord:
mockery --name=DataCoord --dir=$(PWD)/internal/types --output=$(PWD)/internal/mocks --filename=mock_datacoord.go --with-expecter
mock-tnx-kv:
mockery --name=TxnKV --dir=$(PWD)/internal/kv --output=$(PWD)/internal/kv/mocks --filename=TxnKV.go --with-expecter

4
internal/datacoord/meta.go
View File

@ -1269,6 +1269,10 @@ func (m *meta) DropChannelCheckpoint(vChannel string) error {
return nil
}
func (m *meta) GcConfirm(ctx context.Context, collectionID, partitionID UniqueID) bool {
return m.catalog.GcConfirm(ctx, collectionID, partitionID)
}
// addNewSeg update metrics update for a new segment.
func (s *segMetricMutation) addNewSeg(state commonpb.SegmentState, rowCount int64) {
s.stateChange[state.String()]++

25
internal/datacoord/meta_test.go
View File

@ -23,19 +23,18 @@ import (
"testing"
"github.com/golang/protobuf/proto"
"github.com/samber/lo"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"github.com/milvus-io/milvus-proto/go-api/commonpb"
"github.com/milvus-io/milvus/internal/common"
"github.com/milvus-io/milvus/internal/kv"
"github.com/milvus-io/milvus/internal/metastore/kv/datacoord"
"github.com/milvus-io/milvus/internal/metastore/mocks"
"github.com/milvus-io/milvus/internal/metastore/model"
"github.com/milvus-io/milvus/internal/mocks"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/samber/lo"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
)
func TestMetaReloadFromKV(t *testing.T) {
@ -945,3 +944,17 @@ func TestChannelCP(t *testing.T) {
assert.NoError(t, err)
})
}
func Test_meta_GcConfirm(t *testing.T) {
m := &meta{}
catalog := mocks.NewDataCoordCatalog(t)
m.catalog = catalog
catalog.On("GcConfirm",
mock.Anything,
mock.AnythingOfType("int64"),
mock.AnythingOfType("int64")).
Return(false)
assert.False(t, m.GcConfirm(context.TODO(), 100, 10000))
}

18
internal/datacoord/services.go
View File

@ -1443,3 +1443,21 @@ func (s *Server) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthReque
return &milvuspb.CheckHealthResponse{IsHealthy: true, Reasons: errReasons}, nil
}
func (s *Server) GcConfirm(ctx context.Context, request *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
resp := &datapb.GcConfirmResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
},
GcFinished: false,
}
if s.isClosed() {
resp.Status.Reason = msgDataCoordIsUnhealthy(paramtable.GetNodeID())
return resp, nil
}
resp.GcFinished = s.meta.GcConfirm(ctx, request.GetCollectionId(), request.GetPartitionId())
resp.Status.ErrorCode = commonpb.ErrorCode_Success
return resp, nil
}

35
internal/datacoord/services_test.go
View File

@ -4,6 +4,9 @@ import (
"context"
"testing"
"github.com/milvus-io/milvus/internal/mocks"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/assert"
"github.com/milvus-io/milvus-proto/go-api/commonpb"
@ -54,3 +57,35 @@ func TestBroadcastAlteredCollection(t *testing.T) {
assert.NotNil(t, s.meta.collections[1].Properties)
})
}
func TestServer_GcConfirm(t *testing.T) {
t.Run("closed server", func(t *testing.T) {
s := &Server{}
s.stateCode.Store(commonpb.StateCode_Initializing)
resp, err := s.GcConfirm(context.TODO(), &datapb.GcConfirmRequest{CollectionId: 100, PartitionId: 10000})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
t.Run("normal case", func(t *testing.T) {
s := &Server{}
s.stateCode.Store(commonpb.StateCode_Healthy)
m := &meta{}
catalog := mocks.NewDataCoordCatalog(t)
m.catalog = catalog
catalog.On("GcConfirm",
mock.Anything,
mock.AnythingOfType("int64"),
mock.AnythingOfType("int64")).
Return(false)
s.meta = m
resp, err := s.GcConfirm(context.TODO(), &datapb.GcConfirmRequest{CollectionId: 100, PartitionId: 10000})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
assert.False(t, resp.GetGcFinished())
})
}

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

@ -760,6 +760,19 @@ func (c *Client) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthReque
return ret.(*milvuspb.CheckHealthResponse), err
}
func (c *Client) GcConfirm(ctx context.Context, req *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client datapb.DataCoordClient) (any, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.GcConfirm(ctx, req)
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*datapb.GcConfirmResponse), err
}
// CreateIndex sends the build index request to IndexCoord.
func (c *Client) CreateIndex(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client datapb.DataCoordClient) (any, error) {

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

@ -386,6 +386,10 @@ func (s *Server) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthReque
return s.dataCoord.CheckHealth(ctx, req)
}
func (s *Server) GcConfirm(ctx context.Context, request *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
return s.dataCoord.GcConfirm(ctx, request)
}
// CreateIndex sends the build index request to DataCoord.
func (s *Server) CreateIndex(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
return s.dataCoord.CreateIndex(ctx, req)

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

@ -21,12 +21,12 @@ import (
"errors"
"testing"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus-proto/go-api/commonpb"
"github.com/milvus-io/milvus-proto/go-api/milvuspb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/internal/util/paramtable"
"github.com/stretchr/testify/assert"
clientv3 "go.etcd.io/etcd/client/v3"
@ -34,6 +34,8 @@ import (
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
type MockDataCoord struct {
types.DataCoord
states *milvuspb.ComponentStates
status *commonpb.Status
err error

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

@ -554,6 +554,10 @@ func (m *MockDataCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHeal
return nil, nil
}
func (m *MockDataCoord) GcConfirm(ctx context.Context, req *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
return nil, nil
}
func (m *MockDataCoord) CreateIndex(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
return nil, nil
}

80
internal/kv/mocks/MetaKv.go
View File

@ -82,10 +82,10 @@ type MetaKv_CompareValueAndSwap_Call struct {
}
// CompareValueAndSwap is a helper method to define mock.On call
// - key string
// - value string
// - target string
// - opts ...clientv3.OpOption
// - key string
// - value string
// - target string
// - opts ...clientv3.OpOption
func (_e *MetaKv_Expecter) CompareValueAndSwap(key interface{}, value interface{}, target interface{}, opts ...interface{}) *MetaKv_CompareValueAndSwap_Call {
return &MetaKv_CompareValueAndSwap_Call{Call: _e.mock.On("CompareValueAndSwap",
append([]interface{}{key, value, target}, opts...)...)}
@ -143,10 +143,10 @@ type MetaKv_CompareVersionAndSwap_Call struct {
}
// CompareVersionAndSwap is a helper method to define mock.On call
// - key string
// - version int64
// - target string
// - opts ...clientv3.OpOption
// - key string
// - version int64
// - target string
// - opts ...clientv3.OpOption
func (_e *MetaKv_Expecter) CompareVersionAndSwap(key interface{}, version interface{}, target interface{}, opts ...interface{}) *MetaKv_CompareVersionAndSwap_Call {
return &MetaKv_CompareVersionAndSwap_Call{Call: _e.mock.On("CompareVersionAndSwap",
append([]interface{}{key, version, target}, opts...)...)}
@ -190,7 +190,7 @@ type MetaKv_GetPath_Call struct {
}
// GetPath is a helper method to define mock.On call
// - key string
// - key string
func (_e *MetaKv_Expecter) GetPath(key interface{}) *MetaKv_GetPath_Call {
return &MetaKv_GetPath_Call{Call: _e.mock.On("GetPath", key)}
}
@ -234,7 +234,7 @@ type MetaKv_Grant_Call struct {
}
// Grant is a helper method to define mock.On call
// - ttl int64
// - ttl int64
func (_e *MetaKv_Expecter) Grant(ttl interface{}) *MetaKv_Grant_Call {
return &MetaKv_Grant_Call{Call: _e.mock.On("Grant", ttl)}
}
@ -280,7 +280,7 @@ type MetaKv_KeepAlive_Call struct {
}
// KeepAlive is a helper method to define mock.On call
// - id clientv3.LeaseID
// - id clientv3.LeaseID
func (_e *MetaKv_Expecter) KeepAlive(id interface{}) *MetaKv_KeepAlive_Call {
return &MetaKv_KeepAlive_Call{Call: _e.mock.On("KeepAlive", id)}
}
@ -324,7 +324,7 @@ type MetaKv_Load_Call struct {
}
// Load is a helper method to define mock.On call
// - key string
// - key string
func (_e *MetaKv_Expecter) Load(key interface{}) *MetaKv_Load_Call {
return &MetaKv_Load_Call{Call: _e.mock.On("Load", key)}
}
@ -379,7 +379,7 @@ type MetaKv_LoadWithPrefix_Call struct {
}
// LoadWithPrefix is a helper method to define mock.On call
// - key string
// - key string
func (_e *MetaKv_Expecter) LoadWithPrefix(key interface{}) *MetaKv_LoadWithPrefix_Call {
return &MetaKv_LoadWithPrefix_Call{Call: _e.mock.On("LoadWithPrefix", key)}
}
@ -443,7 +443,7 @@ type MetaKv_LoadWithPrefix2_Call struct {
}
// LoadWithPrefix2 is a helper method to define mock.On call
// - key string
// - key string
func (_e *MetaKv_Expecter) LoadWithPrefix2(key interface{}) *MetaKv_LoadWithPrefix2_Call {
return &MetaKv_LoadWithPrefix2_Call{Call: _e.mock.On("LoadWithPrefix2", key)}
}
@ -505,7 +505,7 @@ type MetaKv_LoadWithRevision_Call struct {
}
// LoadWithRevision is a helper method to define mock.On call
// - key string
// - key string
func (_e *MetaKv_Expecter) LoadWithRevision(key interface{}) *MetaKv_LoadWithRevision_Call {
return &MetaKv_LoadWithRevision_Call{Call: _e.mock.On("LoadWithRevision", key)}
}
@ -576,7 +576,7 @@ type MetaKv_LoadWithRevisionAndVersions_Call struct {
}
// LoadWithRevisionAndVersions is a helper method to define mock.On call
// - key string
// - key string
func (_e *MetaKv_Expecter) LoadWithRevisionAndVersions(key interface{}) *MetaKv_LoadWithRevisionAndVersions_Call {
return &MetaKv_LoadWithRevisionAndVersions_Call{Call: _e.mock.On("LoadWithRevisionAndVersions", key)}
}
@ -622,7 +622,7 @@ type MetaKv_MultiLoad_Call struct {
}
// MultiLoad is a helper method to define mock.On call
// - keys []string
// - keys []string
func (_e *MetaKv_Expecter) MultiLoad(keys interface{}) *MetaKv_MultiLoad_Call {
return &MetaKv_MultiLoad_Call{Call: _e.mock.On("MultiLoad", keys)}
}
@ -659,7 +659,7 @@ type MetaKv_MultiRemove_Call struct {
}
// MultiRemove is a helper method to define mock.On call
// - keys []string
// - keys []string
func (_e *MetaKv_Expecter) MultiRemove(keys interface{}) *MetaKv_MultiRemove_Call {
return &MetaKv_MultiRemove_Call{Call: _e.mock.On("MultiRemove", keys)}
}
@ -696,7 +696,7 @@ type MetaKv_MultiRemoveWithPrefix_Call struct {
}
// MultiRemoveWithPrefix is a helper method to define mock.On call
// - keys []string
// - keys []string
func (_e *MetaKv_Expecter) MultiRemoveWithPrefix(keys interface{}) *MetaKv_MultiRemoveWithPrefix_Call {
return &MetaKv_MultiRemoveWithPrefix_Call{Call: _e.mock.On("MultiRemoveWithPrefix", keys)}
}
@ -733,7 +733,7 @@ type MetaKv_MultiSave_Call struct {
}
// MultiSave is a helper method to define mock.On call
// - kvs map[string]string
// - kvs map[string]string
func (_e *MetaKv_Expecter) MultiSave(kvs interface{}) *MetaKv_MultiSave_Call {
return &MetaKv_MultiSave_Call{Call: _e.mock.On("MultiSave", kvs)}
}
@ -770,8 +770,8 @@ type MetaKv_MultiSaveAndRemove_Call struct {
}
// MultiSaveAndRemove is a helper method to define mock.On call
// - saves map[string]string
// - removals []string
// - saves map[string]string
// - removals []string
func (_e *MetaKv_Expecter) MultiSaveAndRemove(saves interface{}, removals interface{}) *MetaKv_MultiSaveAndRemove_Call {
return &MetaKv_MultiSaveAndRemove_Call{Call: _e.mock.On("MultiSaveAndRemove", saves, removals)}
}
@ -808,8 +808,8 @@ type MetaKv_MultiSaveAndRemoveWithPrefix_Call struct {
}
// MultiSaveAndRemoveWithPrefix is a helper method to define mock.On call
// - saves map[string]string
// - removals []string
// - saves map[string]string
// - removals []string
func (_e *MetaKv_Expecter) MultiSaveAndRemoveWithPrefix(saves interface{}, removals interface{}) *MetaKv_MultiSaveAndRemoveWithPrefix_Call {
return &MetaKv_MultiSaveAndRemoveWithPrefix_Call{Call: _e.mock.On("MultiSaveAndRemoveWithPrefix", saves, removals)}
}
@ -846,7 +846,7 @@ type MetaKv_Remove_Call struct {
}
// Remove is a helper method to define mock.On call
// - key string
// - key string
func (_e *MetaKv_Expecter) Remove(key interface{}) *MetaKv_Remove_Call {
return &MetaKv_Remove_Call{Call: _e.mock.On("Remove", key)}
}
@ -883,7 +883,7 @@ type MetaKv_RemoveWithPrefix_Call struct {
}
// RemoveWithPrefix is a helper method to define mock.On call
// - key string
// - key string
func (_e *MetaKv_Expecter) RemoveWithPrefix(key interface{}) *MetaKv_RemoveWithPrefix_Call {
return &MetaKv_RemoveWithPrefix_Call{Call: _e.mock.On("RemoveWithPrefix", key)}
}
@ -920,8 +920,8 @@ type MetaKv_Save_Call struct {
}
// Save is a helper method to define mock.On call
// - key string
// - value string
// - key string
// - value string
func (_e *MetaKv_Expecter) Save(key interface{}, value interface{}) *MetaKv_Save_Call {
return &MetaKv_Save_Call{Call: _e.mock.On("Save", key, value)}
}
@ -958,8 +958,8 @@ type MetaKv_SaveWithIgnoreLease_Call struct {
}
// SaveWithIgnoreLease is a helper method to define mock.On call
// - key string
// - value string
// - key string
// - value string
func (_e *MetaKv_Expecter) SaveWithIgnoreLease(key interface{}, value interface{}) *MetaKv_SaveWithIgnoreLease_Call {
return &MetaKv_SaveWithIgnoreLease_Call{Call: _e.mock.On("SaveWithIgnoreLease", key, value)}
}
@ -996,9 +996,9 @@ type MetaKv_SaveWithLease_Call struct {
}
// SaveWithLease is a helper method to define mock.On call
// - key string
// - value string
// - id clientv3.LeaseID
// - key string
// - value string
// - id clientv3.LeaseID
func (_e *MetaKv_Expecter) SaveWithLease(key interface{}, value interface{}, id interface{}) *MetaKv_SaveWithLease_Call {
return &MetaKv_SaveWithLease_Call{Call: _e.mock.On("SaveWithLease", key, value, id)}
}
@ -1035,9 +1035,9 @@ type MetaKv_WalkWithPrefix_Call struct {
}
// WalkWithPrefix is a helper method to define mock.On call
// - prefix string
// - paginationSize int
// - fn func([]byte , []byte) error
// - prefix string
// - paginationSize int
// - fn func([]byte , []byte) error
func (_e *MetaKv_Expecter) WalkWithPrefix(prefix interface{}, paginationSize interface{}, fn interface{}) *MetaKv_WalkWithPrefix_Call {
return &MetaKv_WalkWithPrefix_Call{Call: _e.mock.On("WalkWithPrefix", prefix, paginationSize, fn)}
}
@ -1076,7 +1076,7 @@ type MetaKv_Watch_Call struct {
}
// Watch is a helper method to define mock.On call
// - key string
// - key string
func (_e *MetaKv_Expecter) Watch(key interface{}) *MetaKv_Watch_Call {
return &MetaKv_Watch_Call{Call: _e.mock.On("Watch", key)}
}
@ -1115,7 +1115,7 @@ type MetaKv_WatchWithPrefix_Call struct {
}
// WatchWithPrefix is a helper method to define mock.On call
// - key string
// - key string
func (_e *MetaKv_Expecter) WatchWithPrefix(key interface{}) *MetaKv_WatchWithPrefix_Call {
return &MetaKv_WatchWithPrefix_Call{Call: _e.mock.On("WatchWithPrefix", key)}
}
@ -1154,8 +1154,8 @@ type MetaKv_WatchWithRevision_Call struct {
}
// WatchWithRevision is a helper method to define mock.On call
// - key string
// - revision int64
// - key string
// - revision int64
func (_e *MetaKv_Expecter) WatchWithRevision(key interface{}, revision interface{}) *MetaKv_WatchWithRevision_Call {
return &MetaKv_WatchWithRevision_Call{Call: _e.mock.On("WatchWithRevision", key, revision)}
}

24
internal/kv/mocks/SnapShotKV.go
View File

@ -44,8 +44,8 @@ type SnapShotKV_Load_Call struct {
}
// Load is a helper method to define mock.On call
// - key string
// - ts uint64
// - key string
// - ts uint64
func (_e *SnapShotKV_Expecter) Load(key interface{}, ts interface{}) *SnapShotKV_Load_Call {
return &SnapShotKV_Load_Call{Call: _e.mock.On("Load", key, ts)}
}
@ -100,8 +100,8 @@ type SnapShotKV_LoadWithPrefix_Call struct {
}
// LoadWithPrefix is a helper method to define mock.On call
// - key string
// - ts uint64
// - key string
// - ts uint64
func (_e *SnapShotKV_Expecter) LoadWithPrefix(key interface{}, ts interface{}) *SnapShotKV_LoadWithPrefix_Call {
return &SnapShotKV_LoadWithPrefix_Call{Call: _e.mock.On("LoadWithPrefix", key, ts)}
}
@ -138,8 +138,8 @@ type SnapShotKV_MultiSave_Call struct {
}
// MultiSave is a helper method to define mock.On call
// - kvs map[string]string
// - ts uint64
// - kvs map[string]string
// - ts uint64
func (_e *SnapShotKV_Expecter) MultiSave(kvs interface{}, ts interface{}) *SnapShotKV_MultiSave_Call {
return &SnapShotKV_MultiSave_Call{Call: _e.mock.On("MultiSave", kvs, ts)}
}
@ -176,9 +176,9 @@ type SnapShotKV_MultiSaveAndRemoveWithPrefix_Call struct {
}
// MultiSaveAndRemoveWithPrefix is a helper method to define mock.On call
// - saves map[string]string
// - removals []string
// - ts uint64
// - saves map[string]string
// - removals []string
// - ts uint64
func (_e *SnapShotKV_Expecter) MultiSaveAndRemoveWithPrefix(saves interface{}, removals interface{}, ts interface{}) *SnapShotKV_MultiSaveAndRemoveWithPrefix_Call {
return &SnapShotKV_MultiSaveAndRemoveWithPrefix_Call{Call: _e.mock.On("MultiSaveAndRemoveWithPrefix", saves, removals, ts)}
}
@ -215,9 +215,9 @@ type SnapShotKV_Save_Call struct {
}
// Save is a helper method to define mock.On call
// - key string
// - value string
// - ts uint64
// - key string
// - value string
// - ts uint64
func (_e *SnapShotKV_Expecter) Save(key interface{}, value interface{}, ts interface{}) *SnapShotKV_Save_Call {
return &SnapShotKV_Save_Call{Call: _e.mock.On("Save", key, value, ts)}
}

28
internal/kv/mocks/TxnKV.go
View File

@ -71,7 +71,7 @@ type TxnKV_Load_Call struct {
}
// Load is a helper method to define mock.On call
// - key string
// - key string
func (_e *TxnKV_Expecter) Load(key interface{}) *TxnKV_Load_Call {
return &TxnKV_Load_Call{Call: _e.mock.On("Load", key)}
}
@ -126,7 +126,7 @@ type TxnKV_LoadWithPrefix_Call struct {
}
// LoadWithPrefix is a helper method to define mock.On call
// - key string
// - key string
func (_e *TxnKV_Expecter) LoadWithPrefix(key interface{}) *TxnKV_LoadWithPrefix_Call {
return &TxnKV_LoadWithPrefix_Call{Call: _e.mock.On("LoadWithPrefix", key)}
}
@ -172,7 +172,7 @@ type TxnKV_MultiLoad_Call struct {
}
// MultiLoad is a helper method to define mock.On call
// - keys []string
// - keys []string
func (_e *TxnKV_Expecter) MultiLoad(keys interface{}) *TxnKV_MultiLoad_Call {
return &TxnKV_MultiLoad_Call{Call: _e.mock.On("MultiLoad", keys)}
}
@ -209,7 +209,7 @@ type TxnKV_MultiRemove_Call struct {
}
// MultiRemove is a helper method to define mock.On call
// - keys []string
// - keys []string
func (_e *TxnKV_Expecter) MultiRemove(keys interface{}) *TxnKV_MultiRemove_Call {
return &TxnKV_MultiRemove_Call{Call: _e.mock.On("MultiRemove", keys)}
}
@ -246,7 +246,7 @@ type TxnKV_MultiRemoveWithPrefix_Call struct {
}
// MultiRemoveWithPrefix is a helper method to define mock.On call
// - keys []string
// - keys []string
func (_e *TxnKV_Expecter) MultiRemoveWithPrefix(keys interface{}) *TxnKV_MultiRemoveWithPrefix_Call {
return &TxnKV_MultiRemoveWithPrefix_Call{Call: _e.mock.On("MultiRemoveWithPrefix", keys)}
}
@ -283,7 +283,7 @@ type TxnKV_MultiSave_Call struct {
}
// MultiSave is a helper method to define mock.On call
// - kvs map[string]string
// - kvs map[string]string
func (_e *TxnKV_Expecter) MultiSave(kvs interface{}) *TxnKV_MultiSave_Call {
return &TxnKV_MultiSave_Call{Call: _e.mock.On("MultiSave", kvs)}
}
@ -320,8 +320,8 @@ type TxnKV_MultiSaveAndRemove_Call struct {
}
// MultiSaveAndRemove is a helper method to define mock.On call
// - saves map[string]string
// - removals []string
// - saves map[string]string
// - removals []string
func (_e *TxnKV_Expecter) MultiSaveAndRemove(saves interface{}, removals interface{}) *TxnKV_MultiSaveAndRemove_Call {
return &TxnKV_MultiSaveAndRemove_Call{Call: _e.mock.On("MultiSaveAndRemove", saves, removals)}
}
@ -358,8 +358,8 @@ type TxnKV_MultiSaveAndRemoveWithPrefix_Call struct {
}
// MultiSaveAndRemoveWithPrefix is a helper method to define mock.On call
// - saves map[string]string
// - removals []string
// - saves map[string]string
// - removals []string
func (_e *TxnKV_Expecter) MultiSaveAndRemoveWithPrefix(saves interface{}, removals interface{}) *TxnKV_MultiSaveAndRemoveWithPrefix_Call {
return &TxnKV_MultiSaveAndRemoveWithPrefix_Call{Call: _e.mock.On("MultiSaveAndRemoveWithPrefix", saves, removals)}
}
@ -396,7 +396,7 @@ type TxnKV_Remove_Call struct {
}
// Remove is a helper method to define mock.On call
// - key string
// - key string
func (_e *TxnKV_Expecter) Remove(key interface{}) *TxnKV_Remove_Call {
return &TxnKV_Remove_Call{Call: _e.mock.On("Remove", key)}
}
@ -433,7 +433,7 @@ type TxnKV_RemoveWithPrefix_Call struct {
}
// RemoveWithPrefix is a helper method to define mock.On call
// - key string
// - key string
func (_e *TxnKV_Expecter) RemoveWithPrefix(key interface{}) *TxnKV_RemoveWithPrefix_Call {
return &TxnKV_RemoveWithPrefix_Call{Call: _e.mock.On("RemoveWithPrefix", key)}
}
@ -470,8 +470,8 @@ type TxnKV_Save_Call struct {
}
// Save is a helper method to define mock.On call
// - key string
// - value string
// - key string
// - value string
func (_e *TxnKV_Expecter) Save(key interface{}, value interface{}) *TxnKV_Save_Call {
return &TxnKV_Save_Call{Call: _e.mock.On("Save", key, value)}
}

2
internal/metastore/catalog.go
View File

@ -130,6 +130,8 @@ type DataCoordCatalog interface {
AlterSegmentIndex(ctx context.Context, newSegIndex *model.SegmentIndex) error
AlterSegmentIndexes(ctx context.Context, newSegIdxes []*model.SegmentIndex) error
DropSegmentIndex(ctx context.Context, collID, partID, segID, buildID typeutil.UniqueID) error
GcConfirm(ctx context.Context, collectionID, partitionID typeutil.UniqueID) bool
}
type IndexCoordCatalog interface {

25
internal/metastore/kv/datacoord/kv_catalog.go
View File

@ -685,6 +685,23 @@ func (kc *Catalog) DropSegmentIndex(ctx context.Context, collID, partID, segID,
return nil
}
const allPartitionID = -1
// GcConfirm returns true if related collection/partition is not found.
// DataCoord will remove all the meta eventually after GC is finished.
func (kc *Catalog) GcConfirm(ctx context.Context, collectionID, partitionID typeutil.UniqueID) bool {
prefix := buildCollectionPrefix(collectionID)
if partitionID != allPartitionID {
prefix = buildPartitionPrefix(collectionID, partitionID)
}
keys, values, err := kc.MetaKv.LoadWithPrefix(prefix)
if err != nil {
// error case can be regarded as not finished.
return false
}
return len(keys) == 0 && len(values) == 0
}
func fillLogPathByLogID(chunkManagerRootPath string, binlogType storage.BinlogType, collectionID, partitionID,
segmentID typeutil.UniqueID, fieldBinlog *datapb.FieldBinlog) error {
for _, binlog := range fieldBinlog.Binlogs {
@ -956,3 +973,11 @@ func BuildIndexKey(collectionID, indexID int64) string {
func BuildSegmentIndexKey(collectionID, partitionID, segmentID, buildID int64) string {
return fmt.Sprintf("%s/%d/%d/%d/%d", util.SegmentIndexPrefix, collectionID, partitionID, segmentID, buildID)
}
func buildCollectionPrefix(collectionID typeutil.UniqueID) string {
return fmt.Sprintf("%s/%d", SegmentPrefix, collectionID)
}
func buildPartitionPrefix(collectionID, partitionID typeutil.UniqueID) string {
return fmt.Sprintf("%s/%d/%d", SegmentPrefix, collectionID, partitionID)
}

17
internal/metastore/kv/datacoord/kv_catalog_test.go
View File

@ -1346,3 +1346,20 @@ func TestMain(m *testing.M) {
code := m.Run()
os.Exit(code)
}
func TestCatalog_GcConfirm(t *testing.T) {
kc := &Catalog{}
txn := mocks.NewMetaKv(t)
kc.MetaKv = txn
txn.On("LoadWithPrefix",
mock.AnythingOfType("string")).
Return(nil, nil, errors.New("error mock LoadWithPrefix")).
Once()
assert.False(t, kc.GcConfirm(context.TODO(), 100, 10000))
txn.On("LoadWithPrefix",
mock.AnythingOfType("string")).
Return(nil, nil, nil)
assert.True(t, kc.GcConfirm(context.TODO(), 100, 10000))
}

143
internal/metastore/mocks/DataCoordCatalog.go
View File

@ -46,8 +46,8 @@ type DataCoordCatalog_AddSegment_Call struct {
}
// AddSegment is a helper method to define mock.On call
// - ctx context.Context
// - segment *datapb.SegmentInfo
// - ctx context.Context
// - segment *datapb.SegmentInfo
func (_e *DataCoordCatalog_Expecter) AddSegment(ctx interface{}, segment interface{}) *DataCoordCatalog_AddSegment_Call {
return &DataCoordCatalog_AddSegment_Call{Call: _e.mock.On("AddSegment", ctx, segment)}
}
@ -84,8 +84,8 @@ type DataCoordCatalog_AlterIndex_Call struct {
}
// AlterIndex is a helper method to define mock.On call
// - ctx context.Context
// - newIndex *model.Index
// - ctx context.Context
// - newIndex *model.Index
func (_e *DataCoordCatalog_Expecter) AlterIndex(ctx interface{}, newIndex interface{}) *DataCoordCatalog_AlterIndex_Call {
return &DataCoordCatalog_AlterIndex_Call{Call: _e.mock.On("AlterIndex", ctx, newIndex)}
}
@ -122,8 +122,8 @@ type DataCoordCatalog_AlterIndexes_Call struct {
}
// AlterIndexes is a helper method to define mock.On call
// - ctx context.Context
// - newIndexes []*model.Index
// - ctx context.Context
// - newIndexes []*model.Index
func (_e *DataCoordCatalog_Expecter) AlterIndexes(ctx interface{}, newIndexes interface{}) *DataCoordCatalog_AlterIndexes_Call {
return &DataCoordCatalog_AlterIndexes_Call{Call: _e.mock.On("AlterIndexes", ctx, newIndexes)}
}
@ -160,9 +160,9 @@ type DataCoordCatalog_AlterSegment_Call struct {
}
// AlterSegment is a helper method to define mock.On call
// - ctx context.Context
// - newSegment *datapb.SegmentInfo
// - oldSegment *datapb.SegmentInfo
// - ctx context.Context
// - newSegment *datapb.SegmentInfo
// - oldSegment *datapb.SegmentInfo
func (_e *DataCoordCatalog_Expecter) AlterSegment(ctx interface{}, newSegment interface{}, oldSegment interface{}) *DataCoordCatalog_AlterSegment_Call {
return &DataCoordCatalog_AlterSegment_Call{Call: _e.mock.On("AlterSegment", ctx, newSegment, oldSegment)}
}
@ -199,8 +199,8 @@ type DataCoordCatalog_AlterSegmentIndex_Call struct {
}
// AlterSegmentIndex is a helper method to define mock.On call
// - ctx context.Context
// - newSegIndex *model.SegmentIndex
// - ctx context.Context
// - newSegIndex *model.SegmentIndex
func (_e *DataCoordCatalog_Expecter) AlterSegmentIndex(ctx interface{}, newSegIndex interface{}) *DataCoordCatalog_AlterSegmentIndex_Call {
return &DataCoordCatalog_AlterSegmentIndex_Call{Call: _e.mock.On("AlterSegmentIndex", ctx, newSegIndex)}
}
@ -237,8 +237,8 @@ type DataCoordCatalog_AlterSegmentIndexes_Call struct {
}
// AlterSegmentIndexes is a helper method to define mock.On call
// - ctx context.Context
// - newSegIdxes []*model.SegmentIndex
// - ctx context.Context
// - newSegIdxes []*model.SegmentIndex
func (_e *DataCoordCatalog_Expecter) AlterSegmentIndexes(ctx interface{}, newSegIdxes interface{}) *DataCoordCatalog_AlterSegmentIndexes_Call {
return &DataCoordCatalog_AlterSegmentIndexes_Call{Call: _e.mock.On("AlterSegmentIndexes", ctx, newSegIdxes)}
}
@ -275,8 +275,8 @@ type DataCoordCatalog_AlterSegments_Call struct {
}
// AlterSegments is a helper method to define mock.On call
// - ctx context.Context
// - newSegments []*datapb.SegmentInfo
// - ctx context.Context
// - newSegments []*datapb.SegmentInfo
func (_e *DataCoordCatalog_Expecter) AlterSegments(ctx interface{}, newSegments interface{}) *DataCoordCatalog_AlterSegments_Call {
return &DataCoordCatalog_AlterSegments_Call{Call: _e.mock.On("AlterSegments", ctx, newSegments)}
}
@ -313,9 +313,9 @@ type DataCoordCatalog_AlterSegmentsAndAddNewSegment_Call struct {
}
// AlterSegmentsAndAddNewSegment is a helper method to define mock.On call
// - ctx context.Context
// - segments []*datapb.SegmentInfo
// - newSegment *datapb.SegmentInfo
// - ctx context.Context
// - segments []*datapb.SegmentInfo
// - newSegment *datapb.SegmentInfo
func (_e *DataCoordCatalog_Expecter) AlterSegmentsAndAddNewSegment(ctx interface{}, segments interface{}, newSegment interface{}) *DataCoordCatalog_AlterSegmentsAndAddNewSegment_Call {
return &DataCoordCatalog_AlterSegmentsAndAddNewSegment_Call{Call: _e.mock.On("AlterSegmentsAndAddNewSegment", ctx, segments, newSegment)}
}
@ -352,8 +352,8 @@ type DataCoordCatalog_CreateIndex_Call struct {
}
// CreateIndex is a helper method to define mock.On call
// - ctx context.Context
// - index *model.Index
// - ctx context.Context
// - index *model.Index
func (_e *DataCoordCatalog_Expecter) CreateIndex(ctx interface{}, index interface{}) *DataCoordCatalog_CreateIndex_Call {
return &DataCoordCatalog_CreateIndex_Call{Call: _e.mock.On("CreateIndex", ctx, index)}
}
@ -390,8 +390,8 @@ type DataCoordCatalog_CreateSegmentIndex_Call struct {
}
// CreateSegmentIndex is a helper method to define mock.On call
// - ctx context.Context
// - segIdx *model.SegmentIndex
// - ctx context.Context
// - segIdx *model.SegmentIndex
func (_e *DataCoordCatalog_Expecter) CreateSegmentIndex(ctx interface{}, segIdx interface{}) *DataCoordCatalog_CreateSegmentIndex_Call {
return &DataCoordCatalog_CreateSegmentIndex_Call{Call: _e.mock.On("CreateSegmentIndex", ctx, segIdx)}
}
@ -428,8 +428,8 @@ type DataCoordCatalog_DropChannel_Call struct {
}
// DropChannel is a helper method to define mock.On call
// - ctx context.Context
// - channel string
// - ctx context.Context
// - channel string
func (_e *DataCoordCatalog_Expecter) DropChannel(ctx interface{}, channel interface{}) *DataCoordCatalog_DropChannel_Call {
return &DataCoordCatalog_DropChannel_Call{Call: _e.mock.On("DropChannel", ctx, channel)}
}
@ -466,8 +466,8 @@ type DataCoordCatalog_DropChannelCheckpoint_Call struct {
}
// DropChannelCheckpoint is a helper method to define mock.On call
// - ctx context.Context
// - vChannel string
// - ctx context.Context
// - vChannel string
func (_e *DataCoordCatalog_Expecter) DropChannelCheckpoint(ctx interface{}, vChannel interface{}) *DataCoordCatalog_DropChannelCheckpoint_Call {
return &DataCoordCatalog_DropChannelCheckpoint_Call{Call: _e.mock.On("DropChannelCheckpoint", ctx, vChannel)}
}
@ -504,9 +504,9 @@ type DataCoordCatalog_DropIndex_Call struct {
}
// DropIndex is a helper method to define mock.On call
// - ctx context.Context
// - collID int64
// - dropIdxID int64
// - ctx context.Context
// - collID int64
// - dropIdxID int64
func (_e *DataCoordCatalog_Expecter) DropIndex(ctx interface{}, collID interface{}, dropIdxID interface{}) *DataCoordCatalog_DropIndex_Call {
return &DataCoordCatalog_DropIndex_Call{Call: _e.mock.On("DropIndex", ctx, collID, dropIdxID)}
}
@ -543,8 +543,8 @@ type DataCoordCatalog_DropSegment_Call struct {
}
// DropSegment is a helper method to define mock.On call
// - ctx context.Context
// - segment *datapb.SegmentInfo
// - ctx context.Context
// - segment *datapb.SegmentInfo
func (_e *DataCoordCatalog_Expecter) DropSegment(ctx interface{}, segment interface{}) *DataCoordCatalog_DropSegment_Call {
return &DataCoordCatalog_DropSegment_Call{Call: _e.mock.On("DropSegment", ctx, segment)}
}
@ -581,11 +581,11 @@ type DataCoordCatalog_DropSegmentIndex_Call struct {
}
// DropSegmentIndex is a helper method to define mock.On call
// - ctx context.Context
// - collID int64
// - partID int64
// - segID int64
// - buildID int64
// - ctx context.Context
// - collID int64
// - partID int64
// - segID int64
// - buildID int64
func (_e *DataCoordCatalog_Expecter) DropSegmentIndex(ctx interface{}, collID interface{}, partID interface{}, segID interface{}, buildID interface{}) *DataCoordCatalog_DropSegmentIndex_Call {
return &DataCoordCatalog_DropSegmentIndex_Call{Call: _e.mock.On("DropSegmentIndex", ctx, collID, partID, segID, buildID)}
}
@ -602,6 +602,45 @@ func (_c *DataCoordCatalog_DropSegmentIndex_Call) Return(_a0 error) *DataCoordCa
return _c
}
// GcConfirm provides a mock function with given fields: ctx, collectionID, partitionID
func (_m *DataCoordCatalog) GcConfirm(ctx context.Context, collectionID int64, partitionID int64) bool {
ret := _m.Called(ctx, collectionID, partitionID)
var r0 bool
if rf, ok := ret.Get(0).(func(context.Context, int64, int64) bool); ok {
r0 = rf(ctx, collectionID, partitionID)
} else {
r0 = ret.Get(0).(bool)
}
return r0
}
// DataCoordCatalog_GcConfirm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GcConfirm'
type DataCoordCatalog_GcConfirm_Call struct {
*mock.Call
}
// GcConfirm is a helper method to define mock.On call
// - ctx context.Context
// - collectionID int64
// - partitionID int64
func (_e *DataCoordCatalog_Expecter) GcConfirm(ctx interface{}, collectionID interface{}, partitionID interface{}) *DataCoordCatalog_GcConfirm_Call {
return &DataCoordCatalog_GcConfirm_Call{Call: _e.mock.On("GcConfirm", ctx, collectionID, partitionID)}
}
func (_c *DataCoordCatalog_GcConfirm_Call) Run(run func(ctx context.Context, collectionID int64, partitionID int64)) *DataCoordCatalog_GcConfirm_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(int64))
})
return _c
}
func (_c *DataCoordCatalog_GcConfirm_Call) Return(_a0 bool) *DataCoordCatalog_GcConfirm_Call {
_c.Call.Return(_a0)
return _c
}
// IsChannelDropped provides a mock function with given fields: ctx, channel
func (_m *DataCoordCatalog) IsChannelDropped(ctx context.Context, channel string) bool {
ret := _m.Called(ctx, channel)
@ -622,8 +661,8 @@ type DataCoordCatalog_IsChannelDropped_Call struct {
}
// IsChannelDropped is a helper method to define mock.On call
// - ctx context.Context
// - channel string
// - ctx context.Context
// - channel string
func (_e *DataCoordCatalog_Expecter) IsChannelDropped(ctx interface{}, channel interface{}) *DataCoordCatalog_IsChannelDropped_Call {
return &DataCoordCatalog_IsChannelDropped_Call{Call: _e.mock.On("IsChannelDropped", ctx, channel)}
}
@ -669,7 +708,7 @@ type DataCoordCatalog_ListChannelCheckpoint_Call struct {
}
// ListChannelCheckpoint is a helper method to define mock.On call
// - ctx context.Context
// - ctx context.Context
func (_e *DataCoordCatalog_Expecter) ListChannelCheckpoint(ctx interface{}) *DataCoordCatalog_ListChannelCheckpoint_Call {
return &DataCoordCatalog_ListChannelCheckpoint_Call{Call: _e.mock.On("ListChannelCheckpoint", ctx)}
}
@ -715,7 +754,7 @@ type DataCoordCatalog_ListIndexes_Call struct {
}
// ListIndexes is a helper method to define mock.On call
// - ctx context.Context
// - ctx context.Context
func (_e *DataCoordCatalog_Expecter) ListIndexes(ctx interface{}) *DataCoordCatalog_ListIndexes_Call {
return &DataCoordCatalog_ListIndexes_Call{Call: _e.mock.On("ListIndexes", ctx)}
}
@ -761,7 +800,7 @@ type DataCoordCatalog_ListSegmentIndexes_Call struct {
}
// ListSegmentIndexes is a helper method to define mock.On call
// - ctx context.Context
// - ctx context.Context
func (_e *DataCoordCatalog_Expecter) ListSegmentIndexes(ctx interface{}) *DataCoordCatalog_ListSegmentIndexes_Call {
return &DataCoordCatalog_ListSegmentIndexes_Call{Call: _e.mock.On("ListSegmentIndexes", ctx)}
}
@ -807,7 +846,7 @@ type DataCoordCatalog_ListSegments_Call struct {
}
// ListSegments is a helper method to define mock.On call
// - ctx context.Context
// - ctx context.Context
func (_e *DataCoordCatalog_Expecter) ListSegments(ctx interface{}) *DataCoordCatalog_ListSegments_Call {
return &DataCoordCatalog_ListSegments_Call{Call: _e.mock.On("ListSegments", ctx)}
}
@ -844,8 +883,8 @@ type DataCoordCatalog_MarkChannelDeleted_Call struct {
}
// MarkChannelDeleted is a helper method to define mock.On call
// - ctx context.Context
// - channel string
// - ctx context.Context
// - channel string
func (_e *DataCoordCatalog_Expecter) MarkChannelDeleted(ctx interface{}, channel interface{}) *DataCoordCatalog_MarkChannelDeleted_Call {
return &DataCoordCatalog_MarkChannelDeleted_Call{Call: _e.mock.On("MarkChannelDeleted", ctx, channel)}
}
@ -882,9 +921,9 @@ type DataCoordCatalog_RevertAlterSegmentsAndAddNewSegment_Call struct {
}
// RevertAlterSegmentsAndAddNewSegment is a helper method to define mock.On call
// - ctx context.Context
// - segments []*datapb.SegmentInfo
// - removalSegment *datapb.SegmentInfo
// - ctx context.Context
// - segments []*datapb.SegmentInfo
// - removalSegment *datapb.SegmentInfo
func (_e *DataCoordCatalog_Expecter) RevertAlterSegmentsAndAddNewSegment(ctx interface{}, segments interface{}, removalSegment interface{}) *DataCoordCatalog_RevertAlterSegmentsAndAddNewSegment_Call {
return &DataCoordCatalog_RevertAlterSegmentsAndAddNewSegment_Call{Call: _e.mock.On("RevertAlterSegmentsAndAddNewSegment", ctx, segments, removalSegment)}
}
@ -921,9 +960,9 @@ type DataCoordCatalog_SaveChannelCheckpoint_Call struct {
}
// SaveChannelCheckpoint is a helper method to define mock.On call
// - ctx context.Context
// - vChannel string
// - pos *internalpb.MsgPosition
// - ctx context.Context
// - vChannel string
// - pos *internalpb.MsgPosition
func (_e *DataCoordCatalog_Expecter) SaveChannelCheckpoint(ctx interface{}, vChannel interface{}, pos interface{}) *DataCoordCatalog_SaveChannelCheckpoint_Call {
return &DataCoordCatalog_SaveChannelCheckpoint_Call{Call: _e.mock.On("SaveChannelCheckpoint", ctx, vChannel, pos)}
}
@ -960,8 +999,8 @@ type DataCoordCatalog_SaveDroppedSegmentsInBatch_Call struct {
}
// SaveDroppedSegmentsInBatch is a helper method to define mock.On call
// - ctx context.Context
// - segments []*datapb.SegmentInfo
// - ctx context.Context
// - segments []*datapb.SegmentInfo
func (_e *DataCoordCatalog_Expecter) SaveDroppedSegmentsInBatch(ctx interface{}, segments interface{}) *DataCoordCatalog_SaveDroppedSegmentsInBatch_Call {
return &DataCoordCatalog_SaveDroppedSegmentsInBatch_Call{Call: _e.mock.On("SaveDroppedSegmentsInBatch", ctx, segments)}
}

2
internal/metastore/mocks/RootCoordCatalog.go
View File

@ -1,4 +1,4 @@
// Code generated by mockery v2.14.0. DO NOT EDIT.
// Code generated by mockery v2.16.0. DO NOT EDIT.
package mocks

439
internal/mocks/mock_datacoord.go
View File

@ -1,4 +1,4 @@
// Code generated by mockery v2.14.0. DO NOT EDIT.
// Code generated by mockery v2.16.0. DO NOT EDIT.
package mocks
@ -9,6 +9,8 @@ import (
datapb "github.com/milvus-io/milvus/internal/proto/datapb"
indexpb "github.com/milvus-io/milvus/internal/proto/indexpb"
internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"
milvuspb "github.com/milvus-io/milvus-proto/go-api/milvuspb"
@ -77,11 +79,11 @@ func (_c *DataCoord_AssignSegmentID_Call) Return(_a0 *datapb.AssignSegmentIDResp
}
// BroadcastAlteredCollection provides a mock function with given fields: ctx, req
func (_m *DataCoord) BroadcastAlteredCollection(ctx context.Context, req *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) {
func (_m *DataCoord) BroadcastAlteredCollection(ctx context.Context, req *datapb.AlterCollectionRequest) (*commonpb.Status, error) {
ret := _m.Called(ctx, req)
var r0 *commonpb.Status
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionRequest) *commonpb.Status); ok {
if rf, ok := ret.Get(0).(func(context.Context, *datapb.AlterCollectionRequest) *commonpb.Status); ok {
r0 = rf(ctx, req)
} else {
if ret.Get(0) != nil {
@ -90,7 +92,7 @@ func (_m *DataCoord) BroadcastAlteredCollection(ctx context.Context, req *milvus
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionRequest) error); ok {
if rf, ok := ret.Get(1).(func(context.Context, *datapb.AlterCollectionRequest) error); ok {
r1 = rf(ctx, req)
} else {
r1 = ret.Error(1)
@ -106,14 +108,14 @@ type DataCoord_BroadcastAlteredCollection_Call struct {
// BroadcastAlteredCollection is a helper method to define mock.On call
// - ctx context.Context
// - req *milvuspb.AlterCollectionRequest
// - req *datapb.AlterCollectionRequest
func (_e *DataCoord_Expecter) BroadcastAlteredCollection(ctx interface{}, req interface{}) *DataCoord_BroadcastAlteredCollection_Call {
return &DataCoord_BroadcastAlteredCollection_Call{Call: _e.mock.On("BroadcastAlteredCollection", ctx, req)}
}
func (_c *DataCoord_BroadcastAlteredCollection_Call) Run(run func(ctx context.Context, req *milvuspb.AlterCollectionRequest)) *DataCoord_BroadcastAlteredCollection_Call {
func (_c *DataCoord_BroadcastAlteredCollection_Call) Run(run func(ctx context.Context, req *datapb.AlterCollectionRequest)) *DataCoord_BroadcastAlteredCollection_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionRequest))
run(args[0].(context.Context), args[1].(*datapb.AlterCollectionRequest))
})
return _c
}
@ -170,6 +172,147 @@ func (_c *DataCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse,
return _c
}
// CreateIndex provides a mock function with given fields: ctx, req
func (_m *DataCoord) CreateIndex(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
ret := _m.Called(ctx, req)
var r0 *commonpb.Status
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.CreateIndexRequest) *commonpb.Status); ok {
r0 = rf(ctx, req)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*commonpb.Status)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.CreateIndexRequest) error); ok {
r1 = rf(ctx, req)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// DataCoord_CreateIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIndex'
type DataCoord_CreateIndex_Call struct {
*mock.Call
}
// CreateIndex is a helper method to define mock.On call
// - ctx context.Context
// - req *indexpb.CreateIndexRequest
func (_e *DataCoord_Expecter) CreateIndex(ctx interface{}, req interface{}) *DataCoord_CreateIndex_Call {
return &DataCoord_CreateIndex_Call{Call: _e.mock.On("CreateIndex", ctx, req)}
}
func (_c *DataCoord_CreateIndex_Call) Run(run func(ctx context.Context, req *indexpb.CreateIndexRequest)) *DataCoord_CreateIndex_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*indexpb.CreateIndexRequest))
})
return _c
}
func (_c *DataCoord_CreateIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_CreateIndex_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// DescribeIndex provides a mock function with given fields: ctx, req
func (_m *DataCoord) DescribeIndex(ctx context.Context, req *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
ret := _m.Called(ctx, req)
var r0 *indexpb.DescribeIndexResponse
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DescribeIndexRequest) *indexpb.DescribeIndexResponse); ok {
r0 = rf(ctx, req)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*indexpb.DescribeIndexResponse)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.DescribeIndexRequest) error); ok {
r1 = rf(ctx, req)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// DataCoord_DescribeIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIndex'
type DataCoord_DescribeIndex_Call struct {
*mock.Call
}
// DescribeIndex is a helper method to define mock.On call
// - ctx context.Context
// - req *indexpb.DescribeIndexRequest
func (_e *DataCoord_Expecter) DescribeIndex(ctx interface{}, req interface{}) *DataCoord_DescribeIndex_Call {
return &DataCoord_DescribeIndex_Call{Call: _e.mock.On("DescribeIndex", ctx, req)}
}
func (_c *DataCoord_DescribeIndex_Call) Run(run func(ctx context.Context, req *indexpb.DescribeIndexRequest)) *DataCoord_DescribeIndex_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*indexpb.DescribeIndexRequest))
})
return _c
}
func (_c *DataCoord_DescribeIndex_Call) Return(_a0 *indexpb.DescribeIndexResponse, _a1 error) *DataCoord_DescribeIndex_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// DropIndex provides a mock function with given fields: ctx, req
func (_m *DataCoord) DropIndex(ctx context.Context, req *indexpb.DropIndexRequest) (*commonpb.Status, error) {
ret := _m.Called(ctx, req)
var r0 *commonpb.Status
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DropIndexRequest) *commonpb.Status); ok {
r0 = rf(ctx, req)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*commonpb.Status)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.DropIndexRequest) error); ok {
r1 = rf(ctx, req)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// DataCoord_DropIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropIndex'
type DataCoord_DropIndex_Call struct {
*mock.Call
}
// DropIndex is a helper method to define mock.On call
// - ctx context.Context
// - req *indexpb.DropIndexRequest
func (_e *DataCoord_Expecter) DropIndex(ctx interface{}, req interface{}) *DataCoord_DropIndex_Call {
return &DataCoord_DropIndex_Call{Call: _e.mock.On("DropIndex", ctx, req)}
}
func (_c *DataCoord_DropIndex_Call) Run(run func(ctx context.Context, req *indexpb.DropIndexRequest)) *DataCoord_DropIndex_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*indexpb.DropIndexRequest))
})
return _c
}
func (_c *DataCoord_DropIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_DropIndex_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// DropVirtualChannel provides a mock function with given fields: ctx, req
func (_m *DataCoord) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
ret := _m.Called(ctx, req)
@ -264,6 +407,53 @@ func (_c *DataCoord_Flush_Call) Return(_a0 *datapb.FlushResponse, _a1 error) *Da
return _c
}
// GcConfirm provides a mock function with given fields: ctx, request
func (_m *DataCoord) GcConfirm(ctx context.Context, request *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
ret := _m.Called(ctx, request)
var r0 *datapb.GcConfirmResponse
if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcConfirmRequest) *datapb.GcConfirmResponse); ok {
r0 = rf(ctx, request)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*datapb.GcConfirmResponse)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *datapb.GcConfirmRequest) error); ok {
r1 = rf(ctx, request)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// DataCoord_GcConfirm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GcConfirm'
type DataCoord_GcConfirm_Call struct {
*mock.Call
}
// GcConfirm is a helper method to define mock.On call
// - ctx context.Context
// - request *datapb.GcConfirmRequest
func (_e *DataCoord_Expecter) GcConfirm(ctx interface{}, request interface{}) *DataCoord_GcConfirm_Call {
return &DataCoord_GcConfirm_Call{Call: _e.mock.On("GcConfirm", ctx, request)}
}
func (_c *DataCoord_GcConfirm_Call) Run(run func(ctx context.Context, request *datapb.GcConfirmRequest)) *DataCoord_GcConfirm_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*datapb.GcConfirmRequest))
})
return _c
}
func (_c *DataCoord_GcConfirm_Call) Return(_a0 *datapb.GcConfirmResponse, _a1 error) *DataCoord_GcConfirm_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// GetCollectionStatistics provides a mock function with given fields: ctx, req
func (_m *DataCoord) GetCollectionStatistics(ctx context.Context, req *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error) {
ret := _m.Called(ctx, req)
@ -545,6 +735,147 @@ func (_c *DataCoord_GetFlushedSegments_Call) Return(_a0 *datapb.GetFlushedSegmen
return _c
}
// GetIndexBuildProgress provides a mock function with given fields: ctx, req
func (_m *DataCoord) GetIndexBuildProgress(ctx context.Context, req *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error) {
ret := _m.Called(ctx, req)
var r0 *indexpb.GetIndexBuildProgressResponse
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexBuildProgressRequest) *indexpb.GetIndexBuildProgressResponse); ok {
r0 = rf(ctx, req)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*indexpb.GetIndexBuildProgressResponse)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexBuildProgressRequest) error); ok {
r1 = rf(ctx, req)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// DataCoord_GetIndexBuildProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexBuildProgress'
type DataCoord_GetIndexBuildProgress_Call struct {
*mock.Call
}
// GetIndexBuildProgress is a helper method to define mock.On call
// - ctx context.Context
// - req *indexpb.GetIndexBuildProgressRequest
func (_e *DataCoord_Expecter) GetIndexBuildProgress(ctx interface{}, req interface{}) *DataCoord_GetIndexBuildProgress_Call {
return &DataCoord_GetIndexBuildProgress_Call{Call: _e.mock.On("GetIndexBuildProgress", ctx, req)}
}
func (_c *DataCoord_GetIndexBuildProgress_Call) Run(run func(ctx context.Context, req *indexpb.GetIndexBuildProgressRequest)) *DataCoord_GetIndexBuildProgress_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*indexpb.GetIndexBuildProgressRequest))
})
return _c
}
func (_c *DataCoord_GetIndexBuildProgress_Call) Return(_a0 *indexpb.GetIndexBuildProgressResponse, _a1 error) *DataCoord_GetIndexBuildProgress_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// GetIndexInfos provides a mock function with given fields: ctx, req
func (_m *DataCoord) GetIndexInfos(ctx context.Context, req *indexpb.GetIndexInfoRequest) (*indexpb.GetIndexInfoResponse, error) {
ret := _m.Called(ctx, req)
var r0 *indexpb.GetIndexInfoResponse
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexInfoRequest) *indexpb.GetIndexInfoResponse); ok {
r0 = rf(ctx, req)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*indexpb.GetIndexInfoResponse)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexInfoRequest) error); ok {
r1 = rf(ctx, req)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// DataCoord_GetIndexInfos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexInfos'
type DataCoord_GetIndexInfos_Call struct {
*mock.Call
}
// GetIndexInfos is a helper method to define mock.On call
// - ctx context.Context
// - req *indexpb.GetIndexInfoRequest
func (_e *DataCoord_Expecter) GetIndexInfos(ctx interface{}, req interface{}) *DataCoord_GetIndexInfos_Call {
return &DataCoord_GetIndexInfos_Call{Call: _e.mock.On("GetIndexInfos", ctx, req)}
}
func (_c *DataCoord_GetIndexInfos_Call) Run(run func(ctx context.Context, req *indexpb.GetIndexInfoRequest)) *DataCoord_GetIndexInfos_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*indexpb.GetIndexInfoRequest))
})
return _c
}
func (_c *DataCoord_GetIndexInfos_Call) Return(_a0 *indexpb.GetIndexInfoResponse, _a1 error) *DataCoord_GetIndexInfos_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// GetIndexState provides a mock function with given fields: ctx, req
func (_m *DataCoord) GetIndexState(ctx context.Context, req *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error) {
ret := _m.Called(ctx, req)
var r0 *indexpb.GetIndexStateResponse
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStateRequest) *indexpb.GetIndexStateResponse); ok {
r0 = rf(ctx, req)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*indexpb.GetIndexStateResponse)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexStateRequest) error); ok {
r1 = rf(ctx, req)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// DataCoord_GetIndexState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexState'
type DataCoord_GetIndexState_Call struct {
*mock.Call
}
// GetIndexState is a helper method to define mock.On call
// - ctx context.Context
// - req *indexpb.GetIndexStateRequest
func (_e *DataCoord_Expecter) GetIndexState(ctx interface{}, req interface{}) *DataCoord_GetIndexState_Call {
return &DataCoord_GetIndexState_Call{Call: _e.mock.On("GetIndexState", ctx, req)}
}
func (_c *DataCoord_GetIndexState_Call) Run(run func(ctx context.Context, req *indexpb.GetIndexStateRequest)) *DataCoord_GetIndexState_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*indexpb.GetIndexStateRequest))
})
return _c
}
func (_c *DataCoord_GetIndexState_Call) Return(_a0 *indexpb.GetIndexStateResponse, _a1 error) *DataCoord_GetIndexState_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// GetInsertBinlogPaths provides a mock function with given fields: ctx, req
func (_m *DataCoord) GetInsertBinlogPaths(ctx context.Context, req *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error) {
ret := _m.Called(ctx, req)
@ -733,6 +1064,53 @@ func (_c *DataCoord_GetRecoveryInfo_Call) Return(_a0 *datapb.GetRecoveryInfoResp
return _c
}
// GetSegmentIndexState provides a mock function with given fields: ctx, req
func (_m *DataCoord) GetSegmentIndexState(ctx context.Context, req *indexpb.GetSegmentIndexStateRequest) (*indexpb.GetSegmentIndexStateResponse, error) {
ret := _m.Called(ctx, req)
var r0 *indexpb.GetSegmentIndexStateResponse
if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetSegmentIndexStateRequest) *indexpb.GetSegmentIndexStateResponse); ok {
r0 = rf(ctx, req)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*indexpb.GetSegmentIndexStateResponse)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetSegmentIndexStateRequest) error); ok {
r1 = rf(ctx, req)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// DataCoord_GetSegmentIndexState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentIndexState'
type DataCoord_GetSegmentIndexState_Call struct {
*mock.Call
}
// GetSegmentIndexState is a helper method to define mock.On call
// - ctx context.Context
// - req *indexpb.GetSegmentIndexStateRequest
func (_e *DataCoord_Expecter) GetSegmentIndexState(ctx interface{}, req interface{}) *DataCoord_GetSegmentIndexState_Call {
return &DataCoord_GetSegmentIndexState_Call{Call: _e.mock.On("GetSegmentIndexState", ctx, req)}
}
func (_c *DataCoord_GetSegmentIndexState_Call) Run(run func(ctx context.Context, req *indexpb.GetSegmentIndexStateRequest)) *DataCoord_GetSegmentIndexState_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*indexpb.GetSegmentIndexStateRequest))
})
return _c
}
func (_c *DataCoord_GetSegmentIndexState_Call) Return(_a0 *indexpb.GetSegmentIndexStateResponse, _a1 error) *DataCoord_GetSegmentIndexState_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// GetSegmentInfo provides a mock function with given fields: ctx, req
func (_m *DataCoord) GetSegmentInfo(ctx context.Context, req *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) {
ret := _m.Called(ctx, req)
@ -1532,6 +1910,53 @@ func (_c *DataCoord_UnsetIsImportingState_Call) Return(_a0 *commonpb.Status, _a1
return _c
}
// UpdateChannelCheckpoint provides a mock function with given fields: ctx, req
func (_m *DataCoord) UpdateChannelCheckpoint(ctx context.Context, req *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error) {
ret := _m.Called(ctx, req)
var r0 *commonpb.Status
if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) *commonpb.Status); ok {
r0 = rf(ctx, req)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*commonpb.Status)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) error); ok {
r1 = rf(ctx, req)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// DataCoord_UpdateChannelCheckpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannelCheckpoint'
type DataCoord_UpdateChannelCheckpoint_Call struct {
*mock.Call
}
// UpdateChannelCheckpoint is a helper method to define mock.On call
// - ctx context.Context
// - req *datapb.UpdateChannelCheckpointRequest
func (_e *DataCoord_Expecter) UpdateChannelCheckpoint(ctx interface{}, req interface{}) *DataCoord_UpdateChannelCheckpoint_Call {
return &DataCoord_UpdateChannelCheckpoint_Call{Call: _e.mock.On("UpdateChannelCheckpoint", ctx, req)}
}
func (_c *DataCoord_UpdateChannelCheckpoint_Call) Run(run func(ctx context.Context, req *datapb.UpdateChannelCheckpointRequest)) *DataCoord_UpdateChannelCheckpoint_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*datapb.UpdateChannelCheckpointRequest))
})
return _c
}
func (_c *DataCoord_UpdateChannelCheckpoint_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_UpdateChannelCheckpoint_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// UpdateSegmentStatistics provides a mock function with given fields: ctx, req
func (_m *DataCoord) UpdateSegmentStatistics(ctx context.Context, req *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error) {
ret := _m.Called(ctx, req)

1033
internal/mocks/mock_datacoord_catalog.go Normal file
View File

File diff suppressed because it is too large Load Diff

12
internal/proto/data_coord.proto
View File

@ -77,6 +77,8 @@ service DataCoord {
rpc DescribeIndex(index.DescribeIndexRequest) returns (index.DescribeIndexResponse) {}
// Deprecated: use DescribeIndex instead
rpc GetIndexBuildProgress(index.GetIndexBuildProgressRequest) returns (index.GetIndexBuildProgressResponse) {}
rpc GcConfirm(GcConfirmRequest) returns (GcConfirmResponse) {}
}
service DataNode {
@ -643,6 +645,16 @@ message AlterCollectionRequest {
repeated common.KeyValuePair properties = 5;
}
message GcConfirmRequest {
int64 collection_id = 1;
int64 partition_id = 2; // -1 means whole collection.
}
message GcConfirmResponse {
common.Status status = 1;
bool gc_finished = 2;
}
//message IndexInfo {
// int64 collectionID = 1;
// int64 fieldID = 2;

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

@ -4781,6 +4781,100 @@ func (m *AlterCollectionRequest) GetProperties() []*commonpb.KeyValuePair {
return nil
}
type GcConfirmRequest struct {
CollectionId int64 `protobuf:"varint,1,opt,name=collection_id,json=collectionId,proto3" json:"collection_id,omitempty"`
PartitionId int64 `protobuf:"varint,2,opt,name=partition_id,json=partitionId,proto3" json:"partition_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GcConfirmRequest) Reset() { *m = GcConfirmRequest{} }
func (m *GcConfirmRequest) String() string { return proto.CompactTextString(m) }
func (*GcConfirmRequest) ProtoMessage() {}
func (*GcConfirmRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{74}
}
func (m *GcConfirmRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GcConfirmRequest.Unmarshal(m, b)
}
func (m *GcConfirmRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GcConfirmRequest.Marshal(b, m, deterministic)
}
func (m *GcConfirmRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GcConfirmRequest.Merge(m, src)
}
func (m *GcConfirmRequest) XXX_Size() int {
return xxx_messageInfo_GcConfirmRequest.Size(m)
}
func (m *GcConfirmRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GcConfirmRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GcConfirmRequest proto.InternalMessageInfo
func (m *GcConfirmRequest) GetCollectionId() int64 {
if m != nil {
return m.CollectionId
}
return 0
}
func (m *GcConfirmRequest) GetPartitionId() int64 {
if m != nil {
return m.PartitionId
}
return 0
}
type GcConfirmResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
GcFinished bool `protobuf:"varint,2,opt,name=gc_finished,json=gcFinished,proto3" json:"gc_finished,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GcConfirmResponse) Reset() { *m = GcConfirmResponse{} }
func (m *GcConfirmResponse) String() string { return proto.CompactTextString(m) }
func (*GcConfirmResponse) ProtoMessage() {}
func (*GcConfirmResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{75}
}
func (m *GcConfirmResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GcConfirmResponse.Unmarshal(m, b)
}
func (m *GcConfirmResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GcConfirmResponse.Marshal(b, m, deterministic)
}
func (m *GcConfirmResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_GcConfirmResponse.Merge(m, src)
}
func (m *GcConfirmResponse) XXX_Size() int {
return xxx_messageInfo_GcConfirmResponse.Size(m)
}
func (m *GcConfirmResponse) XXX_DiscardUnknown() {
xxx_messageInfo_GcConfirmResponse.DiscardUnknown(m)
}
var xxx_messageInfo_GcConfirmResponse proto.InternalMessageInfo
func (m *GcConfirmResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
func (m *GcConfirmResponse) GetGcFinished() bool {
if m != nil {
return m.GcFinished
}
return false
}
func init() {
proto.RegisterEnum("milvus.proto.data.SegmentType", SegmentType_name, SegmentType_value)
proto.RegisterEnum("milvus.proto.data.ChannelWatchState", ChannelWatchState_name, ChannelWatchState_value)
@ -4860,300 +4954,306 @@ func init() {
proto.RegisterType((*MarkSegmentsDroppedRequest)(nil), "milvus.proto.data.MarkSegmentsDroppedRequest")
proto.RegisterType((*SegmentReferenceLock)(nil), "milvus.proto.data.SegmentReferenceLock")
proto.RegisterType((*AlterCollectionRequest)(nil), "milvus.proto.data.AlterCollectionRequest")
proto.RegisterType((*GcConfirmRequest)(nil), "milvus.proto.data.GcConfirmRequest")
proto.RegisterType((*GcConfirmResponse)(nil), "milvus.proto.data.GcConfirmResponse")
}
func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
var fileDescriptor_82cd95f524594f49 = []byte{
// 4597 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x3c, 0x4b, 0x8c, 0x1c, 0x49,
0x56, 0xce, 0xfa, 0x75, 0xd5, 0xab, 0x4f, 0x57, 0x87, 0x3d, 0xed, 0x72, 0xf9, 0x9f, 0xb6, 0xc7,
0x3d, 0x1e, 0x8f, 0xed, 0xf1, 0x30, 0x5a, 0xb3, 0xde, 0x99, 0xc5, 0xdd, 0x6d, 0x7b, 0x0a, 0xdc,
0xbd, 0xbd, 0xd9, 0xed, 0xb1, 0xb4, 0x8b, 0x54, 0xca, 0xae, 0x8c, 0xae, 0xce, 0xed, 0xaa, 0xcc,
0x72, 0x66, 0x56, 0xb7, 0x7b, 0x91, 0xd8, 0x01, 0x24, 0xa4, 0x41, 0x08, 0x10, 0x12, 0x02, 0x24,
0x0e, 0x88, 0xd3, 0xb2, 0x68, 0x11, 0xd2, 0x8a, 0x0b, 0x17, 0xae, 0x23, 0x38, 0x8c, 0x10, 0x12,
0x47, 0x8e, 0xc0, 0x9d, 0x2b, 0x07, 0x14, 0x9f, 0x8c, 0xfc, 0x45, 0x56, 0x65, 0x57, 0xd9, 0x63,
0x09, 0x6e, 0x15, 0x91, 0x2f, 0x5e, 0xbc, 0x88, 0xf7, 0x7f, 0x11, 0x51, 0xd0, 0x34, 0x74, 0x4f,
0xef, 0xf6, 0x6c, 0xdb, 0x31, 0xee, 0x8c, 0x1c, 0xdb, 0xb3, 0xd1, 0xd2, 0xd0, 0x1c, 0x1c, 0x8e,
0x5d, 0xd6, 0xba, 0x43, 0x3e, 0xb7, 0x6b, 0x3d, 0x7b, 0x38, 0xb4, 0x2d, 0xd6, 0xd5, 0x6e, 0x98,
0x96, 0x87, 0x1d, 0x4b, 0x1f, 0xf0, 0x76, 0x2d, 0x3c, 0xa0, 0x5d, 0x73, 0x7b, 0xfb, 0x78, 0xa8,
0xf3, 0xd6, 0x92, 0x69, 0x19, 0xf8, 0x55, 0x18, 0xbf, 0xba, 0x00, 0xc5, 0xc7, 0xc3, 0x91, 0x77,
0xac, 0xfe, 0x99, 0x02, 0xb5, 0x27, 0x83, 0xb1, 0xbb, 0xaf, 0xe1, 0x97, 0x63, 0xec, 0x7a, 0xe8,
0x1e, 0x14, 0x76, 0x75, 0x17, 0xb7, 0x94, 0x2b, 0xca, 0x4a, 0xf5, 0xfe, 0x85, 0x3b, 0x11, 0x42,
0x38, 0x09, 0x1b, 0x6e, 0x7f, 0x55, 0x77, 0xb1, 0x46, 0x21, 0x11, 0x82, 0x82, 0xb1, 0xdb, 0x59,
0x6f, 0xe5, 0xae, 0x28, 0x2b, 0x79, 0x8d, 0xfe, 0x46, 0x97, 0x00, 0x5c, 0xdc, 0x1f, 0x62, 0xcb,
0xeb, 0xac, 0xbb, 0xad, 0xfc, 0x95, 0xfc, 0x4a, 0x5e, 0x0b, 0xf5, 0x20, 0x15, 0x6a, 0x3d, 0x7b,
0x30, 0xc0, 0x3d, 0xcf, 0xb4, 0xad, 0xce, 0x7a, 0xab, 0x40, 0xc7, 0x46, 0xfa, 0xd4, 0xff, 0x50,
0xa0, 0xce, 0x49, 0x73, 0x47, 0xb6, 0xe5, 0x62, 0xf4, 0x11, 0x94, 0x5c, 0x4f, 0xf7, 0xc6, 0x2e,
0xa7, 0xee, 0xbc, 0x94, 0xba, 0x6d, 0x0a, 0xa2, 0x71, 0x50, 0x29, 0x79, 0xf1, 0xe9, 0xf3, 0xc9,
0xe9, 0x63, 0x4b, 0x28, 0x24, 0x96, 0xb0, 0x02, 0x8b, 0x7b, 0x84, 0xba, 0xed, 0x00, 0xa8, 0x48,
0x81, 0xe2, 0xdd, 0x04, 0x93, 0x67, 0x0e, 0xf1, 0xf7, 0xf6, 0xb6, 0xb1, 0x3e, 0x68, 0x95, 0xe8,
0x5c, 0xa1, 0x1e, 0xf5, 0x5f, 0x14, 0x68, 0x0a, 0x70, 0x9f, 0x0f, 0x67, 0xa0, 0xd8, 0xb3, 0xc7,
0x96, 0x47, 0x97, 0x5a, 0xd7, 0x58, 0x03, 0x5d, 0x85, 0x5a, 0x6f, 0x5f, 0xb7, 0x2c, 0x3c, 0xe8,
0x5a, 0xfa, 0x10, 0xd3, 0x45, 0x55, 0xb4, 0x2a, 0xef, 0xdb, 0xd4, 0x87, 0x38, 0xd3, 0xda, 0xae,
0x40, 0x75, 0xa4, 0x3b, 0x9e, 0x19, 0xd9, 0xfd, 0x70, 0x17, 0x6a, 0x43, 0xd9, 0x74, 0x3b, 0xc3,
0x91, 0xed, 0x78, 0xad, 0xe2, 0x15, 0x65, 0xa5, 0xac, 0x89, 0x36, 0x99, 0xc1, 0xa4, 0xbf, 0x76,
0x74, 0xf7, 0xa0, 0xb3, 0xce, 0x57, 0x14, 0xe9, 0x53, 0xff, 0x52, 0x81, 0xe5, 0x47, 0xae, 0x6b,
0xf6, 0xad, 0xc4, 0xca, 0x96, 0xa1, 0x64, 0xd9, 0x06, 0xee, 0xac, 0xd3, 0xa5, 0xe5, 0x35, 0xde,
0x42, 0xe7, 0xa1, 0x32, 0xc2, 0xd8, 0xe9, 0x3a, 0xf6, 0xc0, 0x5f, 0x58, 0x99, 0x74, 0x68, 0xf6,
0x00, 0xa3, 0xef, 0xc3, 0x92, 0x1b, 0x43, 0xc4, 0xe4, 0xaa, 0x7a, 0xff, 0xda, 0x9d, 0x84, 0xb2,
0xdc, 0x89, 0x4f, 0xaa, 0x25, 0x47, 0xab, 0x5f, 0xe4, 0xe0, 0xb4, 0x80, 0x63, 0xb4, 0x92, 0xdf,
0x64, 0xe7, 0x5d, 0xdc, 0x17, 0xe4, 0xb1, 0x46, 0x96, 0x9d, 0x17, 0x2c, 0xcb, 0x87, 0x59, 0x96,
0x41, 0xd4, 0xe3, 0xfc, 0x28, 0x26, 0xf9, 0x71, 0x19, 0xaa, 0xf8, 0xd5, 0xc8, 0x74, 0x70, 0x97,
0x08, 0x0e, 0xdd, 0xf2, 0x82, 0x06, 0xac, 0x6b, 0xc7, 0x1c, 0x86, 0x75, 0x63, 0x21, 0xb3, 0x6e,
0xa8, 0x7f, 0xa5, 0xc0, 0xd9, 0x04, 0x97, 0xb8, 0xb2, 0x69, 0xd0, 0xa4, 0x2b, 0x0f, 0x76, 0x86,
0xa8, 0x1d, 0xd9, 0xf0, 0x77, 0x27, 0x6d, 0x78, 0x00, 0xae, 0x25, 0xc6, 0x87, 0x88, 0xcc, 0x65,
0x27, 0xf2, 0x00, 0xce, 0x3e, 0xc5, 0x1e, 0x9f, 0x80, 0x7c, 0xc3, 0xee, 0xec, 0xc6, 0x2a, 0xaa,
0xd5, 0xb9, 0xb8, 0x56, 0xab, 0x7f, 0x97, 0x13, 0xba, 0x48, 0xa7, 0xea, 0x58, 0x7b, 0x36, 0xba,
0x00, 0x15, 0x01, 0xc2, 0xa5, 0x22, 0xe8, 0x40, 0xdf, 0x82, 0x22, 0xa1, 0x94, 0x89, 0x44, 0xe3,
0xfe, 0x55, 0xf9, 0x9a, 0x42, 0x38, 0x35, 0x06, 0x8f, 0x3a, 0xd0, 0x70, 0x3d, 0xdd, 0xf1, 0xba,
0x23, 0xdb, 0xa5, 0x7c, 0xa6, 0x82, 0x53, 0xbd, 0xaf, 0x46, 0x31, 0x08, 0x4b, 0xbf, 0xe1, 0xf6,
0xb7, 0x38, 0xa4, 0x56, 0xa7, 0x23, 0xfd, 0x26, 0x7a, 0x0c, 0x35, 0x6c, 0x19, 0x01, 0xa2, 0x42,
0x66, 0x44, 0x55, 0x6c, 0x19, 0x02, 0x4d, 0xc0, 0x9f, 0x62, 0x76, 0xfe, 0xfc, 0xbe, 0x02, 0xad,
0x24, 0x83, 0xe6, 0x31, 0xd9, 0x0f, 0xd9, 0x20, 0xcc, 0x18, 0x34, 0x51, 0xc3, 0x05, 0x93, 0x34,
0x3e, 0x44, 0xfd, 0x13, 0x05, 0xde, 0x09, 0xc8, 0xa1, 0x9f, 0xde, 0x94, 0xb4, 0xa0, 0x5b, 0xd0,
0x34, 0xad, 0xde, 0x60, 0x6c, 0xe0, 0xe7, 0xd6, 0x67, 0x58, 0x1f, 0x78, 0xfb, 0xc7, 0x94, 0x87,
0x65, 0x2d, 0xd1, 0xaf, 0xfe, 0x7b, 0x0e, 0x96, 0xe3, 0x74, 0xcd, 0xb3, 0x49, 0xbf, 0x04, 0x45,
0xd3, 0xda, 0xb3, 0xfd, 0x3d, 0xba, 0x34, 0x41, 0x29, 0xc9, 0x5c, 0x0c, 0x18, 0xd9, 0x80, 0x7c,
0x33, 0xd6, 0xdb, 0xc7, 0xbd, 0x83, 0x91, 0x6d, 0x52, 0x83, 0x45, 0x50, 0xfc, 0x8a, 0x04, 0x85,
0x9c, 0xe2, 0x3b, 0x6b, 0x0c, 0xc7, 0x9a, 0x40, 0xf1, 0xd8, 0xf2, 0x9c, 0x63, 0x6d, 0xa9, 0x17,
0xef, 0x6f, 0xef, 0xc3, 0xb2, 0x1c, 0x18, 0x35, 0x21, 0x7f, 0x80, 0x8f, 0xe9, 0x92, 0x2b, 0x1a,
0xf9, 0x89, 0x1e, 0x40, 0xf1, 0x50, 0x1f, 0x8c, 0x31, 0xb7, 0x0e, 0x59, 0xc4, 0x97, 0x0d, 0xf8,
0x76, 0xee, 0x81, 0xa2, 0x0e, 0xe1, 0xfc, 0x53, 0xec, 0x75, 0x2c, 0x17, 0x3b, 0xde, 0xaa, 0x69,
0x0d, 0xec, 0xfe, 0x96, 0xee, 0xed, 0xcf, 0x61, 0x2b, 0x22, 0x6a, 0x9f, 0x8b, 0xa9, 0xbd, 0xfa,
0x53, 0x05, 0x2e, 0xc8, 0xe7, 0xe3, 0x5c, 0x6d, 0x43, 0x79, 0xcf, 0xc4, 0x03, 0x83, 0x88, 0x8e,
0x42, 0x45, 0x47, 0xb4, 0x89, 0xcd, 0x18, 0x11, 0x60, 0xce, 0xbc, 0xab, 0x29, 0x2b, 0xdd, 0xf6,
0x1c, 0xd3, 0xea, 0x3f, 0x33, 0x5d, 0x4f, 0x63, 0xf0, 0x21, 0x51, 0xc9, 0x67, 0xd7, 0xd0, 0xdf,
0x53, 0xe0, 0xd2, 0x53, 0xec, 0xad, 0x09, 0x97, 0x43, 0xbe, 0x9b, 0xae, 0x67, 0xf6, 0xdc, 0xd7,
0x1b, 0xf6, 0x65, 0x88, 0x3d, 0xd4, 0x3f, 0x54, 0xe0, 0x72, 0x2a, 0x31, 0x7c, 0xeb, 0xb8, 0x49,
0xf5, 0x1d, 0x8e, 0xdc, 0xa4, 0xfe, 0x1a, 0x3e, 0xfe, 0x9c, 0x30, 0x7f, 0x4b, 0x37, 0x1d, 0x66,
0x52, 0x67, 0x74, 0x30, 0x3f, 0x57, 0xe0, 0xe2, 0x53, 0xec, 0x6d, 0xf9, 0xee, 0xf6, 0x2d, 0xee,
0x0e, 0x81, 0x09, 0xb9, 0x7d, 0x3f, 0xee, 0x8c, 0xf4, 0xa9, 0x7f, 0xc0, 0xd8, 0x29, 0xa5, 0xf7,
0xad, 0x6c, 0xe0, 0x25, 0xaa, 0x09, 0x21, 0x3b, 0xc1, 0x35, 0x9e, 0x6f, 0x9f, 0xfa, 0x65, 0x11,
0x6a, 0x9f, 0x73, 0xd3, 0x40, 0x1d, 0x6a, 0x7c, 0x27, 0x14, 0x79, 0x4c, 0x14, 0x0a, 0xae, 0x64,
0xf1, 0xd6, 0x53, 0xa8, 0xbb, 0x18, 0x1f, 0xcc, 0xe2, 0x3e, 0x6b, 0x64, 0xa0, 0x70, 0x7b, 0xcf,
0x60, 0x69, 0x6c, 0xd1, 0xa8, 0x1d, 0x1b, 0x7c, 0x15, 0x6c, 0xe7, 0xa7, 0x9b, 0xd5, 0xe4, 0x40,
0xf4, 0x19, 0x4f, 0x0c, 0x42, 0xb8, 0x8a, 0x99, 0x70, 0xc5, 0x87, 0xa1, 0x0e, 0x34, 0x0d, 0xc7,
0x1e, 0x8d, 0xb0, 0xd1, 0x75, 0x7d, 0x54, 0xa5, 0x6c, 0xa8, 0xf8, 0x38, 0x81, 0xea, 0x1e, 0x9c,
0x8e, 0x53, 0xda, 0x31, 0x48, 0xac, 0x48, 0xc4, 0x4b, 0xf6, 0x09, 0xdd, 0x86, 0xa5, 0x24, 0x7c,
0x99, 0xc2, 0x27, 0x3f, 0xa0, 0x0f, 0x00, 0xc5, 0x48, 0x25, 0xe0, 0x15, 0x06, 0x1e, 0x25, 0x86,
0x83, 0xd3, 0xa4, 0x34, 0x0a, 0x0e, 0x0c, 0x9c, 0x7f, 0x09, 0x81, 0x77, 0x88, 0x9f, 0x8d, 0x80,
0xbb, 0xad, 0x6a, 0xb6, 0x8d, 0x88, 0x22, 0x73, 0xd5, 0x2f, 0x15, 0x58, 0x7e, 0xa1, 0x7b, 0xbd,
0xfd, 0xf5, 0x21, 0x97, 0xd2, 0x39, 0xb4, 0xfc, 0x13, 0xa8, 0x1c, 0x72, 0x89, 0xf4, 0x4d, 0xf9,
0x65, 0x09, 0x41, 0x61, 0xd9, 0xd7, 0x82, 0x11, 0x24, 0x49, 0x3a, 0xf3, 0x24, 0x94, 0x2c, 0xbe,
0x05, 0x7b, 0x33, 0x25, 0xcb, 0x55, 0x5f, 0x01, 0x70, 0xe2, 0x36, 0xdc, 0xfe, 0x0c, 0x74, 0x3d,
0x80, 0x05, 0x8e, 0x8d, 0x1b, 0x94, 0x69, 0x0c, 0xf3, 0xc1, 0xd5, 0x9f, 0x95, 0xa0, 0x1a, 0xfa,
0x80, 0x1a, 0x90, 0x13, 0x96, 0x22, 0x27, 0x59, 0x5d, 0x6e, 0x7a, 0x5e, 0x95, 0x4f, 0xe6, 0x55,
0x37, 0xa0, 0x61, 0x52, 0x0f, 0xde, 0xe5, 0x5c, 0xa1, 0xa1, 0x73, 0x45, 0xab, 0xb3, 0x5e, 0x2e,
0x22, 0xe8, 0x12, 0x54, 0xad, 0xf1, 0xb0, 0x6b, 0xef, 0x75, 0x1d, 0xfb, 0xc8, 0xe5, 0x09, 0x5a,
0xc5, 0x1a, 0x0f, 0xbf, 0xb7, 0xa7, 0xd9, 0x47, 0x6e, 0x90, 0x03, 0x94, 0x4e, 0x98, 0x03, 0x5c,
0x82, 0xea, 0x50, 0x7f, 0x45, 0xb0, 0x76, 0xad, 0xf1, 0x90, 0xe6, 0x6e, 0x79, 0xad, 0x32, 0xd4,
0x5f, 0x69, 0xf6, 0xd1, 0xe6, 0x78, 0x88, 0x56, 0xa0, 0x39, 0xd0, 0x5d, 0xaf, 0x1b, 0x4e, 0xfe,
0xca, 0x34, 0xf9, 0x6b, 0x90, 0xfe, 0xc7, 0x41, 0x02, 0x98, 0xcc, 0x26, 0x2a, 0x73, 0x64, 0x13,
0xc6, 0x70, 0x10, 0x20, 0x82, 0xec, 0xd9, 0x84, 0x31, 0x1c, 0x08, 0x34, 0x0f, 0x60, 0x61, 0x97,
0xc6, 0x45, 0x93, 0x94, 0xf5, 0x09, 0x09, 0x89, 0x58, 0xf8, 0xa4, 0xf9, 0xe0, 0xe8, 0x3b, 0x50,
0xa1, 0xee, 0x88, 0x8e, 0xad, 0x65, 0x1a, 0x1b, 0x0c, 0x20, 0xa3, 0x0d, 0x3c, 0xf0, 0x74, 0x3a,
0xba, 0x9e, 0x6d, 0xb4, 0x18, 0x40, 0x2c, 0x65, 0xcf, 0xc1, 0xba, 0x87, 0x8d, 0xd5, 0xe3, 0x35,
0x7b, 0x38, 0xd2, 0xa9, 0x30, 0xb5, 0x1a, 0x34, 0xac, 0x97, 0x7d, 0x42, 0xef, 0x42, 0xa3, 0x27,
0x5a, 0x4f, 0x1c, 0x7b, 0xd8, 0x5a, 0xa4, 0x7a, 0x14, 0xeb, 0x45, 0x17, 0x01, 0x7c, 0x1b, 0xa9,
0x7b, 0xad, 0x26, 0xe5, 0x62, 0x85, 0xf7, 0x3c, 0xa2, 0xb5, 0x1d, 0xd3, 0xed, 0xb2, 0x2a, 0x8a,
0x69, 0xf5, 0x5b, 0x4b, 0x74, 0xc6, 0xaa, 0x5f, 0x76, 0x31, 0xad, 0x3e, 0x3a, 0x0b, 0x0b, 0xa6,
0xdb, 0xdd, 0xd3, 0x0f, 0x70, 0x0b, 0xd1, 0xaf, 0x25, 0xd3, 0x7d, 0xa2, 0x1f, 0x60, 0xf5, 0x27,
0x70, 0x26, 0x90, 0xae, 0x10, 0x27, 0x93, 0x42, 0xa1, 0xcc, 0x2a, 0x14, 0x93, 0xa3, 0xe1, 0xaf,
0x0b, 0xb0, 0xbc, 0xad, 0x1f, 0xe2, 0x37, 0x1f, 0x78, 0x67, 0x32, 0x6b, 0xcf, 0x60, 0x89, 0xc6,
0xda, 0xf7, 0x43, 0xf4, 0x4c, 0xf0, 0xe8, 0x61, 0x51, 0x48, 0x0e, 0x44, 0xdf, 0x25, 0xa1, 0x08,
0xee, 0x1d, 0x6c, 0x91, 0xe4, 0xc5, 0xf7, 0xe6, 0x17, 0x25, 0x78, 0xd6, 0x04, 0x94, 0x16, 0x1e,
0x81, 0xb6, 0x60, 0x31, 0xca, 0x06, 0xdf, 0x8f, 0xdf, 0x9c, 0x98, 0xd9, 0x06, 0xbb, 0xaf, 0x35,
0x22, 0xcc, 0x70, 0x51, 0x0b, 0x16, 0xb8, 0x13, 0xa6, 0x36, 0xa3, 0xac, 0xf9, 0x4d, 0xb4, 0x05,
0xa7, 0xd9, 0x0a, 0xb6, 0xb9, 0x42, 0xb0, 0xc5, 0x97, 0x33, 0x2d, 0x5e, 0x36, 0x34, 0xaa, 0x4f,
0x95, 0x93, 0xea, 0x53, 0x0b, 0x16, 0xb8, 0x8c, 0x53, 0x3b, 0x52, 0xd6, 0xfc, 0x26, 0x61, 0x73,
0x20, 0xed, 0x55, 0xfa, 0x2d, 0xe8, 0x20, 0x49, 0x0b, 0x04, 0xfb, 0x39, 0xa5, 0x06, 0xf3, 0x29,
0x94, 0x85, 0x84, 0x67, 0x4f, 0x1e, 0xc5, 0x98, 0xb8, 0x7d, 0xcf, 0xc7, 0xec, 0xbb, 0xfa, 0xcf,
0x0a, 0xd4, 0xd6, 0xc9, 0x92, 0x9e, 0xd9, 0x7d, 0xea, 0x8d, 0x6e, 0x40, 0xc3, 0xc1, 0x3d, 0xdb,
0x31, 0xba, 0xd8, 0xf2, 0x1c, 0x13, 0xb3, 0xd4, 0xbd, 0xa0, 0xd5, 0x59, 0xef, 0x63, 0xd6, 0x49,
0xc0, 0x88, 0xc9, 0x76, 0x3d, 0x7d, 0x38, 0xea, 0xee, 0x11, 0xd3, 0x90, 0x63, 0x60, 0xa2, 0x97,
0x5a, 0x86, 0xab, 0x50, 0x0b, 0xc0, 0x3c, 0x9b, 0xce, 0x5f, 0xd0, 0xaa, 0xa2, 0x6f, 0xc7, 0x46,
0xd7, 0xa1, 0x41, 0xf7, 0xb4, 0x3b, 0xb0, 0xfb, 0x5d, 0x92, 0x0b, 0x72, 0x47, 0x55, 0x33, 0x38,
0x59, 0x84, 0x57, 0x51, 0x28, 0xd7, 0xfc, 0x31, 0xe6, 0xae, 0x4a, 0x40, 0x6d, 0x9b, 0x3f, 0xc6,
0xea, 0x3f, 0x29, 0x50, 0x5f, 0xd7, 0x3d, 0x7d, 0xd3, 0x36, 0xf0, 0xce, 0x8c, 0x8e, 0x3d, 0x43,
0x3d, 0xf4, 0x02, 0x54, 0xc4, 0x0a, 0xf8, 0x92, 0x82, 0x0e, 0xf4, 0x04, 0x1a, 0x7e, 0x2c, 0xd7,
0x65, 0xb9, 0x4a, 0x21, 0x35, 0x80, 0x0a, 0x79, 0x4e, 0x57, 0xab, 0xfb, 0xc3, 0x68, 0x53, 0x7d,
0x02, 0xb5, 0xf0, 0x67, 0x32, 0xeb, 0x76, 0x5c, 0x50, 0x44, 0x07, 0x91, 0xc6, 0xcd, 0xf1, 0x90,
0xf0, 0x94, 0x1b, 0x16, 0xbf, 0xa9, 0xfe, 0x8e, 0x02, 0x75, 0xee, 0xee, 0xb7, 0xc5, 0xc9, 0x01,
0x5d, 0x1a, 0xab, 0x50, 0xd0, 0xdf, 0xe8, 0xdb, 0xd1, 0x62, 0xdf, 0x75, 0xa9, 0x11, 0xa0, 0x48,
0x68, 0x90, 0x19, 0xf1, 0xf5, 0x59, 0xb2, 0xe3, 0x2f, 0x88, 0xa0, 0x71, 0xd6, 0x50, 0x41, 0x6b,
0xc1, 0x82, 0x6e, 0x18, 0x0e, 0x76, 0x5d, 0x4e, 0x87, 0xdf, 0x24, 0x5f, 0x0e, 0xb1, 0xe3, 0xfa,
0x22, 0x9f, 0xd7, 0xfc, 0x26, 0xfa, 0x0e, 0x94, 0x45, 0x54, 0xca, 0x4a, 0x3b, 0x57, 0xd2, 0xe9,
0xe4, 0xb9, 0x9c, 0x18, 0xa1, 0xfe, 0x7d, 0x0e, 0x1a, 0x7c, 0xc3, 0x56, 0xb9, 0x3f, 0x9e, 0xac,
0x7c, 0xab, 0x50, 0xdb, 0x0b, 0x74, 0x7f, 0x52, 0x41, 0x2a, 0x6c, 0x22, 0x22, 0x63, 0xa6, 0x29,
0x60, 0x34, 0x22, 0x28, 0xcc, 0x15, 0x11, 0x14, 0x4f, 0x6a, 0xc1, 0x92, 0x31, 0x62, 0x49, 0x12,
0x23, 0xaa, 0xbf, 0x0e, 0xd5, 0x10, 0x02, 0x6a, 0xa1, 0x59, 0xb9, 0x87, 0xef, 0x98, 0xdf, 0x44,
0x1f, 0x05, 0x71, 0x11, 0xdb, 0xaa, 0x73, 0x12, 0x5a, 0x62, 0x21, 0x91, 0xfa, 0x8f, 0x0a, 0x94,
0x38, 0xe6, 0xcb, 0x50, 0xe5, 0x46, 0x87, 0xc6, 0x8c, 0x0c, 0x3b, 0xf0, 0x2e, 0x12, 0x34, 0xbe,
0x3e, 0xab, 0x73, 0x0e, 0xca, 0x31, 0x7b, 0xb3, 0xc0, 0xdd, 0x82, 0xff, 0x29, 0x64, 0x64, 0xc8,
0x27, 0x62, 0x5f, 0xd0, 0x19, 0x28, 0x0e, 0xec, 0xbe, 0x38, 0x19, 0x62, 0x0d, 0xf5, 0x2b, 0x85,
0x16, 0xf2, 0x35, 0xdc, 0xb3, 0x0f, 0xb1, 0x73, 0x3c, 0x7f, 0x05, 0xf4, 0x61, 0x48, 0xcc, 0x33,
0x26, 0x5f, 0x62, 0x00, 0x7a, 0x18, 0x30, 0x21, 0x2f, 0xab, 0x91, 0x84, 0xed, 0x0e, 0x17, 0xd2,
0x80, 0x19, 0x7f, 0xa4, 0xd0, 0x5a, 0x6e, 0x74, 0x29, 0xb3, 0x46, 0x3b, 0xaf, 0x25, 0x91, 0x51,
0xbf, 0x56, 0xa0, 0x1d, 0x14, 0x61, 0xdc, 0xd5, 0xe3, 0x79, 0x4f, 0x4a, 0x5e, 0x4f, 0x7e, 0xf5,
0xcb, 0xa2, 0x94, 0x4f, 0x94, 0x36, 0x53, 0x66, 0xe4, 0x17, 0xf2, 0x2d, 0x5a, 0xcf, 0x4d, 0x2e,
0x68, 0x1e, 0x91, 0x69, 0x43, 0x59, 0x14, 0x10, 0x58, 0x39, 0x5f, 0xb4, 0x89, 0x86, 0x9d, 0x7b,
0x8a, 0xbd, 0x27, 0xd1, 0x22, 0xcc, 0xdb, 0xde, 0xc0, 0xf0, 0x11, 0xc3, 0x3e, 0x3f, 0x62, 0x28,
0xc4, 0x8e, 0x18, 0x78, 0xbf, 0x3a, 0xa4, 0x22, 0x90, 0x58, 0xc0, 0x9b, 0xda, 0xb0, 0xdf, 0x55,
0xa0, 0xc5, 0x67, 0xa1, 0x73, 0x92, 0x94, 0x68, 0x80, 0x3d, 0x6c, 0x7c, 0xd3, 0xa5, 0x82, 0xff,
0x51, 0xa0, 0x19, 0xf6, 0xba, 0xd4, 0x71, 0x7e, 0x0c, 0x45, 0x5a, 0x69, 0xe1, 0x14, 0x4c, 0x35,
0x0d, 0x0c, 0x9a, 0x98, 0x6d, 0x1a, 0x6a, 0xef, 0x88, 0x00, 0x81, 0x37, 0x03, 0xd7, 0x9f, 0x3f,
0xb9, 0xeb, 0xe7, 0xa1, 0x90, 0x3d, 0x26, 0x78, 0xd9, 0x09, 0x70, 0xd0, 0x81, 0x3e, 0x81, 0x12,
0xbb, 0xb0, 0xc1, 0x8f, 0xdd, 0x6e, 0x44, 0x51, 0xf3, 0xcb, 0x1c, 0xa1, 0x8a, 0x39, 0xed, 0xd0,
0xf8, 0x20, 0xf5, 0x57, 0x61, 0x39, 0xc8, 0x46, 0xd9, 0xb4, 0xb3, 0x0a, 0xad, 0xfa, 0x6f, 0x0a,
0x9c, 0xde, 0x3e, 0xb6, 0x7a, 0x71, 0xf1, 0x5f, 0x86, 0xd2, 0x68, 0xa0, 0x07, 0xb5, 0x5a, 0xde,
0xa2, 0x61, 0x20, 0x9b, 0x1b, 0x1b, 0xc4, 0x87, 0xb0, 0x3d, 0xab, 0x8a, 0xbe, 0x1d, 0x7b, 0xaa,
0x6b, 0xbf, 0x21, 0xd2, 0x67, 0x6c, 0x30, 0x6f, 0xc5, 0xca, 0x50, 0x75, 0xd1, 0x4b, 0xbd, 0xd5,
0x27, 0x00, 0xd4, 0xa1, 0x77, 0x4f, 0xe2, 0xc4, 0xe9, 0x88, 0x67, 0xc4, 0x64, 0xff, 0x22, 0x07,
0xad, 0xd0, 0x2e, 0x7d, 0xd3, 0xf1, 0x4d, 0x4a, 0x56, 0x96, 0x7f, 0x4d, 0x59, 0x59, 0x61, 0xfe,
0x98, 0xa6, 0x28, 0x8b, 0x69, 0x7e, 0x2b, 0x0f, 0x8d, 0x60, 0xd7, 0xb6, 0x06, 0xba, 0x95, 0x2a,
0x09, 0xdb, 0x22, 0x9e, 0x8f, 0xee, 0xd3, 0xfb, 0x32, 0x3d, 0x49, 0x61, 0x84, 0x16, 0x43, 0x81,
0x2e, 0x52, 0xa6, 0x3b, 0x1e, 0x2b, 0x7c, 0xf1, 0x1c, 0x82, 0x29, 0xa4, 0x39, 0xc4, 0xe8, 0x36,
0x20, 0xae, 0x45, 0x5d, 0xd3, 0xea, 0xba, 0xb8, 0x67, 0x5b, 0x06, 0xd3, 0xaf, 0xa2, 0xd6, 0xe4,
0x5f, 0x3a, 0xd6, 0x36, 0xeb, 0x47, 0x1f, 0x43, 0xc1, 0x3b, 0x1e, 0xb1, 0x68, 0xa5, 0x21, 0xf5,
0xf7, 0x01, 0x5d, 0x3b, 0xc7, 0x23, 0xac, 0x51, 0x70, 0xff, 0xfa, 0x8e, 0xe7, 0xe8, 0x87, 0x3c,
0xf4, 0x2b, 0x68, 0xa1, 0x1e, 0x62, 0x31, 0xfc, 0x3d, 0x5c, 0x60, 0x21, 0x12, 0x6f, 0x32, 0xc9,
0xf6, 0x95, 0xb6, 0xeb, 0x79, 0x03, 0x5a, 0xba, 0xa3, 0x92, 0xed, 0xf7, 0xee, 0x78, 0x03, 0xb2,
0x48, 0xcf, 0xf6, 0xf4, 0x01, 0xd3, 0x8f, 0x0a, 0xb7, 0x0e, 0xa4, 0x87, 0x26, 0x26, 0xff, 0x9a,
0x83, 0x66, 0x40, 0x98, 0x86, 0xdd, 0xf1, 0x20, 0x5d, 0x1f, 0x27, 0x97, 0x4e, 0xa6, 0xa9, 0xe2,
0x77, 0xa1, 0xca, 0xa5, 0xe2, 0x04, 0x52, 0x05, 0x6c, 0xc8, 0xb3, 0x09, 0x62, 0x5e, 0x7c, 0x4d,
0x62, 0x5e, 0x9a, 0xa1, 0xf8, 0x20, 0xe7, 0x8d, 0xfa, 0x53, 0x05, 0xde, 0x49, 0x58, 0xcd, 0x89,
0x5b, 0x3b, 0x39, 0xf5, 0xe3, 0xd6, 0x34, 0x8e, 0x92, 0xdb, 0xff, 0x87, 0x50, 0x72, 0x28, 0x76,
0x7e, 0x46, 0x75, 0x6d, 0xa2, 0xf0, 0x31, 0x42, 0x34, 0x3e, 0x44, 0xfd, 0x63, 0x05, 0xce, 0x26,
0x49, 0x9d, 0xc3, 0xa9, 0xaf, 0xc2, 0x02, 0x43, 0xed, 0xeb, 0xe8, 0xca, 0x64, 0x1d, 0x0d, 0x36,
0x47, 0xf3, 0x07, 0xaa, 0xdb, 0xb0, 0xec, 0xfb, 0xfe, 0x60, 0xeb, 0x37, 0xb0, 0xa7, 0x4f, 0x48,
0x7c, 0x2e, 0x43, 0x95, 0x45, 0xd0, 0x2c, 0xa1, 0x60, 0x25, 0x03, 0xd8, 0x15, 0x95, 0x36, 0xf5,
0xbf, 0x14, 0x38, 0x43, 0x9d, 0x67, 0xfc, 0x68, 0x26, 0xcb, 0x81, 0xa1, 0x2a, 0x2a, 0x12, 0x9b,
0xfa, 0x90, 0xdf, 0x1d, 0xa9, 0x68, 0x91, 0x3e, 0xd4, 0x49, 0x16, 0xe2, 0xa4, 0x09, 0x72, 0x70,
0x42, 0x4a, 0x92, 0x71, 0x7a, 0x40, 0x1a, 0xaf, 0xc0, 0x05, 0x4e, 0xbb, 0x30, 0x8b, 0xd3, 0x7e,
0x06, 0xef, 0xc4, 0x56, 0x3a, 0x07, 0x47, 0xd5, 0xbf, 0x56, 0x08, 0x3b, 0x22, 0x77, 0x70, 0x66,
0x0f, 0x5c, 0x2f, 0x8a, 0x33, 0xa1, 0xae, 0x69, 0xc4, 0x8d, 0x88, 0x81, 0x3e, 0x85, 0x8a, 0x85,
0x8f, 0xba, 0xe1, 0x58, 0x28, 0x43, 0x54, 0x5f, 0xb6, 0xf0, 0x11, 0xfd, 0xa5, 0x6e, 0xc2, 0xd9,
0x04, 0xa9, 0xf3, 0xac, 0xfd, 0x1f, 0x14, 0x38, 0xb7, 0xee, 0xd8, 0xa3, 0xcf, 0x4d, 0xc7, 0x1b,
0xeb, 0x83, 0xe8, 0xd9, 0xf3, 0x9b, 0xa9, 0x6c, 0x7d, 0x16, 0x8a, 0x8a, 0x99, 0xfc, 0xdc, 0x96,
0x68, 0x50, 0x92, 0x28, 0xbe, 0xe8, 0x50, 0x0c, 0xfd, 0x9f, 0x79, 0x19, 0xf1, 0x1c, 0x6e, 0x4a,
0x5c, 0x92, 0x25, 0xc1, 0x90, 0x16, 0xc2, 0xf3, 0xb3, 0x16, 0xc2, 0x53, 0xcc, 0x7b, 0xe1, 0x35,
0x99, 0xf7, 0x13, 0x57, 0x66, 0x3e, 0x83, 0xe8, 0x21, 0x05, 0xf5, 0xce, 0x33, 0x9d, 0x6e, 0xac,
0x02, 0x04, 0x05, 0x7b, 0x7e, 0x85, 0x32, 0x0b, 0x9a, 0xd0, 0x28, 0xc2, 0x2d, 0xe1, 0x4a, 0xb9,
0xa7, 0x0f, 0x95, 0x90, 0xbf, 0x0f, 0x6d, 0x99, 0x94, 0xce, 0x23, 0xf9, 0xbf, 0xc8, 0x01, 0x74,
0xc4, 0xad, 0xdb, 0xd9, 0x7c, 0xc1, 0x35, 0x08, 0x45, 0x23, 0x81, 0xbe, 0x87, 0xa5, 0xc8, 0x20,
0x2a, 0x21, 0x72, 0x52, 0x02, 0x93, 0xc8, 0x53, 0x0d, 0x8a, 0x27, 0xa4, 0x35, 0x4c, 0x28, 0xe2,
0xe6, 0xf7, 0x3c, 0x54, 0x1c, 0xfb, 0xa8, 0x4b, 0xd4, 0xcc, 0xf0, 0xaf, 0x15, 0x3b, 0xf6, 0x11,
0x51, 0x3e, 0x03, 0x9d, 0x85, 0x05, 0x4f, 0x77, 0x0f, 0x08, 0x7e, 0x56, 0x37, 0x2a, 0x91, 0x66,
0xc7, 0x40, 0x67, 0xa0, 0xb8, 0x67, 0x0e, 0x30, 0xbb, 0xad, 0x50, 0xd1, 0x58, 0x03, 0x7d, 0xcb,
0xbf, 0xff, 0x56, 0xce, 0x7c, 0xc5, 0x85, 0xc2, 0xab, 0x5f, 0x29, 0xb0, 0x18, 0xec, 0x1a, 0x35,
0x40, 0xc4, 0xa6, 0x51, 0x7b, 0xb6, 0x66, 0x1b, 0xcc, 0x54, 0x34, 0x52, 0x3c, 0x02, 0x1b, 0xc8,
0xac, 0x56, 0x30, 0x64, 0x52, 0x9a, 0x4c, 0xd6, 0x45, 0x16, 0x6d, 0x1a, 0xfe, 0x45, 0xf8, 0x92,
0x63, 0x1f, 0x75, 0x0c, 0xb1, 0x1b, 0xec, 0xce, 0x30, 0x4b, 0x0a, 0xc9, 0x6e, 0xac, 0xd1, 0x6b,
0xc3, 0xd7, 0xa0, 0x8e, 0x1d, 0xc7, 0x76, 0xba, 0x43, 0xec, 0xba, 0x7a, 0x1f, 0xf3, 0xf8, 0xbc,
0x46, 0x3b, 0x37, 0x58, 0x9f, 0xfa, 0xa7, 0x05, 0x68, 0x04, 0x4b, 0xf1, 0x8f, 0xc9, 0x4d, 0xc3,
0x3f, 0x26, 0x37, 0x09, 0xeb, 0xc0, 0x61, 0xa6, 0x50, 0x30, 0x77, 0x35, 0xd7, 0x52, 0xb4, 0x0a,
0xef, 0xed, 0x18, 0xc4, 0x2d, 0x13, 0x25, 0xb3, 0x6c, 0x03, 0x07, 0xcc, 0x05, 0xbf, 0x8b, 0xf3,
0x36, 0x22, 0x23, 0x85, 0x0c, 0x32, 0x52, 0xcc, 0x20, 0x23, 0x25, 0x89, 0x8c, 0x2c, 0x43, 0x69,
0x77, 0xdc, 0x3b, 0xc0, 0x1e, 0x8f, 0xd8, 0x78, 0x2b, 0x2a, 0x3b, 0xe5, 0x98, 0xec, 0x08, 0x11,
0xa9, 0x84, 0x45, 0xe4, 0x3c, 0x54, 0xd8, 0x79, 0x6d, 0xd7, 0x73, 0xe9, 0xe1, 0x53, 0x5e, 0x2b,
0xb3, 0x8e, 0x1d, 0x17, 0x3d, 0xf0, 0xc3, 0xb9, 0xaa, 0x4c, 0xd9, 0xa9, 0xd5, 0x89, 0x49, 0x89,
0x1f, 0xcc, 0xdd, 0x84, 0xc5, 0xd0, 0x76, 0x50, 0x1f, 0x51, 0xa3, 0xa4, 0x86, 0xa2, 0x7d, 0xea,
0x26, 0x6e, 0x40, 0x23, 0xd8, 0x12, 0x0a, 0x57, 0x67, 0x49, 0x96, 0xe8, 0xa5, 0x60, 0x42, 0x92,
0x1b, 0x27, 0x93, 0x64, 0x74, 0x0e, 0xca, 0x3c, 0x3b, 0x72, 0x5b, 0x8b, 0x91, 0x62, 0x85, 0xfa,
0x23, 0x40, 0x01, 0xf5, 0xf3, 0x45, 0x8b, 0x31, 0xf1, 0xc8, 0xc5, 0xc5, 0x43, 0xfd, 0x99, 0x02,
0x4b, 0xe1, 0xc9, 0x66, 0x75, 0xbc, 0x9f, 0x42, 0x95, 0x1d, 0xff, 0x75, 0x89, 0xe2, 0xf3, 0x22,
0xd0, 0xc5, 0x89, 0x7c, 0xd1, 0x20, 0x78, 0x75, 0x40, 0xc4, 0xeb, 0xc8, 0x76, 0x0e, 0x4c, 0xab,
0xdf, 0x25, 0x94, 0xf9, 0xea, 0x56, 0xe3, 0x9d, 0x9b, 0xa4, 0x4f, 0xfd, 0x52, 0x81, 0x4b, 0xcf,
0x47, 0x86, 0xee, 0xe1, 0x50, 0x04, 0x32, 0xef, 0x6d, 0xbf, 0x8f, 0xfd, 0xeb, 0x76, 0xb9, 0x6c,
0x47, 0x58, 0x0c, 0x5a, 0xfd, 0x5b, 0x41, 0x4b, 0xe2, 0x8a, 0xec, 0xec, 0xb4, 0xb4, 0xa1, 0x7c,
0xc8, 0xd1, 0xf9, 0xaf, 0x28, 0xfc, 0x76, 0xe4, 0x98, 0x34, 0x7f, 0xf2, 0x63, 0x52, 0x75, 0x03,
0xce, 0x69, 0xd8, 0xc5, 0x96, 0x11, 0x59, 0xcd, 0xcc, 0xc5, 0xa6, 0x11, 0xb4, 0x65, 0xe8, 0xe6,
0x11, 0x56, 0x16, 0xbb, 0x76, 0x1d, 0x82, 0xd6, 0xe3, 0xa6, 0x98, 0x84, 0x4c, 0x74, 0x1e, 0x4f,
0xfd, 0x9b, 0x1c, 0x9c, 0x7d, 0x64, 0x18, 0xdc, 0x8a, 0xf3, 0x68, 0xec, 0x4d, 0x05, 0xca, 0xf1,
0x40, 0x32, 0x9f, 0x0c, 0x24, 0x5f, 0x97, 0x65, 0xe5, 0x3e, 0xc6, 0x1a, 0x0f, 0x7d, 0xdf, 0xe9,
0xb0, 0xfb, 0x43, 0x0f, 0xf9, 0xb9, 0x19, 0x49, 0xe8, 0xa9, 0xff, 0x9c, 0x1e, 0x5f, 0x95, 0xfd,
0xa2, 0x99, 0x3a, 0x82, 0x56, 0x72, 0xb3, 0xe6, 0x34, 0x25, 0xfe, 0x8e, 0x8c, 0x6c, 0x56, 0x60,
0xad, 0x91, 0x10, 0x8a, 0x76, 0x6d, 0xd9, 0xae, 0xfa, 0xdf, 0x39, 0x68, 0x6d, 0xeb, 0x87, 0xf8,
0xff, 0x0f, 0x83, 0x7e, 0x00, 0x67, 0x5c, 0xfd, 0x10, 0x77, 0x43, 0x89, 0x71, 0xd7, 0xc1, 0x2f,
0x79, 0x08, 0xfa, 0x9e, 0xcc, 0x92, 0x48, 0xaf, 0xd9, 0x68, 0x4b, 0x6e, 0xa4, 0x5f, 0xc3, 0x2f,
0xd1, 0xbb, 0xb0, 0x18, 0xbe, 0xc7, 0x45, 0x48, 0x2b, 0xd3, 0x2d, 0xaf, 0x87, 0xae, 0x69, 0x75,
0x0c, 0xf5, 0x25, 0x5c, 0x78, 0x6e, 0xb9, 0xd8, 0xeb, 0x04, 0x57, 0x8d, 0xe6, 0x4c, 0x21, 0x2f,
0x43, 0x35, 0xd8, 0xf8, 0xc4, 0xcb, 0x09, 0xc3, 0x55, 0x6d, 0x68, 0x6f, 0xe8, 0xce, 0x81, 0x5f,
0x66, 0x5e, 0x67, 0x57, 0x42, 0xde, 0xe0, 0x84, 0x7b, 0xe2, 0x86, 0x94, 0x86, 0xf7, 0xb0, 0x83,
0xad, 0x1e, 0x7e, 0x66, 0xf7, 0x0e, 0x48, 0xb8, 0xe1, 0xb1, 0x67, 0x6c, 0x4a, 0x28, 0xe8, 0x5c,
0x0f, 0xbd, 0x52, 0xcb, 0x45, 0x5e, 0xa9, 0x4d, 0x79, 0xd9, 0xa8, 0xfe, 0x3c, 0x07, 0xcb, 0x8f,
0x06, 0x1e, 0x76, 0x82, 0xcc, 0xff, 0x24, 0x45, 0x8c, 0xa0, 0xaa, 0x90, 0x9b, 0xa1, 0xaa, 0x90,
0xb8, 0x3e, 0x9e, 0x4f, 0x5e, 0x1f, 0x97, 0xd5, 0x40, 0x0a, 0x33, 0xd6, 0x40, 0x1e, 0x01, 0x8c,
0x1c, 0x7b, 0x84, 0x1d, 0xcf, 0xc4, 0x7e, 0xfa, 0x96, 0x21, 0x7c, 0x09, 0x0d, 0xba, 0xf5, 0xa9,
0xb8, 0xe5, 0xb9, 0x73, 0x3c, 0xc2, 0x68, 0x01, 0xf2, 0x9b, 0xf8, 0xa8, 0x79, 0x0a, 0x01, 0x94,
0x36, 0x6d, 0x67, 0xa8, 0x0f, 0x9a, 0x0a, 0xaa, 0xc2, 0x02, 0x3f, 0xd4, 0x6a, 0xe6, 0x50, 0x1d,
0x2a, 0x6b, 0xfe, 0xc1, 0x40, 0x33, 0x7f, 0xeb, 0xcf, 0x15, 0x58, 0x4a, 0x1c, 0xbb, 0xa0, 0x06,
0xc0, 0x73, 0xab, 0xc7, 0xcf, 0xa3, 0x9a, 0xa7, 0x50, 0x0d, 0xca, 0xfe, 0xe9, 0x14, 0xc3, 0xb7,
0x63, 0x53, 0xe8, 0x66, 0x0e, 0x35, 0xa1, 0xc6, 0x06, 0x8e, 0x7b, 0x3d, 0xec, 0xba, 0xcd, 0xbc,
0xe8, 0x79, 0xa2, 0x9b, 0x83, 0xb1, 0x83, 0x9b, 0x05, 0x32, 0xe7, 0x8e, 0xad, 0xe1, 0x01, 0xd6,
0x5d, 0xdc, 0x2c, 0x22, 0x04, 0x0d, 0xde, 0xf0, 0x07, 0x95, 0x42, 0x7d, 0xfe, 0xb0, 0x85, 0x5b,
0x2f, 0xc2, 0xc5, 0x73, 0xba, 0xbc, 0xb3, 0x70, 0xfa, 0xb9, 0x65, 0xe0, 0x3d, 0xd3, 0xc2, 0x46,
0xf0, 0xa9, 0x79, 0x0a, 0x9d, 0x86, 0xc5, 0x0d, 0xec, 0xf4, 0x71, 0xa8, 0x33, 0x87, 0x96, 0xa0,
0xbe, 0x61, 0xbe, 0x0a, 0x75, 0xe5, 0xd5, 0x42, 0x59, 0x69, 0x2a, 0xf7, 0xff, 0xe2, 0x2a, 0x54,
0x08, 0x53, 0xd6, 0x6c, 0xdb, 0x31, 0xd0, 0x00, 0x10, 0x7d, 0x50, 0x31, 0x1c, 0xd9, 0x96, 0x78,
0x81, 0x85, 0xee, 0x44, 0xf9, 0xc0, 0x1b, 0x49, 0x40, 0x2e, 0x9d, 0xed, 0xeb, 0x52, 0xf8, 0x18,
0xb0, 0x7a, 0x0a, 0x0d, 0xe9, 0x6c, 0x3b, 0xe6, 0x10, 0xef, 0x98, 0xbd, 0x03, 0x3f, 0xb2, 0xb8,
0x97, 0x12, 0x47, 0x24, 0x41, 0xfd, 0xf9, 0xae, 0x49, 0xe7, 0x63, 0x2f, 0x5e, 0x7c, 0x2f, 0xa3,
0x9e, 0x42, 0x2f, 0xe1, 0xcc, 0x53, 0x1c, 0x0a, 0xd2, 0xfc, 0x09, 0xef, 0xa7, 0x4f, 0x98, 0x00,
0x3e, 0xe1, 0x94, 0xcf, 0xa0, 0x48, 0xc5, 0x0d, 0xc9, 0xe2, 0xb8, 0xf0, 0x63, 0xe9, 0xf6, 0x95,
0x74, 0x00, 0x81, 0xed, 0x47, 0xb0, 0x18, 0x7b, 0x62, 0x89, 0x64, 0x56, 0x5d, 0xfe, 0x58, 0xb6,
0x7d, 0x2b, 0x0b, 0xa8, 0x98, 0xab, 0x0f, 0x8d, 0xe8, 0x43, 0x0c, 0xb4, 0x92, 0xe1, 0x4d, 0x17,
0x9b, 0xe9, 0xbd, 0xcc, 0xaf, 0xbf, 0xa8, 0x10, 0x34, 0xe3, 0x4f, 0xfe, 0xd0, 0xad, 0x89, 0x08,
0xa2, 0xc2, 0xf6, 0x7e, 0x26, 0x58, 0x31, 0xdd, 0x31, 0x15, 0x82, 0xc4, 0x53, 0xab, 0xb8, 0x8c,
0xfb, 0x68, 0xd2, 0xde, 0x80, 0xb5, 0xef, 0x66, 0x86, 0x17, 0x53, 0xff, 0x36, 0xbb, 0xb5, 0x22,
0x7b, 0xae, 0x84, 0x3e, 0x94, 0xa3, 0x9b, 0xf0, 0xce, 0xaa, 0x7d, 0xff, 0x24, 0x43, 0x04, 0x11,
0x3f, 0xa1, 0xd7, 0x4d, 0x24, 0x0f, 0x7e, 0xe2, 0x7a, 0xe7, 0xe3, 0x4b, 0x7f, 0xcb, 0xd4, 0xfe,
0xf0, 0x04, 0x23, 0x04, 0x01, 0x76, 0xfc, 0x4d, 0xa5, 0xaf, 0x86, 0x77, 0xa7, 0x4a, 0xcd, 0x6c,
0x3a, 0xf8, 0x43, 0x58, 0x8c, 0xc5, 0x39, 0x28, 0x7b, 0x2c, 0xd4, 0x9e, 0x14, 0x8c, 0x32, 0x95,
0x8c, 0xdd, 0xde, 0x41, 0x29, 0xd2, 0x2f, 0xb9, 0xe1, 0xd3, 0xbe, 0x95, 0x05, 0x54, 0x2c, 0xc4,
0xa5, 0xe6, 0x32, 0x76, 0x27, 0x03, 0xdd, 0x96, 0xe3, 0x90, 0xdf, 0x3d, 0x69, 0x7f, 0x90, 0x11,
0x5a, 0x4c, 0x7a, 0x08, 0xa7, 0x25, 0x57, 0x67, 0xd0, 0x07, 0x13, 0x99, 0x15, 0xbf, 0x33, 0xd4,
0xbe, 0x93, 0x15, 0x5c, 0xcc, 0xfb, 0x1b, 0x80, 0xb6, 0xf7, 0xed, 0xa3, 0x35, 0xdb, 0xda, 0x33,
0xfb, 0x63, 0x47, 0x67, 0x51, 0x42, 0x9a, 0x6f, 0x48, 0x82, 0xa6, 0xc8, 0xe8, 0xc4, 0x11, 0x62,
0xf2, 0x2e, 0xc0, 0x53, 0xec, 0x6d, 0x60, 0xcf, 0x21, 0x8a, 0xf1, 0x6e, 0x9a, 0xfb, 0xe3, 0x00,
0xfe, 0x54, 0x37, 0xa7, 0xc2, 0x85, 0x5c, 0x51, 0x73, 0x43, 0xb7, 0xc6, 0xfa, 0x20, 0x74, 0xf7,
0xff, 0xb6, 0x74, 0x78, 0x1c, 0x2c, 0x85, 0x91, 0xa9, 0xd0, 0x62, 0xca, 0x23, 0xe1, 0xda, 0x43,
0x47, 0x71, 0x93, 0x5d, 0x7b, 0xf2, 0x1a, 0x48, 0xdc, 0xec, 0x4d, 0x80, 0x17, 0x13, 0x7f, 0xa1,
0xd0, 0xdb, 0x57, 0x31, 0x80, 0x17, 0xa6, 0xb7, 0xbf, 0x35, 0xd0, 0x2d, 0x37, 0x0b, 0x09, 0x14,
0xf0, 0x04, 0x24, 0x70, 0x78, 0x41, 0x82, 0x01, 0xf5, 0xc8, 0x09, 0x19, 0x92, 0x5d, 0x96, 0x97,
0x9d, 0x16, 0xb6, 0x57, 0xa6, 0x03, 0x8a, 0x59, 0xf6, 0xa1, 0xee, 0xab, 0x12, 0xdb, 0xdc, 0xf7,
0xd2, 0x28, 0x0d, 0x60, 0x52, 0x2c, 0x81, 0x1c, 0x34, 0x6c, 0x09, 0x92, 0x07, 0x00, 0x28, 0xdb,
0xc1, 0xd1, 0x24, 0x4b, 0x90, 0x7e, 0xaa, 0xc0, 0x4c, 0x5d, 0xec, 0xb0, 0x4d, 0x6e, 0x47, 0xa5,
0x67, 0x87, 0x52, 0x53, 0x97, 0x72, 0x76, 0xa7, 0x9e, 0x42, 0x2f, 0xa0, 0xc4, 0xff, 0x21, 0xe4,
0xfa, 0xe4, 0xa2, 0x1d, 0xc7, 0x7e, 0x63, 0x0a, 0x94, 0x40, 0x7c, 0x00, 0x67, 0x53, 0x4a, 0x76,
0x52, 0x17, 0x3c, 0xb9, 0xbc, 0x37, 0xcd, 0x39, 0x88, 0xc9, 0x12, 0x35, 0xb9, 0x09, 0x93, 0xa5,
0xd5, 0xef, 0xa6, 0x4d, 0xd6, 0x85, 0xa5, 0x44, 0xb9, 0x03, 0xbd, 0x9f, 0xe2, 0xe8, 0x64, 0x45,
0x91, 0x69, 0x13, 0xf4, 0xe1, 0x1d, 0x69, 0x6a, 0x2f, 0x75, 0xdc, 0x93, 0x8a, 0x00, 0xd3, 0x26,
0xea, 0xc1, 0x69, 0x49, 0x42, 0x2f, 0x75, 0x39, 0xe9, 0x89, 0xff, 0xb4, 0x49, 0xf6, 0xa0, 0xbd,
0xea, 0xd8, 0xba, 0xd1, 0xd3, 0x5d, 0x8f, 0x26, 0xd9, 0x24, 0x8b, 0xf2, 0x23, 0x27, 0x79, 0x58,
0x2d, 0x4d, 0xc5, 0xa7, 0xcd, 0xb3, 0x0b, 0x55, 0xca, 0x4a, 0xf6, 0xdf, 0x0d, 0x48, 0xee, 0x23,
0x42, 0x10, 0x29, 0x86, 0x47, 0x06, 0x28, 0x84, 0x7a, 0x07, 0xaa, 0x6b, 0xf4, 0x2c, 0xa2, 0x63,
0x19, 0xf8, 0x55, 0xdc, 0x5f, 0xd1, 0x67, 0xab, 0x77, 0x42, 0x00, 0x99, 0x77, 0xa8, 0x4e, 0x03,
0x5a, 0x03, 0xbf, 0x62, 0x7c, 0x5e, 0x91, 0xe1, 0x8d, 0x80, 0xa4, 0x24, 0x00, 0x52, 0xc8, 0x90,
0xa7, 0x3f, 0x13, 0x0e, 0xf3, 0xc4, 0x74, 0x77, 0x53, 0x90, 0x24, 0x20, 0xfd, 0x59, 0xef, 0x65,
0x1f, 0x10, 0xf6, 0x0c, 0x3e, 0x5d, 0x1d, 0x7a, 0x10, 0x72, 0x73, 0x12, 0xe9, 0xe1, 0xd8, 0x6d,
0x65, 0x3a, 0xa0, 0x98, 0x65, 0x0b, 0x2a, 0x44, 0x3a, 0x19, 0x7b, 0xae, 0xcb, 0x06, 0x8a, 0xcf,
0xd9, 0x99, 0xb3, 0x8e, 0xdd, 0x9e, 0x63, 0xee, 0x72, 0xa6, 0x4b, 0xc9, 0x89, 0x80, 0x4c, 0x64,
0x4e, 0x0c, 0x52, 0x50, 0xfe, 0x9b, 0x34, 0x5a, 0xa7, 0xbd, 0xab, 0x63, 0x73, 0x60, 0x6c, 0x39,
0x76, 0x9f, 0x3e, 0x19, 0xb9, 0x37, 0x69, 0xf9, 0x11, 0xd0, 0xd4, 0x48, 0x6c, 0xc2, 0x08, 0x7f,
0xfe, 0xfb, 0x5f, 0x55, 0xa0, 0xec, 0x3f, 0x62, 0xf9, 0x86, 0xab, 0x13, 0x6f, 0xa1, 0x5c, 0xf0,
0x43, 0x58, 0x8c, 0x3d, 0x28, 0x97, 0x5a, 0x22, 0xf9, 0xa3, 0xf3, 0x69, 0x22, 0xf3, 0x82, 0xff,
0x07, 0x9a, 0xc8, 0x1c, 0x6e, 0xa6, 0x95, 0x1c, 0xe2, 0x49, 0xc3, 0x14, 0xc4, 0xff, 0xb7, 0x43,
0xf5, 0x4d, 0x80, 0x50, 0x90, 0x3e, 0xf9, 0xaa, 0x27, 0x89, 0x3b, 0xa7, 0xed, 0xd6, 0x50, 0x1a,
0x87, 0xbf, 0x97, 0xe5, 0xda, 0x5c, 0x7a, 0x24, 0x95, 0x1e, 0x7d, 0x3f, 0x87, 0x5a, 0xf8, 0x12,
0x36, 0x92, 0xfe, 0xe3, 0x56, 0xf2, 0x96, 0xf6, 0xb4, 0x55, 0x6c, 0x9c, 0x30, 0x40, 0x9b, 0x82,
0xce, 0x05, 0x94, 0x3c, 0xbe, 0x93, 0x06, 0xb4, 0xa9, 0x87, 0x86, 0xd2, 0x80, 0x36, 0xfd, 0x4c,
0x90, 0x55, 0x9e, 0xe2, 0x67, 0x52, 0xd2, 0xca, 0x53, 0xca, 0x29, 0x9f, 0xb4, 0xf2, 0x94, 0x76,
0xc8, 0xa5, 0x9e, 0x5a, 0xfd, 0xe8, 0x07, 0x1f, 0xf6, 0x4d, 0x6f, 0x7f, 0xbc, 0x4b, 0x56, 0x7f,
0x97, 0x0d, 0xfd, 0xc0, 0xb4, 0xf9, 0xaf, 0xbb, 0xbe, 0xb8, 0xdf, 0xa5, 0xd8, 0xee, 0x12, 0x6c,
0xa3, 0xdd, 0xdd, 0x12, 0x6d, 0x7d, 0xf4, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb0, 0x82, 0x83,
0x41, 0xd8, 0x51, 0x00, 0x00,
// 4664 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7c, 0x4b, 0x8c, 0x1c, 0x49,
0x5a, 0xb0, 0xb3, 0x5e, 0x5d, 0xf5, 0xd5, 0xa3, 0xab, 0xc3, 0x9e, 0x76, 0xb9, 0x66, 0xfc, 0x4a,
0xdb, 0xe3, 0x1e, 0x8f, 0xc7, 0xf6, 0x78, 0xfe, 0xd1, 0xfa, 0x5f, 0xef, 0xcc, 0xe2, 0xee, 0x76,
0x7b, 0x0a, 0xdc, 0xbd, 0xbd, 0xd9, 0xed, 0x31, 0x9a, 0x45, 0x2a, 0x65, 0x57, 0x46, 0x57, 0xe7,
0x76, 0x55, 0x66, 0x39, 0x33, 0xab, 0xdb, 0xbd, 0x48, 0xec, 0x00, 0x12, 0xd2, 0x20, 0x04, 0x08,
0x09, 0x01, 0x37, 0xc4, 0x69, 0x59, 0xb4, 0x08, 0x69, 0xc5, 0x85, 0x0b, 0xd7, 0x11, 0x1c, 0x56,
0x08, 0x89, 0x23, 0x47, 0xe0, 0x8e, 0xc4, 0x89, 0x03, 0x8a, 0x47, 0x46, 0xbe, 0x22, 0xab, 0xb2,
0xab, 0xec, 0xb1, 0x04, 0xb7, 0x8a, 0x2f, 0xbf, 0xf8, 0xe2, 0x8b, 0x88, 0xef, 0x1d, 0x11, 0x05,
0x4d, 0x43, 0xf7, 0xf4, 0x6e, 0xcf, 0xb6, 0x1d, 0xe3, 0xce, 0xc8, 0xb1, 0x3d, 0x1b, 0x2d, 0x0d,
0xcd, 0xc1, 0xd1, 0xd8, 0x65, 0xad, 0x3b, 0xe4, 0x73, 0xbb, 0xd6, 0xb3, 0x87, 0x43, 0xdb, 0x62,
0xa0, 0x76, 0xc3, 0xb4, 0x3c, 0xec, 0x58, 0xfa, 0x80, 0xb7, 0x6b, 0xe1, 0x0e, 0xed, 0x9a, 0xdb,
0x3b, 0xc0, 0x43, 0x9d, 0xb7, 0x96, 0x4c, 0xcb, 0xc0, 0x2f, 0xc3, 0xf4, 0xd5, 0x05, 0x28, 0x3e,
0x1e, 0x8e, 0xbc, 0x13, 0xf5, 0x4f, 0x15, 0xa8, 0x6d, 0x0c, 0xc6, 0xee, 0x81, 0x86, 0x5f, 0x8c,
0xb1, 0xeb, 0xa1, 0x7b, 0x50, 0xd8, 0xd3, 0x5d, 0xdc, 0x52, 0xae, 0x28, 0x2b, 0xd5, 0xfb, 0xef,
0xdc, 0x89, 0x30, 0xc2, 0x59, 0xd8, 0x74, 0xfb, 0xab, 0xba, 0x8b, 0x35, 0x8a, 0x89, 0x10, 0x14,
0x8c, 0xbd, 0xce, 0x7a, 0x2b, 0x77, 0x45, 0x59, 0xc9, 0x6b, 0xf4, 0x37, 0xba, 0x04, 0xe0, 0xe2,
0xfe, 0x10, 0x5b, 0x5e, 0x67, 0xdd, 0x6d, 0xe5, 0xaf, 0xe4, 0x57, 0xf2, 0x5a, 0x08, 0x82, 0x54,
0xa8, 0xf5, 0xec, 0xc1, 0x00, 0xf7, 0x3c, 0xd3, 0xb6, 0x3a, 0xeb, 0xad, 0x02, 0xed, 0x1b, 0x81,
0xa9, 0xff, 0xa6, 0x40, 0x9d, 0xb3, 0xe6, 0x8e, 0x6c, 0xcb, 0xc5, 0xe8, 0x23, 0x28, 0xb9, 0x9e,
0xee, 0x8d, 0x5d, 0xce, 0xdd, 0xdb, 0x52, 0xee, 0x76, 0x28, 0x8a, 0xc6, 0x51, 0xa5, 0xec, 0xc5,
0x87, 0xcf, 0x27, 0x87, 0x8f, 0x4d, 0xa1, 0x90, 0x98, 0xc2, 0x0a, 0x2c, 0xee, 0x13, 0xee, 0x76,
0x02, 0xa4, 0x22, 0x45, 0x8a, 0x83, 0x09, 0x25, 0xcf, 0x1c, 0xe2, 0xef, 0xed, 0xef, 0x60, 0x7d,
0xd0, 0x2a, 0xd1, 0xb1, 0x42, 0x10, 0xf5, 0x9f, 0x14, 0x68, 0x0a, 0x74, 0x7f, 0x1f, 0xce, 0x41,
0xb1, 0x67, 0x8f, 0x2d, 0x8f, 0x4e, 0xb5, 0xae, 0xb1, 0x06, 0xba, 0x0a, 0xb5, 0xde, 0x81, 0x6e,
0x59, 0x78, 0xd0, 0xb5, 0xf4, 0x21, 0xa6, 0x93, 0xaa, 0x68, 0x55, 0x0e, 0xdb, 0xd2, 0x87, 0x38,
0xd3, 0xdc, 0xae, 0x40, 0x75, 0xa4, 0x3b, 0x9e, 0x19, 0x59, 0xfd, 0x30, 0x08, 0xb5, 0xa1, 0x6c,
0xba, 0x9d, 0xe1, 0xc8, 0x76, 0xbc, 0x56, 0xf1, 0x8a, 0xb2, 0x52, 0xd6, 0x44, 0x9b, 0x8c, 0x60,
0xd2, 0x5f, 0xbb, 0xba, 0x7b, 0xd8, 0x59, 0xe7, 0x33, 0x8a, 0xc0, 0xd4, 0x3f, 0x57, 0x60, 0xf9,
0x91, 0xeb, 0x9a, 0x7d, 0x2b, 0x31, 0xb3, 0x65, 0x28, 0x59, 0xb6, 0x81, 0x3b, 0xeb, 0x74, 0x6a,
0x79, 0x8d, 0xb7, 0xd0, 0xdb, 0x50, 0x19, 0x61, 0xec, 0x74, 0x1d, 0x7b, 0xe0, 0x4f, 0xac, 0x4c,
0x00, 0x9a, 0x3d, 0xc0, 0xe8, 0xfb, 0xb0, 0xe4, 0xc6, 0x08, 0x31, 0xb9, 0xaa, 0xde, 0xbf, 0x76,
0x27, 0xa1, 0x2c, 0x77, 0xe2, 0x83, 0x6a, 0xc9, 0xde, 0xea, 0x97, 0x39, 0x38, 0x2b, 0xf0, 0x18,
0xaf, 0xe4, 0x37, 0x59, 0x79, 0x17, 0xf7, 0x05, 0x7b, 0xac, 0x91, 0x65, 0xe5, 0xc5, 0x96, 0xe5,
0xc3, 0x5b, 0x96, 0x41, 0xd4, 0xe3, 0xfb, 0x51, 0x4c, 0xee, 0xc7, 0x65, 0xa8, 0xe2, 0x97, 0x23,
0xd3, 0xc1, 0x5d, 0x22, 0x38, 0x74, 0xc9, 0x0b, 0x1a, 0x30, 0xd0, 0xae, 0x39, 0x0c, 0xeb, 0xc6,
0x42, 0x66, 0xdd, 0x50, 0xff, 0x42, 0x81, 0xf3, 0x89, 0x5d, 0xe2, 0xca, 0xa6, 0x41, 0x93, 0xce,
0x3c, 0x58, 0x19, 0xa2, 0x76, 0x64, 0xc1, 0xdf, 0x9d, 0xb4, 0xe0, 0x01, 0xba, 0x96, 0xe8, 0x1f,
0x62, 0x32, 0x97, 0x9d, 0xc9, 0x43, 0x38, 0xff, 0x04, 0x7b, 0x7c, 0x00, 0xf2, 0x0d, 0xbb, 0xb3,
0x1b, 0xab, 0xa8, 0x56, 0xe7, 0xe2, 0x5a, 0xad, 0xfe, 0x4d, 0x4e, 0xe8, 0x22, 0x1d, 0xaa, 0x63,
0xed, 0xdb, 0xe8, 0x1d, 0xa8, 0x08, 0x14, 0x2e, 0x15, 0x01, 0x00, 0x7d, 0x0b, 0x8a, 0x84, 0x53,
0x26, 0x12, 0x8d, 0xfb, 0x57, 0xe5, 0x73, 0x0a, 0xd1, 0xd4, 0x18, 0x3e, 0xea, 0x40, 0xc3, 0xf5,
0x74, 0xc7, 0xeb, 0x8e, 0x6c, 0x97, 0xee, 0x33, 0x15, 0x9c, 0xea, 0x7d, 0x35, 0x4a, 0x41, 0x58,
0xfa, 0x4d, 0xb7, 0xbf, 0xcd, 0x31, 0xb5, 0x3a, 0xed, 0xe9, 0x37, 0xd1, 0x63, 0xa8, 0x61, 0xcb,
0x08, 0x08, 0x15, 0x32, 0x13, 0xaa, 0x62, 0xcb, 0x10, 0x64, 0x82, 0xfd, 0x29, 0x66, 0xdf, 0x9f,
0xdf, 0x53, 0xa0, 0x95, 0xdc, 0xa0, 0x79, 0x4c, 0xf6, 0x43, 0xd6, 0x09, 0xb3, 0x0d, 0x9a, 0xa8,
0xe1, 0x62, 0x93, 0x34, 0xde, 0x45, 0xfd, 0x63, 0x05, 0xde, 0x0a, 0xd8, 0xa1, 0x9f, 0x5e, 0x97,
0xb4, 0xa0, 0x5b, 0xd0, 0x34, 0xad, 0xde, 0x60, 0x6c, 0xe0, 0x67, 0xd6, 0x67, 0x58, 0x1f, 0x78,
0x07, 0x27, 0x74, 0x0f, 0xcb, 0x5a, 0x02, 0xae, 0xfe, 0x6b, 0x0e, 0x96, 0xe3, 0x7c, 0xcd, 0xb3,
0x48, 0xff, 0x0f, 0x8a, 0xa6, 0xb5, 0x6f, 0xfb, 0x6b, 0x74, 0x69, 0x82, 0x52, 0x92, 0xb1, 0x18,
0x32, 0xb2, 0x01, 0xf9, 0x66, 0xac, 0x77, 0x80, 0x7b, 0x87, 0x23, 0xdb, 0xa4, 0x06, 0x8b, 0x90,
0xf8, 0x25, 0x09, 0x09, 0x39, 0xc7, 0x77, 0xd6, 0x18, 0x8d, 0x35, 0x41, 0xe2, 0xb1, 0xe5, 0x39,
0x27, 0xda, 0x52, 0x2f, 0x0e, 0x6f, 0x1f, 0xc0, 0xb2, 0x1c, 0x19, 0x35, 0x21, 0x7f, 0x88, 0x4f,
0xe8, 0x94, 0x2b, 0x1a, 0xf9, 0x89, 0x1e, 0x40, 0xf1, 0x48, 0x1f, 0x8c, 0x31, 0xb7, 0x0e, 0x59,
0xc4, 0x97, 0x75, 0xf8, 0x76, 0xee, 0x81, 0xa2, 0x0e, 0xe1, 0xed, 0x27, 0xd8, 0xeb, 0x58, 0x2e,
0x76, 0xbc, 0x55, 0xd3, 0x1a, 0xd8, 0xfd, 0x6d, 0xdd, 0x3b, 0x98, 0xc3, 0x56, 0x44, 0xd4, 0x3e,
0x17, 0x53, 0x7b, 0xf5, 0x27, 0x0a, 0xbc, 0x23, 0x1f, 0x8f, 0xef, 0x6a, 0x1b, 0xca, 0xfb, 0x26,
0x1e, 0x18, 0x44, 0x74, 0x14, 0x2a, 0x3a, 0xa2, 0x4d, 0x6c, 0xc6, 0x88, 0x20, 0xf3, 0xcd, 0xbb,
0x9a, 0x32, 0xd3, 0x1d, 0xcf, 0x31, 0xad, 0xfe, 0x53, 0xd3, 0xf5, 0x34, 0x86, 0x1f, 0x12, 0x95,
0x7c, 0x76, 0x0d, 0xfd, 0x5d, 0x05, 0x2e, 0x3d, 0xc1, 0xde, 0x9a, 0x70, 0x39, 0xe4, 0xbb, 0xe9,
0x7a, 0x66, 0xcf, 0x7d, 0xb5, 0x61, 0x5f, 0x86, 0xd8, 0x43, 0xfd, 0x03, 0x05, 0x2e, 0xa7, 0x32,
0xc3, 0x97, 0x8e, 0x9b, 0x54, 0xdf, 0xe1, 0xc8, 0x4d, 0xea, 0xaf, 0xe0, 0x93, 0xcf, 0xc9, 0xe6,
0x6f, 0xeb, 0xa6, 0xc3, 0x4c, 0xea, 0x8c, 0x0e, 0xe6, 0x67, 0x0a, 0x5c, 0x7c, 0x82, 0xbd, 0x6d,
0xdf, 0xdd, 0xbe, 0xc1, 0xd5, 0x21, 0x38, 0x21, 0xb7, 0xef, 0xc7, 0x9d, 0x11, 0x98, 0xfa, 0xfb,
0x6c, 0x3b, 0xa5, 0xfc, 0xbe, 0x91, 0x05, 0xbc, 0x44, 0x35, 0x21, 0x64, 0x27, 0xb8, 0xc6, 0xf3,
0xe5, 0x53, 0xbf, 0x2a, 0x42, 0xed, 0x73, 0x6e, 0x1a, 0xa8, 0x43, 0x8d, 0xaf, 0x84, 0x22, 0x8f,
0x89, 0x42, 0xc1, 0x95, 0x2c, 0xde, 0x7a, 0x02, 0x75, 0x17, 0xe3, 0xc3, 0x59, 0xdc, 0x67, 0x8d,
0x74, 0x14, 0x6e, 0xef, 0x29, 0x2c, 0x8d, 0x2d, 0x1a, 0xb5, 0x63, 0x83, 0xcf, 0x82, 0xad, 0xfc,
0x74, 0xb3, 0x9a, 0xec, 0x88, 0x3e, 0xe3, 0x89, 0x41, 0x88, 0x56, 0x31, 0x13, 0xad, 0x78, 0x37,
0xd4, 0x81, 0xa6, 0xe1, 0xd8, 0xa3, 0x11, 0x36, 0xba, 0xae, 0x4f, 0xaa, 0x94, 0x8d, 0x14, 0xef,
0x27, 0x48, 0xdd, 0x83, 0xb3, 0x71, 0x4e, 0x3b, 0x06, 0x89, 0x15, 0x89, 0x78, 0xc9, 0x3e, 0xa1,
0xdb, 0xb0, 0x94, 0xc4, 0x2f, 0x53, 0xfc, 0xe4, 0x07, 0xf4, 0x01, 0xa0, 0x18, 0xab, 0x04, 0xbd,
0xc2, 0xd0, 0xa3, 0xcc, 0x70, 0x74, 0x9a, 0x94, 0x46, 0xd1, 0x81, 0xa1, 0xf3, 0x2f, 0x21, 0xf4,
0x0e, 0xf1, 0xb3, 0x11, 0x74, 0xb7, 0x55, 0xcd, 0xb6, 0x10, 0x51, 0x62, 0xae, 0xfa, 0x95, 0x02,
0xcb, 0xcf, 0x75, 0xaf, 0x77, 0xb0, 0x3e, 0xe4, 0x52, 0x3a, 0x87, 0x96, 0x7f, 0x02, 0x95, 0x23,
0x2e, 0x91, 0xbe, 0x29, 0xbf, 0x2c, 0x61, 0x28, 0x2c, 0xfb, 0x5a, 0xd0, 0x83, 0x24, 0x49, 0xe7,
0x36, 0x42, 0xc9, 0xe2, 0x1b, 0xb0, 0x37, 0x53, 0xb2, 0x5c, 0xf5, 0x25, 0x00, 0x67, 0x6e, 0xd3,
0xed, 0xcf, 0xc0, 0xd7, 0x03, 0x58, 0xe0, 0xd4, 0xb8, 0x41, 0x99, 0xb6, 0x61, 0x3e, 0xba, 0xfa,
0xd3, 0x12, 0x54, 0x43, 0x1f, 0x50, 0x03, 0x72, 0xc2, 0x52, 0xe4, 0x24, 0xb3, 0xcb, 0x4d, 0xcf,
0xab, 0xf2, 0xc9, 0xbc, 0xea, 0x06, 0x34, 0x4c, 0xea, 0xc1, 0xbb, 0x7c, 0x57, 0x68, 0xe8, 0x5c,
0xd1, 0xea, 0x0c, 0xca, 0x45, 0x04, 0x5d, 0x82, 0xaa, 0x35, 0x1e, 0x76, 0xed, 0xfd, 0xae, 0x63,
0x1f, 0xbb, 0x3c, 0x41, 0xab, 0x58, 0xe3, 0xe1, 0xf7, 0xf6, 0x35, 0xfb, 0xd8, 0x0d, 0x72, 0x80,
0xd2, 0x29, 0x73, 0x80, 0x4b, 0x50, 0x1d, 0xea, 0x2f, 0x09, 0xd5, 0xae, 0x35, 0x1e, 0xd2, 0xdc,
0x2d, 0xaf, 0x55, 0x86, 0xfa, 0x4b, 0xcd, 0x3e, 0xde, 0x1a, 0x0f, 0xd1, 0x0a, 0x34, 0x07, 0xba,
0xeb, 0x75, 0xc3, 0xc9, 0x5f, 0x99, 0x26, 0x7f, 0x0d, 0x02, 0x7f, 0x1c, 0x24, 0x80, 0xc9, 0x6c,
0xa2, 0x32, 0x47, 0x36, 0x61, 0x0c, 0x07, 0x01, 0x21, 0xc8, 0x9e, 0x4d, 0x18, 0xc3, 0x81, 0x20,
0xf3, 0x00, 0x16, 0xf6, 0x68, 0x5c, 0x34, 0x49, 0x59, 0x37, 0x48, 0x48, 0xc4, 0xc2, 0x27, 0xcd,
0x47, 0x47, 0xdf, 0x81, 0x0a, 0x75, 0x47, 0xb4, 0x6f, 0x2d, 0x53, 0xdf, 0xa0, 0x03, 0xe9, 0x6d,
0xe0, 0x81, 0xa7, 0xd3, 0xde, 0xf5, 0x6c, 0xbd, 0x45, 0x07, 0x62, 0x29, 0x7b, 0x0e, 0xd6, 0x3d,
0x6c, 0xac, 0x9e, 0xac, 0xd9, 0xc3, 0x91, 0x4e, 0x85, 0xa9, 0xd5, 0xa0, 0x61, 0xbd, 0xec, 0x13,
0x7a, 0x17, 0x1a, 0x3d, 0xd1, 0xda, 0x70, 0xec, 0x61, 0x6b, 0x91, 0xea, 0x51, 0x0c, 0x8a, 0x2e,
0x02, 0xf8, 0x36, 0x52, 0xf7, 0x5a, 0x4d, 0xba, 0x8b, 0x15, 0x0e, 0x79, 0x44, 0x6b, 0x3b, 0xa6,
0xdb, 0x65, 0x55, 0x14, 0xd3, 0xea, 0xb7, 0x96, 0xe8, 0x88, 0x55, 0xbf, 0xec, 0x62, 0x5a, 0x7d,
0x74, 0x1e, 0x16, 0x4c, 0xb7, 0xbb, 0xaf, 0x1f, 0xe2, 0x16, 0xa2, 0x5f, 0x4b, 0xa6, 0xbb, 0xa1,
0x1f, 0x62, 0xf5, 0xc7, 0x70, 0x2e, 0x90, 0xae, 0xd0, 0x4e, 0x26, 0x85, 0x42, 0x99, 0x55, 0x28,
0x26, 0x47, 0xc3, 0xbf, 0x28, 0xc0, 0xf2, 0x8e, 0x7e, 0x84, 0x5f, 0x7f, 0xe0, 0x9d, 0xc9, 0xac,
0x3d, 0x85, 0x25, 0x1a, 0x6b, 0xdf, 0x0f, 0xf1, 0x33, 0xc1, 0xa3, 0x87, 0x45, 0x21, 0xd9, 0x11,
0x7d, 0x97, 0x84, 0x22, 0xb8, 0x77, 0xb8, 0x4d, 0x92, 0x17, 0xdf, 0x9b, 0x5f, 0x94, 0xd0, 0x59,
0x13, 0x58, 0x5a, 0xb8, 0x07, 0xda, 0x86, 0xc5, 0xe8, 0x36, 0xf8, 0x7e, 0xfc, 0xe6, 0xc4, 0xcc,
0x36, 0x58, 0x7d, 0xad, 0x11, 0xd9, 0x0c, 0x17, 0xb5, 0x60, 0x81, 0x3b, 0x61, 0x6a, 0x33, 0xca,
0x9a, 0xdf, 0x44, 0xdb, 0x70, 0x96, 0xcd, 0x60, 0x87, 0x2b, 0x04, 0x9b, 0x7c, 0x39, 0xd3, 0xe4,
0x65, 0x5d, 0xa3, 0xfa, 0x54, 0x39, 0xad, 0x3e, 0xb5, 0x60, 0x81, 0xcb, 0x38, 0xb5, 0x23, 0x65,
0xcd, 0x6f, 0x92, 0x6d, 0x0e, 0xa4, 0xbd, 0x4a, 0xbf, 0x05, 0x00, 0x92, 0xb4, 0x40, 0xb0, 0x9e,
0x53, 0x6a, 0x30, 0x9f, 0x42, 0x59, 0x48, 0x78, 0xf6, 0xe4, 0x51, 0xf4, 0x89, 0xdb, 0xf7, 0x7c,
0xcc, 0xbe, 0xab, 0xff, 0xa8, 0x40, 0x6d, 0x9d, 0x4c, 0xe9, 0xa9, 0xdd, 0xa7, 0xde, 0xe8, 0x06,
0x34, 0x1c, 0xdc, 0xb3, 0x1d, 0xa3, 0x8b, 0x2d, 0xcf, 0x31, 0x31, 0x4b, 0xdd, 0x0b, 0x5a, 0x9d,
0x41, 0x1f, 0x33, 0x20, 0x41, 0x23, 0x26, 0xdb, 0xf5, 0xf4, 0xe1, 0xa8, 0xbb, 0x4f, 0x4c, 0x43,
0x8e, 0xa1, 0x09, 0x28, 0xb5, 0x0c, 0x57, 0xa1, 0x16, 0xa0, 0x79, 0x36, 0x1d, 0xbf, 0xa0, 0x55,
0x05, 0x6c, 0xd7, 0x46, 0xd7, 0xa1, 0x41, 0xd7, 0xb4, 0x3b, 0xb0, 0xfb, 0x5d, 0x92, 0x0b, 0x72,
0x47, 0x55, 0x33, 0x38, 0x5b, 0x64, 0xaf, 0xa2, 0x58, 0xae, 0xf9, 0x23, 0xcc, 0x5d, 0x95, 0xc0,
0xda, 0x31, 0x7f, 0x84, 0xd5, 0x7f, 0x50, 0xa0, 0xbe, 0xae, 0x7b, 0xfa, 0x96, 0x6d, 0xe0, 0xdd,
0x19, 0x1d, 0x7b, 0x86, 0x7a, 0xe8, 0x3b, 0x50, 0x11, 0x33, 0xe0, 0x53, 0x0a, 0x00, 0x68, 0x03,
0x1a, 0x7e, 0x2c, 0xd7, 0x65, 0xb9, 0x4a, 0x21, 0x35, 0x80, 0x0a, 0x79, 0x4e, 0x57, 0xab, 0xfb,
0xdd, 0x68, 0x53, 0xdd, 0x80, 0x5a, 0xf8, 0x33, 0x19, 0x75, 0x27, 0x2e, 0x28, 0x02, 0x40, 0xa4,
0x71, 0x6b, 0x3c, 0x24, 0x7b, 0xca, 0x0d, 0x8b, 0xdf, 0x54, 0x7f, 0x5b, 0x81, 0x3a, 0x77, 0xf7,
0x3b, 0xe2, 0xe4, 0x80, 0x4e, 0x8d, 0x55, 0x28, 0xe8, 0x6f, 0xf4, 0xed, 0x68, 0xb1, 0xef, 0xba,
0xd4, 0x08, 0x50, 0x22, 0x34, 0xc8, 0x8c, 0xf8, 0xfa, 0x2c, 0xd9, 0xf1, 0x97, 0x44, 0xd0, 0xf8,
0xd6, 0x50, 0x41, 0x6b, 0xc1, 0x82, 0x6e, 0x18, 0x0e, 0x76, 0x5d, 0xce, 0x87, 0xdf, 0x24, 0x5f,
0x8e, 0xb0, 0xe3, 0xfa, 0x22, 0x9f, 0xd7, 0xfc, 0x26, 0xfa, 0x0e, 0x94, 0x45, 0x54, 0xca, 0x4a,
0x3b, 0x57, 0xd2, 0xf9, 0xe4, 0xb9, 0x9c, 0xe8, 0xa1, 0xfe, 0x6d, 0x0e, 0x1a, 0x7c, 0xc1, 0x56,
0xb9, 0x3f, 0x9e, 0xac, 0x7c, 0xab, 0x50, 0xdb, 0x0f, 0x74, 0x7f, 0x52, 0x41, 0x2a, 0x6c, 0x22,
0x22, 0x7d, 0xa6, 0x29, 0x60, 0x34, 0x22, 0x28, 0xcc, 0x15, 0x11, 0x14, 0x4f, 0x6b, 0xc1, 0x92,
0x31, 0x62, 0x49, 0x12, 0x23, 0xaa, 0xbf, 0x06, 0xd5, 0x10, 0x01, 0x6a, 0xa1, 0x59, 0xb9, 0x87,
0xaf, 0x98, 0xdf, 0x44, 0x1f, 0x05, 0x71, 0x11, 0x5b, 0xaa, 0x0b, 0x12, 0x5e, 0x62, 0x21, 0x91,
0xfa, 0xf7, 0x0a, 0x94, 0x38, 0xe5, 0xcb, 0x50, 0xe5, 0x46, 0x87, 0xc6, 0x8c, 0x8c, 0x3a, 0x70,
0x10, 0x09, 0x1a, 0x5f, 0x9d, 0xd5, 0xb9, 0x00, 0xe5, 0x98, 0xbd, 0x59, 0xe0, 0x6e, 0xc1, 0xff,
0x14, 0x32, 0x32, 0xe4, 0x13, 0xb1, 0x2f, 0xe8, 0x1c, 0x14, 0x07, 0x76, 0x5f, 0x9c, 0x0c, 0xb1,
0x86, 0xfa, 0xb5, 0x42, 0x0b, 0xf9, 0x1a, 0xee, 0xd9, 0x47, 0xd8, 0x39, 0x99, 0xbf, 0x02, 0xfa,
0x30, 0x24, 0xe6, 0x19, 0x93, 0x2f, 0xd1, 0x01, 0x3d, 0x0c, 0x36, 0x21, 0x2f, 0xab, 0x91, 0x84,
0xed, 0x0e, 0x17, 0xd2, 0x60, 0x33, 0xfe, 0x50, 0xa1, 0xb5, 0xdc, 0xe8, 0x54, 0x66, 0x8d, 0x76,
0x5e, 0x49, 0x22, 0xa3, 0xfe, 0x42, 0x81, 0x76, 0x50, 0x84, 0x71, 0x57, 0x4f, 0xe6, 0x3d, 0x29,
0x79, 0x35, 0xf9, 0xd5, 0xff, 0x17, 0xa5, 0x7c, 0xa2, 0xb4, 0x99, 0x32, 0x23, 0xbf, 0x90, 0x6f,
0xd1, 0x7a, 0x6e, 0x72, 0x42, 0xf3, 0x88, 0x4c, 0x1b, 0xca, 0xa2, 0x80, 0xc0, 0xca, 0xf9, 0xa2,
0x4d, 0x34, 0xec, 0xc2, 0x13, 0xec, 0x6d, 0x44, 0x8b, 0x30, 0x6f, 0x7a, 0x01, 0xc3, 0x47, 0x0c,
0x07, 0xfc, 0x88, 0xa1, 0x10, 0x3b, 0x62, 0xe0, 0x70, 0x75, 0x48, 0x45, 0x20, 0x31, 0x81, 0xd7,
0xb5, 0x60, 0xbf, 0xa3, 0x40, 0x8b, 0x8f, 0x42, 0xc7, 0x24, 0x29, 0xd1, 0x00, 0x7b, 0xd8, 0xf8,
0xa6, 0x4b, 0x05, 0xff, 0xad, 0x40, 0x33, 0xec, 0x75, 0xa9, 0xe3, 0xfc, 0x18, 0x8a, 0xb4, 0xd2,
0xc2, 0x39, 0x98, 0x6a, 0x1a, 0x18, 0x36, 0x31, 0xdb, 0x34, 0xd4, 0xde, 0x15, 0x01, 0x02, 0x6f,
0x06, 0xae, 0x3f, 0x7f, 0x7a, 0xd7, 0xcf, 0x43, 0x21, 0x7b, 0x4c, 0xe8, 0xb2, 0x13, 0xe0, 0x00,
0x80, 0x3e, 0x81, 0x12, 0xbb, 0xb0, 0xc1, 0x8f, 0xdd, 0x6e, 0x44, 0x49, 0xf3, 0xcb, 0x1c, 0xa1,
0x8a, 0x39, 0x05, 0x68, 0xbc, 0x93, 0xfa, 0xcb, 0xb0, 0x1c, 0x64, 0xa3, 0x6c, 0xd8, 0x59, 0x85,
0x56, 0xfd, 0x17, 0x05, 0xce, 0xee, 0x9c, 0x58, 0xbd, 0xb8, 0xf8, 0x2f, 0x43, 0x69, 0x34, 0xd0,
0x83, 0x5a, 0x2d, 0x6f, 0xd1, 0x30, 0x90, 0x8d, 0x8d, 0x0d, 0xe2, 0x43, 0xd8, 0x9a, 0x55, 0x05,
0x6c, 0xd7, 0x9e, 0xea, 0xda, 0x6f, 0x88, 0xf4, 0x19, 0x1b, 0xcc, 0x5b, 0xb1, 0x32, 0x54, 0x5d,
0x40, 0xa9, 0xb7, 0xfa, 0x04, 0x80, 0x3a, 0xf4, 0xee, 0x69, 0x9c, 0x38, 0xed, 0xf1, 0x94, 0x98,
0xec, 0x9f, 0xe7, 0xa0, 0x15, 0x5a, 0xa5, 0x6f, 0x3a, 0xbe, 0x49, 0xc9, 0xca, 0xf2, 0xaf, 0x28,
0x2b, 0x2b, 0xcc, 0x1f, 0xd3, 0x14, 0x65, 0x31, 0xcd, 0x6f, 0xe6, 0xa1, 0x11, 0xac, 0xda, 0xf6,
0x40, 0xb7, 0x52, 0x25, 0x61, 0x47, 0xc4, 0xf3, 0xd1, 0x75, 0x7a, 0x5f, 0xa6, 0x27, 0x29, 0x1b,
0xa1, 0xc5, 0x48, 0xa0, 0x8b, 0x74, 0xd3, 0x1d, 0x8f, 0x15, 0xbe, 0x78, 0x0e, 0xc1, 0x14, 0xd2,
0x1c, 0x62, 0x74, 0x1b, 0x10, 0xd7, 0xa2, 0xae, 0x69, 0x75, 0x5d, 0xdc, 0xb3, 0x2d, 0x83, 0xe9,
0x57, 0x51, 0x6b, 0xf2, 0x2f, 0x1d, 0x6b, 0x87, 0xc1, 0xd1, 0xc7, 0x50, 0xf0, 0x4e, 0x46, 0x2c,
0x5a, 0x69, 0x48, 0xfd, 0x7d, 0xc0, 0xd7, 0xee, 0xc9, 0x08, 0x6b, 0x14, 0xdd, 0xbf, 0xbe, 0xe3,
0x39, 0xfa, 0x11, 0x0f, 0xfd, 0x0a, 0x5a, 0x08, 0x42, 0x2c, 0x86, 0xbf, 0x86, 0x0b, 0x2c, 0x44,
0xe2, 0x4d, 0x26, 0xd9, 0xbe, 0xd2, 0x76, 0x3d, 0x6f, 0x40, 0x4b, 0x77, 0x54, 0xb2, 0x7d, 0xe8,
0xae, 0x37, 0x20, 0x93, 0xf4, 0x6c, 0x4f, 0x1f, 0x30, 0xfd, 0xa8, 0x70, 0xeb, 0x40, 0x20, 0x34,
0x31, 0xf9, 0xe7, 0x1c, 0x34, 0x03, 0xc6, 0x34, 0xec, 0x8e, 0x07, 0xe9, 0xfa, 0x38, 0xb9, 0x74,
0x32, 0x4d, 0x15, 0xbf, 0x0b, 0x55, 0x2e, 0x15, 0xa7, 0x90, 0x2a, 0x60, 0x5d, 0x9e, 0x4e, 0x10,
0xf3, 0xe2, 0x2b, 0x12, 0xf3, 0xd2, 0x0c, 0xc5, 0x07, 0xf9, 0xde, 0xa8, 0x3f, 0x51, 0xe0, 0xad,
0x84, 0xd5, 0x9c, 0xb8, 0xb4, 0x93, 0x53, 0x3f, 0x6e, 0x4d, 0xe3, 0x24, 0xb9, 0xfd, 0x7f, 0x08,
0x25, 0x87, 0x52, 0xe7, 0x67, 0x54, 0xd7, 0x26, 0x0a, 0x1f, 0x63, 0x44, 0xe3, 0x5d, 0xd4, 0x3f,
0x52, 0xe0, 0x7c, 0x92, 0xd5, 0x39, 0x9c, 0xfa, 0x2a, 0x2c, 0x30, 0xd2, 0xbe, 0x8e, 0xae, 0x4c,
0xd6, 0xd1, 0x60, 0x71, 0x34, 0xbf, 0xa3, 0xba, 0x03, 0xcb, 0xbe, 0xef, 0x0f, 0x96, 0x7e, 0x13,
0x7b, 0xfa, 0x84, 0xc4, 0xe7, 0x32, 0x54, 0x59, 0x04, 0xcd, 0x12, 0x0a, 0x56, 0x32, 0x80, 0x3d,
0x51, 0x69, 0x53, 0xff, 0x43, 0x81, 0x73, 0xd4, 0x79, 0xc6, 0x8f, 0x66, 0xb2, 0x1c, 0x18, 0xaa,
0xa2, 0x22, 0xb1, 0xa5, 0x0f, 0xf9, 0xdd, 0x91, 0x8a, 0x16, 0x81, 0xa1, 0x4e, 0xb2, 0x10, 0x27,
0x4d, 0x90, 0x83, 0x13, 0x52, 0x92, 0x8c, 0xd3, 0x03, 0xd2, 0x78, 0x05, 0x2e, 0x70, 0xda, 0x85,
0x59, 0x9c, 0xf6, 0x53, 0x78, 0x2b, 0x36, 0xd3, 0x39, 0x76, 0x54, 0xfd, 0x4b, 0x85, 0x6c, 0x47,
0xe4, 0x0e, 0xce, 0xec, 0x81, 0xeb, 0x45, 0x71, 0x26, 0xd4, 0x35, 0x8d, 0xb8, 0x11, 0x31, 0xd0,
0xa7, 0x50, 0xb1, 0xf0, 0x71, 0x37, 0x1c, 0x0b, 0x65, 0x88, 0xea, 0xcb, 0x16, 0x3e, 0xa6, 0xbf,
0xd4, 0x2d, 0x38, 0x9f, 0x60, 0x75, 0x9e, 0xb9, 0xff, 0x9d, 0x02, 0x17, 0xd6, 0x1d, 0x7b, 0xf4,
0xb9, 0xe9, 0x78, 0x63, 0x7d, 0x10, 0x3d, 0x7b, 0x7e, 0x3d, 0x95, 0xad, 0xcf, 0x42, 0x51, 0x31,
0x93, 0x9f, 0xdb, 0x12, 0x0d, 0x4a, 0x32, 0xc5, 0x27, 0x1d, 0x8a, 0xa1, 0xff, 0x3d, 0x2f, 0x63,
0x9e, 0xe3, 0x4d, 0x89, 0x4b, 0xb2, 0x24, 0x18, 0xd2, 0x42, 0x78, 0x7e, 0xd6, 0x42, 0x78, 0x8a,
0x79, 0x2f, 0xbc, 0x22, 0xf3, 0x7e, 0xea, 0xca, 0xcc, 0x67, 0x10, 0x3d, 0xa4, 0xa0, 0xde, 0x79,
0xa6, 0xd3, 0x8d, 0x55, 0x80, 0xa0, 0x60, 0xcf, 0xaf, 0x50, 0x66, 0x21, 0x13, 0xea, 0x45, 0x76,
0x4b, 0xb8, 0x52, 0xee, 0xe9, 0x43, 0x25, 0xe4, 0xef, 0x43, 0x5b, 0x26, 0xa5, 0xf3, 0x48, 0xfe,
0xcf, 0x73, 0x00, 0x1d, 0x71, 0xeb, 0x76, 0x36, 0x5f, 0x70, 0x0d, 0x42, 0xd1, 0x48, 0xa0, 0xef,
0x61, 0x29, 0x32, 0x88, 0x4a, 0x88, 0x9c, 0x94, 0xe0, 0x24, 0xf2, 0x54, 0x83, 0xd2, 0x09, 0x69,
0x0d, 0x13, 0x8a, 0xb8, 0xf9, 0x7d, 0x1b, 0x2a, 0x8e, 0x7d, 0xdc, 0x25, 0x6a, 0x66, 0xf8, 0xd7,
0x8a, 0x1d, 0xfb, 0x98, 0x28, 0x9f, 0x81, 0xce, 0xc3, 0x82, 0xa7, 0xbb, 0x87, 0x84, 0x3e, 0xab,
0x1b, 0x95, 0x48, 0xb3, 0x63, 0xa0, 0x73, 0x50, 0xdc, 0x37, 0x07, 0x98, 0xdd, 0x56, 0xa8, 0x68,
0xac, 0x81, 0xbe, 0xe5, 0xdf, 0x7f, 0x2b, 0x67, 0xbe, 0xe2, 0x42, 0xf1, 0xd5, 0xaf, 0x15, 0x58,
0x0c, 0x56, 0x8d, 0x1a, 0x20, 0x62, 0xd3, 0xa8, 0x3d, 0x5b, 0xb3, 0x0d, 0x66, 0x2a, 0x1a, 0x29,
0x1e, 0x81, 0x75, 0x64, 0x56, 0x2b, 0xe8, 0x32, 0x29, 0x4d, 0x26, 0xf3, 0x22, 0x93, 0x36, 0x0d,
0xff, 0x22, 0x7c, 0xc9, 0xb1, 0x8f, 0x3b, 0x86, 0x58, 0x0d, 0x76, 0x67, 0x98, 0x25, 0x85, 0x64,
0x35, 0xd6, 0xe8, 0xb5, 0xe1, 0x6b, 0x50, 0xc7, 0x8e, 0x63, 0x3b, 0xdd, 0x21, 0x76, 0x5d, 0xbd,
0x8f, 0x79, 0x7c, 0x5e, 0xa3, 0xc0, 0x4d, 0x06, 0x53, 0xff, 0xa4, 0x00, 0x8d, 0x60, 0x2a, 0xfe,
0x31, 0xb9, 0x69, 0xf8, 0xc7, 0xe4, 0x26, 0xd9, 0x3a, 0x70, 0x98, 0x29, 0x14, 0x9b, 0xbb, 0x9a,
0x6b, 0x29, 0x5a, 0x85, 0x43, 0x3b, 0x06, 0x71, 0xcb, 0x44, 0xc9, 0x2c, 0xdb, 0xc0, 0xc1, 0xe6,
0x82, 0x0f, 0xe2, 0x7b, 0x1b, 0x91, 0x91, 0x42, 0x06, 0x19, 0x29, 0x66, 0x90, 0x91, 0x92, 0x44,
0x46, 0x96, 0xa1, 0xb4, 0x37, 0xee, 0x1d, 0x62, 0x8f, 0x47, 0x6c, 0xbc, 0x15, 0x95, 0x9d, 0x72,
0x4c, 0x76, 0x84, 0x88, 0x54, 0xc2, 0x22, 0xf2, 0x36, 0x54, 0xd8, 0x79, 0x6d, 0xd7, 0x73, 0xe9,
0xe1, 0x53, 0x5e, 0x2b, 0x33, 0xc0, 0xae, 0x8b, 0x1e, 0xf8, 0xe1, 0x5c, 0x55, 0xa6, 0xec, 0xd4,
0xea, 0xc4, 0xa4, 0xc4, 0x0f, 0xe6, 0x6e, 0xc2, 0x62, 0x68, 0x39, 0xa8, 0x8f, 0xa8, 0x51, 0x56,
0x43, 0xd1, 0x3e, 0x75, 0x13, 0x37, 0xa0, 0x11, 0x2c, 0x09, 0xc5, 0xab, 0xb3, 0x24, 0x4b, 0x40,
0x29, 0x9a, 0x90, 0xe4, 0xc6, 0xe9, 0x24, 0x19, 0x5d, 0x80, 0x32, 0xcf, 0x8e, 0xdc, 0xd6, 0x62,
0xa4, 0x58, 0xa1, 0xfe, 0x10, 0x50, 0xc0, 0xfd, 0x7c, 0xd1, 0x62, 0x4c, 0x3c, 0x72, 0x71, 0xf1,
0x50, 0x7f, 0xaa, 0xc0, 0x52, 0x78, 0xb0, 0x59, 0x1d, 0xef, 0xa7, 0x50, 0x65, 0xc7, 0x7f, 0x5d,
0xa2, 0xf8, 0xbc, 0x08, 0x74, 0x71, 0xe2, 0xbe, 0x68, 0x10, 0xbc, 0x3a, 0x20, 0xe2, 0x75, 0x6c,
0x3b, 0x87, 0xa6, 0xd5, 0xef, 0x12, 0xce, 0x7c, 0x75, 0xab, 0x71, 0xe0, 0x16, 0x81, 0xa9, 0x5f,
0x29, 0x70, 0xe9, 0xd9, 0xc8, 0xd0, 0x3d, 0x1c, 0x8a, 0x40, 0xe6, 0xbd, 0xed, 0xf7, 0xb1, 0x7f,
0xdd, 0x2e, 0x97, 0xed, 0x08, 0x8b, 0x61, 0xab, 0x7f, 0x2d, 0x78, 0x49, 0x5c, 0x91, 0x9d, 0x9d,
0x97, 0x36, 0x94, 0x8f, 0x38, 0x39, 0xff, 0x15, 0x85, 0xdf, 0x8e, 0x1c, 0x93, 0xe6, 0x4f, 0x7f,
0x4c, 0xaa, 0x6e, 0xc2, 0x05, 0x0d, 0xbb, 0xd8, 0x32, 0x22, 0xb3, 0x99, 0xb9, 0xd8, 0x34, 0x82,
0xb6, 0x8c, 0xdc, 0x3c, 0xc2, 0xca, 0x62, 0xd7, 0xae, 0x43, 0xc8, 0x7a, 0xdc, 0x14, 0x93, 0x90,
0x89, 0x8e, 0xe3, 0xa9, 0x7f, 0x95, 0x83, 0xf3, 0x8f, 0x0c, 0x83, 0x5b, 0x71, 0x1e, 0x8d, 0xbd,
0xae, 0x40, 0x39, 0x1e, 0x48, 0xe6, 0x93, 0x81, 0xe4, 0xab, 0xb2, 0xac, 0xdc, 0xc7, 0x58, 0xe3,
0xa1, 0xef, 0x3b, 0x1d, 0x76, 0x7f, 0xe8, 0x21, 0x3f, 0x37, 0x23, 0x09, 0x3d, 0xf5, 0x9f, 0xd3,
0xe3, 0xab, 0xb2, 0x5f, 0x34, 0x53, 0x47, 0xd0, 0x4a, 0x2e, 0xd6, 0x9c, 0xa6, 0xc4, 0x5f, 0x91,
0x91, 0xcd, 0x0a, 0xac, 0x35, 0x12, 0x42, 0x51, 0xd0, 0xb6, 0xed, 0xaa, 0xff, 0x99, 0x83, 0xd6,
0x8e, 0x7e, 0x84, 0xff, 0xef, 0x6c, 0xd0, 0x17, 0x70, 0xce, 0xd5, 0x8f, 0x70, 0x37, 0x94, 0x18,
0x77, 0x1d, 0xfc, 0x82, 0x87, 0xa0, 0xef, 0xc9, 0x2c, 0x89, 0xf4, 0x9a, 0x8d, 0xb6, 0xe4, 0x46,
0xe0, 0x1a, 0x7e, 0x81, 0xde, 0x85, 0xc5, 0xf0, 0x3d, 0x2e, 0xc2, 0x5a, 0x99, 0x2e, 0x79, 0x3d,
0x74, 0x4d, 0xab, 0x63, 0xa8, 0x2f, 0xe0, 0x9d, 0x67, 0x96, 0x8b, 0xbd, 0x4e, 0x70, 0xd5, 0x68,
0xce, 0x14, 0xf2, 0x32, 0x54, 0x83, 0x85, 0x4f, 0xbc, 0x9c, 0x30, 0x5c, 0xd5, 0x86, 0xf6, 0xa6,
0xee, 0x1c, 0xfa, 0x65, 0xe6, 0x75, 0x76, 0x25, 0xe4, 0x35, 0x0e, 0xb8, 0x2f, 0x6e, 0x48, 0x69,
0x78, 0x1f, 0x3b, 0xd8, 0xea, 0xe1, 0xa7, 0x76, 0xef, 0x90, 0x84, 0x1b, 0x1e, 0x7b, 0xc6, 0xa6,
0x84, 0x82, 0xce, 0xf5, 0xd0, 0x2b, 0xb5, 0x5c, 0xe4, 0x95, 0xda, 0x94, 0x97, 0x8d, 0xea, 0xcf,
0x72, 0xb0, 0xfc, 0x68, 0xe0, 0x61, 0x27, 0xc8, 0xfc, 0x4f, 0x53, 0xc4, 0x08, 0xaa, 0x0a, 0xb9,
0x19, 0xaa, 0x0a, 0x89, 0xeb, 0xe3, 0xf9, 0xe4, 0xf5, 0x71, 0x59, 0x0d, 0xa4, 0x30, 0x63, 0x0d,
0xe4, 0x11, 0xc0, 0xc8, 0xb1, 0x47, 0xd8, 0xf1, 0x4c, 0xec, 0xa7, 0x6f, 0x19, 0xc2, 0x97, 0x50,
0x27, 0xf5, 0x0b, 0x68, 0x3e, 0xe9, 0xad, 0xd9, 0xd6, 0xbe, 0xe9, 0x0c, 0xfd, 0x85, 0x4a, 0x28,
0x9d, 0x92, 0x41, 0xe9, 0x72, 0x09, 0xa5, 0x53, 0x4d, 0x58, 0x0a, 0xd1, 0x9e, 0xd3, 0x70, 0xf5,
0x7b, 0xdd, 0x7d, 0xd3, 0x32, 0xe9, 0x95, 0xab, 0x1c, 0x0d, 0x3f, 0xa1, 0xdf, 0xdb, 0xe0, 0x90,
0x5b, 0x9f, 0x8a, 0xcb, 0xaa, 0xbb, 0x27, 0x23, 0x8c, 0x16, 0x20, 0xbf, 0x85, 0x8f, 0x9b, 0x67,
0x10, 0x40, 0x69, 0xcb, 0x76, 0x86, 0xfa, 0xa0, 0xa9, 0xa0, 0x2a, 0x2c, 0xf0, 0xb3, 0xb9, 0x66,
0x0e, 0xd5, 0xa1, 0xb2, 0xe6, 0x9f, 0x6f, 0x34, 0xf3, 0xb7, 0xfe, 0x4c, 0x81, 0xa5, 0xc4, 0xe9,
0x11, 0x6a, 0x00, 0x3c, 0xb3, 0x7a, 0xfc, 0x58, 0xad, 0x79, 0x06, 0xd5, 0xa0, 0xec, 0x1f, 0xb2,
0x31, 0x7a, 0xbb, 0x36, 0xc5, 0x6e, 0xe6, 0x50, 0x13, 0x6a, 0xac, 0xe3, 0xb8, 0xd7, 0xc3, 0xae,
0xdb, 0xcc, 0x0b, 0xc8, 0x86, 0x6e, 0x0e, 0xc6, 0x0e, 0x6e, 0x16, 0xc8, 0x98, 0xbb, 0xb6, 0x86,
0x07, 0x58, 0x77, 0x71, 0xb3, 0x88, 0x10, 0x34, 0x78, 0xc3, 0xef, 0x54, 0x0a, 0xc1, 0xfc, 0x6e,
0x0b, 0xb7, 0x9e, 0x87, 0xcf, 0x00, 0xe8, 0xf4, 0xce, 0xc3, 0xd9, 0x67, 0x96, 0x81, 0xf7, 0x4d,
0x0b, 0x1b, 0xc1, 0xa7, 0xe6, 0x19, 0x74, 0x16, 0x16, 0x37, 0xb1, 0xd3, 0xc7, 0x21, 0x60, 0x0e,
0x2d, 0x41, 0x7d, 0xd3, 0x7c, 0x19, 0x02, 0xe5, 0xd5, 0x42, 0x59, 0x69, 0x2a, 0xf7, 0xff, 0xeb,
0x2a, 0x54, 0x88, 0x6c, 0xad, 0xd9, 0xb6, 0x63, 0xa0, 0x01, 0x20, 0xfa, 0x2e, 0x64, 0x38, 0xb2,
0x2d, 0xf1, 0x90, 0x0c, 0xdd, 0x89, 0x6e, 0x0f, 0x6f, 0x24, 0x11, 0xb9, 0xec, 0xb4, 0xaf, 0x4b,
0xf1, 0x63, 0xc8, 0xea, 0x19, 0x34, 0xa4, 0xa3, 0xed, 0x9a, 0x43, 0xbc, 0x6b, 0xf6, 0x0e, 0xfd,
0x00, 0xe9, 0x5e, 0x4a, 0x38, 0x94, 0x44, 0xf5, 0xc7, 0xbb, 0x26, 0x1d, 0x8f, 0x3d, 0xdc, 0xf1,
0x65, 0x4e, 0x3d, 0x83, 0x5e, 0xc0, 0xb9, 0x27, 0x38, 0x14, 0x6b, 0xfa, 0x03, 0xde, 0x4f, 0x1f,
0x30, 0x81, 0x7c, 0xca, 0x21, 0x9f, 0x42, 0x91, 0x8a, 0x1b, 0x92, 0x85, 0xa3, 0xe1, 0x37, 0xdf,
0xed, 0x2b, 0xe9, 0x08, 0x82, 0xda, 0x0f, 0x61, 0x31, 0xf6, 0x52, 0x14, 0xc9, 0x9c, 0x93, 0xfc,
0xcd, 0x6f, 0xfb, 0x56, 0x16, 0x54, 0x31, 0x56, 0x1f, 0x1a, 0xd1, 0xf7, 0x24, 0x68, 0x25, 0xc3,
0xd3, 0x34, 0x36, 0xd2, 0x7b, 0x99, 0x1f, 0xb1, 0x51, 0x21, 0x68, 0xc6, 0x5f, 0x2e, 0xa2, 0x5b,
0x13, 0x09, 0x44, 0x85, 0xed, 0xfd, 0x4c, 0xb8, 0x62, 0xb8, 0x13, 0x2a, 0x04, 0x89, 0x17, 0x63,
0x71, 0x19, 0xf7, 0xc9, 0xa4, 0x3d, 0x65, 0x6b, 0xdf, 0xcd, 0x8c, 0x2f, 0x86, 0xfe, 0x2d, 0x76,
0xf9, 0x46, 0xf6, 0xea, 0x0a, 0x7d, 0x28, 0x27, 0x37, 0xe1, 0xb9, 0x58, 0xfb, 0xfe, 0x69, 0xba,
0x08, 0x26, 0x7e, 0x4c, 0x6f, 0xcd, 0x48, 0xde, 0x2d, 0xc5, 0xf5, 0xce, 0xa7, 0x97, 0xfe, 0x24,
0xab, 0xfd, 0xe1, 0x29, 0x7a, 0x08, 0x06, 0xec, 0xf8, 0xd3, 0x50, 0x5f, 0x0d, 0xef, 0x4e, 0x95,
0x9a, 0xd9, 0x74, 0xf0, 0x07, 0xb0, 0x18, 0x0b, 0xd7, 0x50, 0xf6, 0x90, 0xae, 0x3d, 0xc9, 0x35,
0x31, 0x95, 0x8c, 0x5d, 0x42, 0x42, 0x29, 0xd2, 0x2f, 0xb9, 0xa8, 0xd4, 0xbe, 0x95, 0x05, 0x55,
0x4c, 0xc4, 0xa5, 0xe6, 0x32, 0x76, 0xb5, 0x04, 0xdd, 0x96, 0xd3, 0x90, 0x5f, 0xa1, 0x69, 0x7f,
0x90, 0x11, 0x5b, 0x0c, 0x7a, 0x04, 0x67, 0x25, 0x37, 0x80, 0xd0, 0x07, 0x13, 0x37, 0x2b, 0x7e,
0xf5, 0xa9, 0x7d, 0x27, 0x2b, 0xba, 0x18, 0xf7, 0xd7, 0x01, 0xed, 0x1c, 0xd8, 0xc7, 0x34, 0x72,
0xe8, 0x8f, 0x1d, 0x9d, 0x05, 0x3b, 0x69, 0xbe, 0x21, 0x89, 0x9a, 0x22, 0xa3, 0x13, 0x7b, 0x88,
0xc1, 0xbb, 0x00, 0x4f, 0xb0, 0xb7, 0x89, 0x3d, 0x87, 0x28, 0xc6, 0xbb, 0x69, 0xee, 0x8f, 0x23,
0xf8, 0x43, 0xdd, 0x9c, 0x8a, 0x17, 0x72, 0x45, 0xcd, 0x4d, 0xdd, 0x1a, 0xeb, 0x83, 0xd0, 0x13,
0x86, 0xdb, 0xd2, 0xee, 0x71, 0xb4, 0x94, 0x8d, 0x4c, 0xc5, 0x16, 0x43, 0x1e, 0x0b, 0xd7, 0x1e,
0x3a, 0x51, 0x9c, 0xec, 0xda, 0x93, 0xb7, 0x59, 0xe2, 0x66, 0x6f, 0x02, 0xbe, 0x18, 0xf8, 0x4b,
0x85, 0x5e, 0x22, 0x8b, 0x21, 0x3c, 0x37, 0xbd, 0x83, 0xed, 0x81, 0x6e, 0xb9, 0x59, 0x58, 0xa0,
0x88, 0xa7, 0x60, 0x81, 0xe3, 0x0b, 0x16, 0x0c, 0xa8, 0x47, 0x0e, 0xfa, 0x90, 0xec, 0xce, 0xbf,
0xec, 0xd0, 0xb3, 0xbd, 0x32, 0x1d, 0x51, 0x8c, 0x72, 0x00, 0x75, 0x5f, 0x95, 0xd8, 0xe2, 0xbe,
0x97, 0xc6, 0x69, 0x80, 0x93, 0x62, 0x09, 0xe4, 0xa8, 0x61, 0x4b, 0x90, 0x3c, 0xc7, 0x40, 0xd9,
0xce, 0xbf, 0x26, 0x59, 0x82, 0xf4, 0xc3, 0x11, 0x66, 0xea, 0x62, 0x67, 0x86, 0x72, 0x3b, 0x2a,
0x3d, 0x02, 0x95, 0x9a, 0xba, 0x94, 0x23, 0x48, 0xf5, 0x0c, 0x7a, 0x0e, 0x25, 0xfe, 0x47, 0x27,
0xd7, 0x27, 0xd7, 0x1e, 0x39, 0xf5, 0x1b, 0x53, 0xb0, 0x04, 0xe1, 0x43, 0x38, 0x9f, 0x52, 0x79,
0x94, 0xba, 0xe0, 0xc9, 0x55, 0xca, 0x69, 0xce, 0x41, 0x0c, 0x96, 0x28, 0x2d, 0x4e, 0x18, 0x2c,
0xad, 0x0c, 0x39, 0x6d, 0xb0, 0x2e, 0x2c, 0x25, 0xaa, 0x36, 0xe8, 0xfd, 0x14, 0x47, 0x27, 0xab,
0xed, 0x4c, 0x1b, 0xa0, 0x0f, 0x6f, 0x49, 0x2b, 0x14, 0x52, 0xc7, 0x3d, 0xa9, 0x96, 0x31, 0x6d,
0xa0, 0x1e, 0x9c, 0x95, 0xd4, 0x25, 0xa4, 0x2e, 0x27, 0xbd, 0x7e, 0x31, 0x6d, 0x90, 0x7d, 0x68,
0xaf, 0x3a, 0xb6, 0x6e, 0xf4, 0x74, 0xd7, 0xa3, 0xb5, 0x02, 0x92, 0x45, 0xf9, 0x91, 0x93, 0x3c,
0xac, 0x96, 0x56, 0x14, 0xa6, 0x8d, 0xb3, 0x07, 0x55, 0xba, 0x95, 0xec, 0x2f, 0x28, 0x90, 0xdc,
0x47, 0x84, 0x30, 0x52, 0x0c, 0x8f, 0x0c, 0x51, 0x08, 0xf5, 0x2e, 0x54, 0xd7, 0xe8, 0x91, 0x4a,
0xc7, 0x32, 0xf0, 0xcb, 0xb8, 0xbf, 0xa2, 0xaf, 0x6f, 0xef, 0x84, 0x10, 0x32, 0xaf, 0x50, 0x9d,
0x06, 0xb4, 0x06, 0x7e, 0xc9, 0xf6, 0x79, 0x45, 0x46, 0x37, 0x82, 0x92, 0x92, 0x00, 0x48, 0x31,
0x43, 0x9e, 0xfe, 0x5c, 0x38, 0xcc, 0x13, 0xc3, 0xdd, 0x4d, 0x21, 0x92, 0xc0, 0xf4, 0x47, 0xbd,
0x97, 0xbd, 0x43, 0xd8, 0x33, 0xf8, 0x7c, 0x75, 0xe8, 0x79, 0xce, 0xcd, 0x49, 0xac, 0x87, 0x63,
0xb7, 0x95, 0xe9, 0x88, 0x62, 0x94, 0x6d, 0xa8, 0x10, 0xe9, 0x64, 0xdb, 0x73, 0x5d, 0xd6, 0x51,
0x7c, 0xce, 0xbe, 0x39, 0xeb, 0xd8, 0xed, 0x39, 0xe6, 0x1e, 0xdf, 0x74, 0x29, 0x3b, 0x11, 0x94,
0x89, 0x9b, 0x13, 0xc3, 0x14, 0x9c, 0xff, 0x06, 0x8d, 0xd6, 0x29, 0x74, 0x75, 0x6c, 0x0e, 0x8c,
0x6d, 0xc7, 0xee, 0xd3, 0x97, 0x2f, 0xf7, 0x26, 0x4d, 0x3f, 0x82, 0x9a, 0x1a, 0x89, 0x4d, 0xe8,
0x21, 0xc6, 0xff, 0x55, 0xa8, 0x88, 0xf2, 0x11, 0x92, 0xdd, 0xd8, 0x8a, 0x17, 0xae, 0xda, 0xd7,
0x27, 0x23, 0xf9, 0x94, 0xef, 0x7f, 0x5d, 0x81, 0xb2, 0xff, 0xca, 0xe7, 0x1b, 0xae, 0x7b, 0xbc,
0x81, 0x42, 0xc4, 0x0f, 0x60, 0x31, 0xf6, 0xe2, 0x5e, 0x6a, 0xe3, 0xe4, 0xaf, 0xf2, 0xa7, 0x09,
0xe3, 0x73, 0xfe, 0x27, 0x71, 0x22, 0x27, 0xb9, 0x99, 0x56, 0xcc, 0x88, 0xa7, 0x23, 0x53, 0x08,
0xff, 0xef, 0x4e, 0x02, 0xb6, 0x00, 0x42, 0xe1, 0xff, 0xe4, 0xbb, 0xb0, 0x24, 0xa2, 0x9d, 0xb6,
0x5a, 0x43, 0x69, 0x84, 0xff, 0x5e, 0x96, 0x7b, 0x85, 0xe9, 0x31, 0x5a, 0x7a, 0x5c, 0xff, 0x0c,
0x6a, 0xe1, 0x5b, 0xea, 0x48, 0xfa, 0x97, 0x64, 0xc9, 0x6b, 0xec, 0xd3, 0x66, 0xb1, 0x79, 0xca,
0xd0, 0x6f, 0x0a, 0x39, 0x17, 0x50, 0xf2, 0x7c, 0x53, 0x1a, 0x2a, 0xa7, 0x9e, 0xaa, 0x4a, 0x43,
0xe5, 0xf4, 0x43, 0x53, 0x56, 0xd3, 0x8a, 0x1f, 0xda, 0x49, 0x6b, 0x5a, 0x29, 0xc7, 0xa0, 0xd2,
0x9a, 0x56, 0xda, 0x29, 0xa0, 0x7a, 0x66, 0xf5, 0xa3, 0x2f, 0x3e, 0xec, 0x9b, 0xde, 0xc1, 0x78,
0x8f, 0xcc, 0xfe, 0x2e, 0xeb, 0xfa, 0x81, 0x69, 0xf3, 0x5f, 0x77, 0x7d, 0x71, 0xbf, 0x4b, 0xa9,
0xdd, 0x25, 0xd4, 0x46, 0x7b, 0x7b, 0x25, 0xda, 0xfa, 0xe8, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff,
0x4a, 0x84, 0x21, 0x10, 0xf9, 0x52, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -5211,6 +5311,7 @@ type DataCoordClient interface {
DescribeIndex(ctx context.Context, in *indexpb.DescribeIndexRequest, opts ...grpc.CallOption) (*indexpb.DescribeIndexResponse, error)
// Deprecated: use DescribeIndex instead
GetIndexBuildProgress(ctx context.Context, in *indexpb.GetIndexBuildProgressRequest, opts ...grpc.CallOption) (*indexpb.GetIndexBuildProgressResponse, error)
GcConfirm(ctx context.Context, in *GcConfirmRequest, opts ...grpc.CallOption) (*GcConfirmResponse, error)
}
type dataCoordClient struct {
@ -5572,6 +5673,15 @@ func (c *dataCoordClient) GetIndexBuildProgress(ctx context.Context, in *indexpb
return out, nil
}
func (c *dataCoordClient) GcConfirm(ctx context.Context, in *GcConfirmRequest, opts ...grpc.CallOption) (*GcConfirmResponse, error) {
out := new(GcConfirmResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/GcConfirm", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// DataCoordServer is the server API for DataCoord service.
type DataCoordServer interface {
GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
@ -5617,6 +5727,7 @@ type DataCoordServer interface {
DescribeIndex(context.Context, *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error)
// Deprecated: use DescribeIndex instead
GetIndexBuildProgress(context.Context, *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error)
GcConfirm(context.Context, *GcConfirmRequest) (*GcConfirmResponse, error)
}
// UnimplementedDataCoordServer can be embedded to have forward compatible implementations.
@ -5740,6 +5851,9 @@ func (*UnimplementedDataCoordServer) DescribeIndex(ctx context.Context, req *ind
func (*UnimplementedDataCoordServer) GetIndexBuildProgress(ctx context.Context, req *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetIndexBuildProgress not implemented")
}
func (*UnimplementedDataCoordServer) GcConfirm(ctx context.Context, req *GcConfirmRequest) (*GcConfirmResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GcConfirm not implemented")
}
func RegisterDataCoordServer(s *grpc.Server, srv DataCoordServer) {
s.RegisterService(&_DataCoord_serviceDesc, srv)
@ -6447,6 +6561,24 @@ func _DataCoord_GetIndexBuildProgress_Handler(srv interface{}, ctx context.Conte
return interceptor(ctx, in, info, handler)
}
func _DataCoord_GcConfirm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GcConfirmRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DataCoordServer).GcConfirm(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.data.DataCoord/GcConfirm",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DataCoordServer).GcConfirm(ctx, req.(*GcConfirmRequest))
}
return interceptor(ctx, in, info, handler)
}
var _DataCoord_serviceDesc = grpc.ServiceDesc{
ServiceName: "milvus.proto.data.DataCoord",
HandlerType: (*DataCoordServer)(nil),
@ -6607,6 +6739,10 @@ var _DataCoord_serviceDesc = grpc.ServiceDesc{
MethodName: "GetIndexBuildProgress",
Handler: _DataCoord_GetIndexBuildProgress_Handler,
},
{
MethodName: "GcConfirm",
Handler: _DataCoord_GcConfirm_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "data_coord.proto",

8
internal/proxy/data_coord_mock_test.go
View File

@ -18,20 +18,22 @@ package proxy
import (
"context"
"sync/atomic"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus-proto/go-api/commonpb"
"github.com/milvus-io/milvus-proto/go-api/milvuspb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/internal/util/funcutil"
"github.com/milvus-io/milvus/internal/util/typeutil"
"github.com/milvus-io/milvus/internal/util/uniquegenerator"
"go.uber.org/atomic"
)
type DataCoordMock struct {
types.DataCoord
nodeID typeutil.UniqueID
address string

13
internal/rootcoord/broker.go
View File

@ -40,6 +40,7 @@ type Broker interface {
UnsetIsImportingState(context.Context, *datapb.UnsetIsImportingStateRequest) (*commonpb.Status, error)
MarkSegmentsDropped(context.Context, *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error)
GetSegmentStates(context.Context, *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error)
GcConfirm(ctx context.Context, collectionID, partitionID UniqueID) bool
DropCollectionIndex(ctx context.Context, collID UniqueID, partIDs []UniqueID) error
GetSegmentIndexState(ctx context.Context, collID UniqueID, indexName string, segIDs []UniqueID) ([]*indexpb.SegmentIndexState, error)
@ -235,3 +236,15 @@ func (b *ServerBroker) DescribeIndex(ctx context.Context, colID UniqueID) (*inde
CollectionID: colID,
})
}
func (b *ServerBroker) GcConfirm(ctx context.Context, collectionID, partitionID UniqueID) bool {
req := &datapb.GcConfirmRequest{CollectionId: collectionID, PartitionId: partitionID}
resp, err := b.s.dataCoord.GcConfirm(ctx, req)
if err != nil {
return false
}
if resp.GetStatus().GetErrorCode() != commonpb.ErrorCode_Success {
return false
}
return resp.GetGcFinished()
}

51
internal/rootcoord/broker_test.go
View File

@ -5,15 +5,15 @@ import (
"errors"
"testing"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/metastore/model"
"github.com/milvus-io/milvus-proto/go-api/milvuspb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus-proto/go-api/commonpb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus-proto/go-api/milvuspb"
"github.com/milvus-io/milvus/internal/metastore/model"
"github.com/milvus-io/milvus/internal/mocks"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
)
func TestServerBroker_ReleaseCollection(t *testing.T) {
@ -304,3 +304,42 @@ func TestServerBroker_BroadcastAlteredCollection(t *testing.T) {
assert.NoError(t, err)
})
}
func TestServerBroker_GcConfirm(t *testing.T) {
t.Run("invalid datacoord", func(t *testing.T) {
dc := mocks.NewDataCoord(t)
dc.On("GcConfirm",
mock.Anything, // context.Context
mock.Anything, // *datapb.GcConfirmRequest
).Return(nil, errors.New("error mock GcConfirm"))
c := newTestCore(withDataCoord(dc))
broker := newServerBroker(c)
assert.False(t, broker.GcConfirm(context.Background(), 100, 10000))
})
t.Run("non success", func(t *testing.T) {
dc := mocks.NewDataCoord(t)
dc.On("GcConfirm",
mock.Anything, // context.Context
mock.Anything, // *datapb.GcConfirmRequest
).Return(
&datapb.GcConfirmResponse{Status: failStatus(commonpb.ErrorCode_UnexpectedError, "error mock GcConfirm")},
nil)
c := newTestCore(withDataCoord(dc))
broker := newServerBroker(c)
assert.False(t, broker.GcConfirm(context.Background(), 100, 10000))
})
t.Run("normal case", func(t *testing.T) {
dc := mocks.NewDataCoord(t)
dc.On("GcConfirm",
mock.Anything, // context.Context
mock.Anything, // *datapb.GcConfirmRequest
).Return(
&datapb.GcConfirmResponse{Status: succStatus(), GcFinished: true},
nil)
c := newTestCore(withDataCoord(dc))
broker := newServerBroker(c)
assert.True(t, broker.GcConfirm(context.Background(), 100, 10000))
})
}

1
internal/rootcoord/drop_collection_task.go
View File

@ -91,6 +91,7 @@ func (t *dropCollectionTask) Execute(ctx context.Context) error {
baseStep: baseStep{core: t.core},
pChannels: collMeta.PhysicalChannelNames,
})
redoTask.AddAsyncStep(newConfirmGCStep(t.core, collMeta.CollectionID, allPartition))
redoTask.AddAsyncStep(&deleteCollectionMetaStep{
baseStep: baseStep{core: t.core},
collectionID: collMeta.CollectionID,

8
internal/rootcoord/drop_collection_task_test.go
View File

@ -4,6 +4,7 @@ import (
"context"
"errors"
"testing"
"time"
"github.com/milvus-io/milvus/internal/common"
@ -148,6 +149,9 @@ func Test_dropCollectionTask_Execute(t *testing.T) {
t.Run("normal case, redo", func(t *testing.T) {
defer cleanTestEnv()
confirmGCInterval = time.Millisecond
defer restoreConfirmGCInterval()
collectionName := funcutil.GenRandomStr()
shardNum := 2
@ -187,8 +191,12 @@ func Test_dropCollectionTask_Execute(t *testing.T) {
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
dropIndexCalled = true
dropIndexChan <- struct{}{}
time.Sleep(confirmGCInterval)
return nil
}
broker.GCConfirmFunc = func(ctx context.Context, collectionID, partitionID UniqueID) bool {
return true
}
gc := newMockGarbageCollector()
deleteCollectionCalled := false

1
internal/rootcoord/drop_partition_task.go
View File

@ -79,6 +79,7 @@ func (t *dropPartitionTask) Execute(ctx context.Context) error {
CollectionID: t.collMeta.CollectionID,
},
})
redoTask.AddAsyncStep(newConfirmGCStep(t.core, t.collMeta.CollectionID, partID))
redoTask.AddAsyncStep(&removePartitionMetaStep{
baseStep: baseStep{core: t.core},
collectionID: t.collMeta.CollectionID,

19
internal/rootcoord/drop_partition_task_test.go
View File

@ -3,6 +3,7 @@ package rootcoord
import (
"context"
"testing"
"time"
"github.com/milvus-io/milvus/internal/metastore/model"
"github.com/milvus-io/milvus/internal/proto/etcdpb"
@ -125,6 +126,9 @@ func Test_dropPartitionTask_Execute(t *testing.T) {
})
t.Run("normal case", func(t *testing.T) {
confirmGCInterval = time.Millisecond
defer restoreConfirmGCInterval()
collectionName := funcutil.GenRandomStr()
partitionName := funcutil.GenRandomStr()
coll := &model.Collection{Name: collectionName, Partitions: []*model.Partition{{PartitionName: partitionName}}}
@ -146,10 +150,23 @@ func Test_dropPartitionTask_Execute(t *testing.T) {
gc.GcPartitionDataFunc = func(ctx context.Context, pChannels []string, coll *model.Partition) (Timestamp, error) {
deletePartitionChan <- struct{}{}
deletePartitionCalled = true
time.Sleep(confirmGCInterval)
return 0, nil
}
core := newTestCore(withValidProxyManager(), withMeta(meta), withGarbageCollector(gc), withDropIndex())
broker := newMockBroker()
broker.GCConfirmFunc = func(ctx context.Context, collectionID, partitionID UniqueID) bool {
return true
}
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
return nil
}
core := newTestCore(
withValidProxyManager(),
withMeta(meta),
withGarbageCollector(gc),
withBroker(broker))
task := &dropPartitionTask{
baseTask: baseTask{core: core},

24
internal/rootcoord/meta_table.go
View File

@ -35,7 +35,6 @@ import (
"github.com/milvus-io/milvus-proto/go-api/milvuspb"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/metastore"
"github.com/milvus-io/milvus/internal/metastore/kv/rootcoord"
"github.com/milvus-io/milvus/internal/metastore/model"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/contextutil"
@ -43,29 +42,6 @@ import (
"github.com/milvus-io/milvus/internal/util/typeutil"
)
const (
// TimestampPrefix prefix for timestamp
TimestampPrefix = rootcoord.ComponentPrefix + "/timestamp"
// CreateCollectionDDType name of DD type for create collection
CreateCollectionDDType = "CreateCollection"
// DropCollectionDDType name of DD type for drop collection
DropCollectionDDType = "DropCollection"
// CreatePartitionDDType name of DD type for create partition
CreatePartitionDDType = "CreatePartition"
// DropPartitionDDType name of DD type for drop partition
DropPartitionDDType = "DropPartition"
// DefaultIndexType name of default index type for scalar field
DefaultIndexType = "STL_SORT"
// DefaultStringIndexType name of default index type for varChar/string field
DefaultStringIndexType = "Trie"
)
//go:generate mockery --name=IMetaTable --outpkg=mockrootcoord
type IMetaTable interface {
AddCollection(ctx context.Context, coll *model.Collection) error

6
internal/rootcoord/mock_test.go
View File

@ -765,6 +765,8 @@ type mockBroker struct {
GetSegmentIndexStateFunc func(ctx context.Context, collID UniqueID, indexName string, segIDs []UniqueID) ([]*indexpb.SegmentIndexState, error)
BroadcastAlteredCollectionFunc func(ctx context.Context, req *milvuspb.AlterCollectionRequest) error
GCConfirmFunc func(ctx context.Context, collectionID, partitionID UniqueID) bool
}
func newMockBroker() *mockBroker {
@ -799,6 +801,10 @@ func (b mockBroker) BroadcastAlteredCollection(ctx context.Context, req *milvusp
return b.BroadcastAlteredCollectionFunc(ctx, req)
}
func (b mockBroker) GcConfirm(ctx context.Context, collectionID, partitionID UniqueID) bool {
return b.GCConfirmFunc(ctx, collectionID, partitionID)
}
func withBroker(b Broker) Opt {
return func(c *Core) {
c.broker = b

56
internal/rootcoord/step.go
View File

@ -3,6 +3,7 @@ package rootcoord
import (
"context"
"fmt"
"time"
"github.com/milvus-io/milvus-proto/go-api/milvuspb"
@ -14,10 +15,10 @@ import (
type stepPriority int
const (
stepPriorityLow = iota
stepPriorityNormal
stepPriorityImportant
stepPriorityUrgent
stepPriorityLow = 0
stepPriorityNormal = 1
stepPriorityImportant = 10
stepPriorityUrgent = 1000
)
type nestedStep interface {
@ -374,3 +375,50 @@ func (b *BroadcastAlteredCollectionStep) Execute(ctx context.Context) ([]nestedS
func (b *BroadcastAlteredCollectionStep) Desc() string {
return fmt.Sprintf("broadcast altered collection, collectionID: %d", b.req.CollectionID)
}
var (
confirmGCInterval = time.Minute * 20
allPartition UniqueID = -1
)
type confirmGCStep struct {
baseStep
collectionID UniqueID
partitionID UniqueID
lastScheduledTime time.Time
}
func newConfirmGCStep(core *Core, collectionID, partitionID UniqueID) *confirmGCStep {
return &confirmGCStep{
baseStep: baseStep{core: core},
collectionID: collectionID,
partitionID: partitionID,
lastScheduledTime: time.Now(),
}
}
func (b *confirmGCStep) Execute(ctx context.Context) ([]nestedStep, error) {
if time.Since(b.lastScheduledTime) < confirmGCInterval {
return nil, fmt.Errorf("wait for reschedule to confirm GC, collection: %d, partition: %d, last scheduled time: %s, now: %s",
b.collectionID, b.partitionID, b.lastScheduledTime.String(), time.Now().String())
}
finished := b.core.broker.GcConfirm(ctx, b.collectionID, b.partitionID)
if finished {
return nil, nil
}
b.lastScheduledTime = time.Now()
return nil, fmt.Errorf("GC is not finished, collection: %d, partition: %d, last scheduled time: %s, now: %s",
b.collectionID, b.partitionID, b.lastScheduledTime.String(), time.Now().String())
}
func (b *confirmGCStep) Desc() string {
return fmt.Sprintf("wait for GC finished, collection: %d, partition: %d, last scheduled time: %s, now: %s",
b.collectionID, b.partitionID, b.lastScheduledTime.String(), time.Now().String())
}
func (b *confirmGCStep) Weight() stepPriority {
return stepPriorityLow
}

37
internal/rootcoord/step_executor.go
View File

@ -2,6 +2,7 @@ package rootcoord
import (
"context"
"sort"
"sync"
"time"
@ -25,14 +26,26 @@ type stepStack struct {
steps []nestedStep
}
func (s *stepStack) totalPriority() int {
total := 0
for _, step := range s.steps {
total += int(step.Weight())
}
return total
}
func (s *stepStack) Execute(ctx context.Context) *stepStack {
steps := s.steps
for len(steps) > 0 {
l := len(steps)
todo := steps[l-1]
childSteps, err := todo.Execute(ctx)
// TODO: maybe a interface `step.LogOnError` is better.
_, skipLog := todo.(*waitForTsSyncedStep)
_, isWaitForTsSyncedStep := todo.(*waitForTsSyncedStep)
_, isConfirmGCStep := todo.(*confirmGCStep)
skipLog := isWaitForTsSyncedStep || isConfirmGCStep
if retry.IsUnRecoverable(err) {
if !skipLog {
log.Warn("failed to execute step, not able to reschedule", zap.Error(err), zap.String("step", todo.Desc()))
@ -76,8 +89,28 @@ func randomSelectPolicy(parallel int) selectStepPolicy {
}
}
func selectByPriority(parallel int, m map[*stepStack]struct{}) []*stepStack {
h := make([]*stepStack, 0, len(m))
for k := range m {
h = append(h, k)
}
sort.Slice(h, func(i, j int) bool {
return h[i].totalPriority() > h[j].totalPriority()
})
if len(h) <= parallel {
return h
}
return h[:parallel]
}
func selectByPriorityPolicy(parallel int) selectStepPolicy {
return func(m map[*stepStack]struct{}) []*stepStack {
return selectByPriority(parallel, m)
}
}
func defaultSelectPolicy() selectStepPolicy {
return randomSelectPolicy(defaultBgExecutingParallel)
return selectByPriorityPolicy(defaultBgExecutingParallel)
}
type bgOpt func(*bgStepExecutor)

43
internal/rootcoord/step_executor_test.go
View File

@ -8,7 +8,6 @@ import (
"time"
"github.com/milvus-io/milvus/internal/util/retry"
"github.com/stretchr/testify/assert"
)
@ -128,7 +127,7 @@ func Test_randomSelect(t *testing.T) {
func Test_bgStepExecutor_scheduleLoop(t *testing.T) {
bg := newBgStepExecutor(context.Background(),
withSelectStepPolicy(defaultSelectPolicy()),
withSelectStepPolicy(randomSelectPolicy(defaultBgExecutingParallel)),
withBgInterval(time.Millisecond*10))
bg.Start()
n := 20
@ -173,3 +172,43 @@ func Test_bgStepExecutor_scheduleLoop(t *testing.T) {
}
bg.Stop()
}
func Test_selectByPriorityPolicy(t *testing.T) {
policy := selectByPriorityPolicy(4)
t.Run("select all", func(t *testing.T) {
m := map[*stepStack]struct{}{
{steps: []nestedStep{}}: {},
{steps: []nestedStep{}}: {},
}
selected := policy(m)
assert.Equal(t, 2, len(selected))
})
t.Run("select by priority", func(t *testing.T) {
steps := []nestedStep{
&releaseCollectionStep{},
&releaseCollectionStep{},
&releaseCollectionStep{},
&releaseCollectionStep{},
&releaseCollectionStep{},
}
s1 := &stepStack{steps: steps[0:1]}
s2 := &stepStack{steps: steps[0:2]}
s3 := &stepStack{steps: steps[0:3]}
s4 := &stepStack{steps: steps[0:4]}
s5 := &stepStack{steps: steps[0:5]}
m := map[*stepStack]struct{}{
s1: {},
s2: {},
s3: {},
s4: {},
s5: {},
}
selected := policy(m)
assert.Equal(t, 4, len(selected))
for i := 1; i < len(selected); i++ {
assert.True(t, selected[i].totalPriority() <= selected[i-1].totalPriority())
}
})
}

52
internal/rootcoord/step_test.go
View File

@ -3,6 +3,7 @@ package rootcoord
import (
"context"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
@ -27,3 +28,54 @@ func Test_waitForTsSyncedStep_Execute(t *testing.T) {
assert.Equal(t, 0, len(children))
assert.NoError(t, err)
}
func restoreConfirmGCInterval() {
confirmGCInterval = time.Minute * 20
}
func Test_confirmGCStep_Execute(t *testing.T) {
t.Run("wait for reschedule", func(t *testing.T) {
confirmGCInterval = time.Minute * 1000
defer restoreConfirmGCInterval()
s := &confirmGCStep{lastScheduledTime: time.Now()}
_, err := s.Execute(context.TODO())
assert.Error(t, err)
})
t.Run("GC not finished", func(t *testing.T) {
broker := newMockBroker()
broker.GCConfirmFunc = func(ctx context.Context, collectionID, partitionID UniqueID) bool {
return false
}
core := newTestCore(withBroker(broker))
confirmGCInterval = time.Millisecond
defer restoreConfirmGCInterval()
s := newConfirmGCStep(core, 100, 1000)
time.Sleep(confirmGCInterval)
_, err := s.Execute(context.TODO())
assert.Error(t, err)
})
t.Run("normal case", func(t *testing.T) {
broker := newMockBroker()
broker.GCConfirmFunc = func(ctx context.Context, collectionID, partitionID UniqueID) bool {
return true
}
core := newTestCore(withBroker(broker))
confirmGCInterval = time.Millisecond
defer restoreConfirmGCInterval()
s := newConfirmGCStep(core, 100, 1000)
time.Sleep(confirmGCInterval)
_, err := s.Execute(context.TODO())
assert.NoError(t, err)
})
}

2
internal/types/types.go
View File

@ -331,6 +331,8 @@ type DataCoord interface {
CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
GcConfirm(ctx context.Context, request *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error)
// CreateIndex create an index on collection.
// Index building is asynchronous, so when an index building request comes, an IndexID is assigned to the task and
// will get all flushed segments from DataCoord and record tasks with these segments. The background process

5
internal/util/mock/datacoord_client.go
View File

@ -19,16 +19,17 @@ package mock
import (
"context"
"google.golang.org/grpc"
"github.com/milvus-io/milvus-proto/go-api/commonpb"
"github.com/milvus-io/milvus-proto/go-api/milvuspb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/types"
"google.golang.org/grpc"
)
// DataCoordClient mocks of DataCoordClient
type DataCoordClient struct {
types.DataCoord
Err error
}

4
internal/util/mock/grpc_datacoord_client.go
View File

@ -36,6 +36,10 @@ type GrpcDataCoordClient struct {
Err error
}
func (m *GrpcDataCoordClient) GcConfirm(ctx context.Context, in *datapb.GcConfirmRequest, opts ...grpc.CallOption) (*datapb.GcConfirmResponse, error) {
return &datapb.GcConfirmResponse{}, m.Err
}
func (m *GrpcDataCoordClient) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error) {
return &milvuspb.CheckHealthResponse{}, m.Err
}