mirror of
https://gitee.com/milvus-io/milvus.git
synced 2025-12-07 01:28:27 +08:00
0e1f367164
We’ve frequently observed data loss caused by broken mutual exclusion in compaction tasks. This PR introduces a post-check: before modifying metadata upon compaction task completion, it verifies the state of the input segments. If any input segment has been dropped, the compaction task will be marked as failed. issue: https://github.com/milvus-io/milvus/issues/43513 --------- Signed-off-by: bigsheeper <yihao.dai@zilliz.com>
941 lines
32 KiB
Go
941 lines
32 KiB
Go
// Code generated by mockery v2.53.3. DO NOT EDIT.
|
|
|
|
package datacoord
|
|
|
|
import (
|
|
context "context"
|
|
|
|
datapb "github.com/milvus-io/milvus/pkg/v2/proto/datapb"
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// MockCompactionMeta is an autogenerated mock type for the CompactionMeta type
|
|
type MockCompactionMeta struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockCompactionMeta_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockCompactionMeta) EXPECT() *MockCompactionMeta_Expecter {
|
|
return &MockCompactionMeta_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// CheckAndSetSegmentsCompacting provides a mock function with given fields: ctx, segmentIDs
|
|
func (_m *MockCompactionMeta) CheckAndSetSegmentsCompacting(ctx context.Context, segmentIDs []int64) (bool, bool) {
|
|
ret := _m.Called(ctx, segmentIDs)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CheckAndSetSegmentsCompacting")
|
|
}
|
|
|
|
var r0 bool
|
|
var r1 bool
|
|
if rf, ok := ret.Get(0).(func(context.Context, []int64) (bool, bool)); ok {
|
|
return rf(ctx, segmentIDs)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, []int64) bool); ok {
|
|
r0 = rf(ctx, segmentIDs)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, []int64) bool); ok {
|
|
r1 = rf(ctx, segmentIDs)
|
|
} else {
|
|
r1 = ret.Get(1).(bool)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCompactionMeta_CheckAndSetSegmentsCompacting_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckAndSetSegmentsCompacting'
|
|
type MockCompactionMeta_CheckAndSetSegmentsCompacting_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CheckAndSetSegmentsCompacting is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - segmentIDs []int64
|
|
func (_e *MockCompactionMeta_Expecter) CheckAndSetSegmentsCompacting(ctx interface{}, segmentIDs interface{}) *MockCompactionMeta_CheckAndSetSegmentsCompacting_Call {
|
|
return &MockCompactionMeta_CheckAndSetSegmentsCompacting_Call{Call: _e.mock.On("CheckAndSetSegmentsCompacting", ctx, segmentIDs)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_CheckAndSetSegmentsCompacting_Call) Run(run func(ctx context.Context, segmentIDs []int64)) *MockCompactionMeta_CheckAndSetSegmentsCompacting_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].([]int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_CheckAndSetSegmentsCompacting_Call) Return(_a0 bool, _a1 bool) *MockCompactionMeta_CheckAndSetSegmentsCompacting_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_CheckAndSetSegmentsCompacting_Call) RunAndReturn(run func(context.Context, []int64) (bool, bool)) *MockCompactionMeta_CheckAndSetSegmentsCompacting_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CleanPartitionStatsInfo provides a mock function with given fields: ctx, info
|
|
func (_m *MockCompactionMeta) CleanPartitionStatsInfo(ctx context.Context, info *datapb.PartitionStatsInfo) error {
|
|
ret := _m.Called(ctx, info)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CleanPartitionStatsInfo")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.PartitionStatsInfo) error); ok {
|
|
r0 = rf(ctx, info)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_CleanPartitionStatsInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanPartitionStatsInfo'
|
|
type MockCompactionMeta_CleanPartitionStatsInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CleanPartitionStatsInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - info *datapb.PartitionStatsInfo
|
|
func (_e *MockCompactionMeta_Expecter) CleanPartitionStatsInfo(ctx interface{}, info interface{}) *MockCompactionMeta_CleanPartitionStatsInfo_Call {
|
|
return &MockCompactionMeta_CleanPartitionStatsInfo_Call{Call: _e.mock.On("CleanPartitionStatsInfo", ctx, info)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_CleanPartitionStatsInfo_Call) Run(run func(ctx context.Context, info *datapb.PartitionStatsInfo)) *MockCompactionMeta_CleanPartitionStatsInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.PartitionStatsInfo))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_CleanPartitionStatsInfo_Call) Return(_a0 error) *MockCompactionMeta_CleanPartitionStatsInfo_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_CleanPartitionStatsInfo_Call) RunAndReturn(run func(context.Context, *datapb.PartitionStatsInfo) error) *MockCompactionMeta_CleanPartitionStatsInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CompleteCompactionMutation provides a mock function with given fields: ctx, t, result
|
|
func (_m *MockCompactionMeta) CompleteCompactionMutation(ctx context.Context, t *datapb.CompactionTask, result *datapb.CompactionPlanResult) ([]*SegmentInfo, *segMetricMutation, error) {
|
|
ret := _m.Called(ctx, t, result)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CompleteCompactionMutation")
|
|
}
|
|
|
|
var r0 []*SegmentInfo
|
|
var r1 *segMetricMutation
|
|
var r2 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.CompactionTask, *datapb.CompactionPlanResult) ([]*SegmentInfo, *segMetricMutation, error)); ok {
|
|
return rf(ctx, t, result)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.CompactionTask, *datapb.CompactionPlanResult) []*SegmentInfo); ok {
|
|
r0 = rf(ctx, t, result)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*SegmentInfo)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *datapb.CompactionTask, *datapb.CompactionPlanResult) *segMetricMutation); ok {
|
|
r1 = rf(ctx, t, result)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*segMetricMutation)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(2).(func(context.Context, *datapb.CompactionTask, *datapb.CompactionPlanResult) error); ok {
|
|
r2 = rf(ctx, t, result)
|
|
} else {
|
|
r2 = ret.Error(2)
|
|
}
|
|
|
|
return r0, r1, r2
|
|
}
|
|
|
|
// MockCompactionMeta_CompleteCompactionMutation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteCompactionMutation'
|
|
type MockCompactionMeta_CompleteCompactionMutation_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CompleteCompactionMutation is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - t *datapb.CompactionTask
|
|
// - result *datapb.CompactionPlanResult
|
|
func (_e *MockCompactionMeta_Expecter) CompleteCompactionMutation(ctx interface{}, t interface{}, result interface{}) *MockCompactionMeta_CompleteCompactionMutation_Call {
|
|
return &MockCompactionMeta_CompleteCompactionMutation_Call{Call: _e.mock.On("CompleteCompactionMutation", ctx, t, result)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_CompleteCompactionMutation_Call) Run(run func(ctx context.Context, t *datapb.CompactionTask, result *datapb.CompactionPlanResult)) *MockCompactionMeta_CompleteCompactionMutation_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.CompactionTask), args[2].(*datapb.CompactionPlanResult))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_CompleteCompactionMutation_Call) Return(_a0 []*SegmentInfo, _a1 *segMetricMutation, _a2 error) *MockCompactionMeta_CompleteCompactionMutation_Call {
|
|
_c.Call.Return(_a0, _a1, _a2)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_CompleteCompactionMutation_Call) RunAndReturn(run func(context.Context, *datapb.CompactionTask, *datapb.CompactionPlanResult) ([]*SegmentInfo, *segMetricMutation, error)) *MockCompactionMeta_CompleteCompactionMutation_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DropCompactionTask provides a mock function with given fields: ctx, task
|
|
func (_m *MockCompactionMeta) DropCompactionTask(ctx context.Context, task *datapb.CompactionTask) error {
|
|
ret := _m.Called(ctx, task)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DropCompactionTask")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.CompactionTask) error); ok {
|
|
r0 = rf(ctx, task)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_DropCompactionTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropCompactionTask'
|
|
type MockCompactionMeta_DropCompactionTask_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DropCompactionTask is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - task *datapb.CompactionTask
|
|
func (_e *MockCompactionMeta_Expecter) DropCompactionTask(ctx interface{}, task interface{}) *MockCompactionMeta_DropCompactionTask_Call {
|
|
return &MockCompactionMeta_DropCompactionTask_Call{Call: _e.mock.On("DropCompactionTask", ctx, task)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_DropCompactionTask_Call) Run(run func(ctx context.Context, task *datapb.CompactionTask)) *MockCompactionMeta_DropCompactionTask_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.CompactionTask))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_DropCompactionTask_Call) Return(_a0 error) *MockCompactionMeta_DropCompactionTask_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_DropCompactionTask_Call) RunAndReturn(run func(context.Context, *datapb.CompactionTask) error) *MockCompactionMeta_DropCompactionTask_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAnalyzeMeta provides a mock function with no fields
|
|
func (_m *MockCompactionMeta) GetAnalyzeMeta() *analyzeMeta {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAnalyzeMeta")
|
|
}
|
|
|
|
var r0 *analyzeMeta
|
|
if rf, ok := ret.Get(0).(func() *analyzeMeta); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*analyzeMeta)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_GetAnalyzeMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAnalyzeMeta'
|
|
type MockCompactionMeta_GetAnalyzeMeta_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAnalyzeMeta is a helper method to define mock.On call
|
|
func (_e *MockCompactionMeta_Expecter) GetAnalyzeMeta() *MockCompactionMeta_GetAnalyzeMeta_Call {
|
|
return &MockCompactionMeta_GetAnalyzeMeta_Call{Call: _e.mock.On("GetAnalyzeMeta")}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetAnalyzeMeta_Call) Run(run func()) *MockCompactionMeta_GetAnalyzeMeta_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetAnalyzeMeta_Call) Return(_a0 *analyzeMeta) *MockCompactionMeta_GetAnalyzeMeta_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetAnalyzeMeta_Call) RunAndReturn(run func() *analyzeMeta) *MockCompactionMeta_GetAnalyzeMeta_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCompactionTaskMeta provides a mock function with no fields
|
|
func (_m *MockCompactionMeta) GetCompactionTaskMeta() *compactionTaskMeta {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCompactionTaskMeta")
|
|
}
|
|
|
|
var r0 *compactionTaskMeta
|
|
if rf, ok := ret.Get(0).(func() *compactionTaskMeta); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*compactionTaskMeta)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_GetCompactionTaskMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompactionTaskMeta'
|
|
type MockCompactionMeta_GetCompactionTaskMeta_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCompactionTaskMeta is a helper method to define mock.On call
|
|
func (_e *MockCompactionMeta_Expecter) GetCompactionTaskMeta() *MockCompactionMeta_GetCompactionTaskMeta_Call {
|
|
return &MockCompactionMeta_GetCompactionTaskMeta_Call{Call: _e.mock.On("GetCompactionTaskMeta")}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetCompactionTaskMeta_Call) Run(run func()) *MockCompactionMeta_GetCompactionTaskMeta_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetCompactionTaskMeta_Call) Return(_a0 *compactionTaskMeta) *MockCompactionMeta_GetCompactionTaskMeta_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetCompactionTaskMeta_Call) RunAndReturn(run func() *compactionTaskMeta) *MockCompactionMeta_GetCompactionTaskMeta_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCompactionTasks provides a mock function with given fields: ctx
|
|
func (_m *MockCompactionMeta) GetCompactionTasks(ctx context.Context) map[int64][]*datapb.CompactionTask {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCompactionTasks")
|
|
}
|
|
|
|
var r0 map[int64][]*datapb.CompactionTask
|
|
if rf, ok := ret.Get(0).(func(context.Context) map[int64][]*datapb.CompactionTask); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[int64][]*datapb.CompactionTask)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_GetCompactionTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompactionTasks'
|
|
type MockCompactionMeta_GetCompactionTasks_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCompactionTasks is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *MockCompactionMeta_Expecter) GetCompactionTasks(ctx interface{}) *MockCompactionMeta_GetCompactionTasks_Call {
|
|
return &MockCompactionMeta_GetCompactionTasks_Call{Call: _e.mock.On("GetCompactionTasks", ctx)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetCompactionTasks_Call) Run(run func(ctx context.Context)) *MockCompactionMeta_GetCompactionTasks_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetCompactionTasks_Call) Return(_a0 map[int64][]*datapb.CompactionTask) *MockCompactionMeta_GetCompactionTasks_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetCompactionTasks_Call) RunAndReturn(run func(context.Context) map[int64][]*datapb.CompactionTask) *MockCompactionMeta_GetCompactionTasks_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCompactionTasksByTriggerID provides a mock function with given fields: ctx, triggerID
|
|
func (_m *MockCompactionMeta) GetCompactionTasksByTriggerID(ctx context.Context, triggerID int64) []*datapb.CompactionTask {
|
|
ret := _m.Called(ctx, triggerID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCompactionTasksByTriggerID")
|
|
}
|
|
|
|
var r0 []*datapb.CompactionTask
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) []*datapb.CompactionTask); ok {
|
|
r0 = rf(ctx, triggerID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*datapb.CompactionTask)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_GetCompactionTasksByTriggerID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompactionTasksByTriggerID'
|
|
type MockCompactionMeta_GetCompactionTasksByTriggerID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCompactionTasksByTriggerID is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - triggerID int64
|
|
func (_e *MockCompactionMeta_Expecter) GetCompactionTasksByTriggerID(ctx interface{}, triggerID interface{}) *MockCompactionMeta_GetCompactionTasksByTriggerID_Call {
|
|
return &MockCompactionMeta_GetCompactionTasksByTriggerID_Call{Call: _e.mock.On("GetCompactionTasksByTriggerID", ctx, triggerID)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetCompactionTasksByTriggerID_Call) Run(run func(ctx context.Context, triggerID int64)) *MockCompactionMeta_GetCompactionTasksByTriggerID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetCompactionTasksByTriggerID_Call) Return(_a0 []*datapb.CompactionTask) *MockCompactionMeta_GetCompactionTasksByTriggerID_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetCompactionTasksByTriggerID_Call) RunAndReturn(run func(context.Context, int64) []*datapb.CompactionTask) *MockCompactionMeta_GetCompactionTasksByTriggerID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetHealthySegment provides a mock function with given fields: ctx, segID
|
|
func (_m *MockCompactionMeta) GetHealthySegment(ctx context.Context, segID int64) *SegmentInfo {
|
|
ret := _m.Called(ctx, segID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetHealthySegment")
|
|
}
|
|
|
|
var r0 *SegmentInfo
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) *SegmentInfo); ok {
|
|
r0 = rf(ctx, segID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*SegmentInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_GetHealthySegment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHealthySegment'
|
|
type MockCompactionMeta_GetHealthySegment_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetHealthySegment is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - segID int64
|
|
func (_e *MockCompactionMeta_Expecter) GetHealthySegment(ctx interface{}, segID interface{}) *MockCompactionMeta_GetHealthySegment_Call {
|
|
return &MockCompactionMeta_GetHealthySegment_Call{Call: _e.mock.On("GetHealthySegment", ctx, segID)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetHealthySegment_Call) Run(run func(ctx context.Context, segID int64)) *MockCompactionMeta_GetHealthySegment_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetHealthySegment_Call) Return(_a0 *SegmentInfo) *MockCompactionMeta_GetHealthySegment_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetHealthySegment_Call) RunAndReturn(run func(context.Context, int64) *SegmentInfo) *MockCompactionMeta_GetHealthySegment_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetIndexMeta provides a mock function with no fields
|
|
func (_m *MockCompactionMeta) GetIndexMeta() *indexMeta {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetIndexMeta")
|
|
}
|
|
|
|
var r0 *indexMeta
|
|
if rf, ok := ret.Get(0).(func() *indexMeta); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*indexMeta)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_GetIndexMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexMeta'
|
|
type MockCompactionMeta_GetIndexMeta_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetIndexMeta is a helper method to define mock.On call
|
|
func (_e *MockCompactionMeta_Expecter) GetIndexMeta() *MockCompactionMeta_GetIndexMeta_Call {
|
|
return &MockCompactionMeta_GetIndexMeta_Call{Call: _e.mock.On("GetIndexMeta")}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetIndexMeta_Call) Run(run func()) *MockCompactionMeta_GetIndexMeta_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetIndexMeta_Call) Return(_a0 *indexMeta) *MockCompactionMeta_GetIndexMeta_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetIndexMeta_Call) RunAndReturn(run func() *indexMeta) *MockCompactionMeta_GetIndexMeta_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetPartitionStatsMeta provides a mock function with no fields
|
|
func (_m *MockCompactionMeta) GetPartitionStatsMeta() *partitionStatsMeta {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPartitionStatsMeta")
|
|
}
|
|
|
|
var r0 *partitionStatsMeta
|
|
if rf, ok := ret.Get(0).(func() *partitionStatsMeta); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*partitionStatsMeta)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_GetPartitionStatsMeta_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPartitionStatsMeta'
|
|
type MockCompactionMeta_GetPartitionStatsMeta_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetPartitionStatsMeta is a helper method to define mock.On call
|
|
func (_e *MockCompactionMeta_Expecter) GetPartitionStatsMeta() *MockCompactionMeta_GetPartitionStatsMeta_Call {
|
|
return &MockCompactionMeta_GetPartitionStatsMeta_Call{Call: _e.mock.On("GetPartitionStatsMeta")}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetPartitionStatsMeta_Call) Run(run func()) *MockCompactionMeta_GetPartitionStatsMeta_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetPartitionStatsMeta_Call) Return(_a0 *partitionStatsMeta) *MockCompactionMeta_GetPartitionStatsMeta_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetPartitionStatsMeta_Call) RunAndReturn(run func() *partitionStatsMeta) *MockCompactionMeta_GetPartitionStatsMeta_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSegment provides a mock function with given fields: ctx, segID
|
|
func (_m *MockCompactionMeta) GetSegment(ctx context.Context, segID int64) *SegmentInfo {
|
|
ret := _m.Called(ctx, segID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSegment")
|
|
}
|
|
|
|
var r0 *SegmentInfo
|
|
if rf, ok := ret.Get(0).(func(context.Context, int64) *SegmentInfo); ok {
|
|
r0 = rf(ctx, segID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*SegmentInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_GetSegment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegment'
|
|
type MockCompactionMeta_GetSegment_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegment is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - segID int64
|
|
func (_e *MockCompactionMeta_Expecter) GetSegment(ctx interface{}, segID interface{}) *MockCompactionMeta_GetSegment_Call {
|
|
return &MockCompactionMeta_GetSegment_Call{Call: _e.mock.On("GetSegment", ctx, segID)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetSegment_Call) Run(run func(ctx context.Context, segID int64)) *MockCompactionMeta_GetSegment_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetSegment_Call) Return(_a0 *SegmentInfo) *MockCompactionMeta_GetSegment_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetSegment_Call) RunAndReturn(run func(context.Context, int64) *SegmentInfo) *MockCompactionMeta_GetSegment_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSegmentInfos provides a mock function with given fields: segIDs
|
|
func (_m *MockCompactionMeta) GetSegmentInfos(segIDs []int64) []*SegmentInfo {
|
|
ret := _m.Called(segIDs)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSegmentInfos")
|
|
}
|
|
|
|
var r0 []*SegmentInfo
|
|
if rf, ok := ret.Get(0).(func([]int64) []*SegmentInfo); ok {
|
|
r0 = rf(segIDs)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*SegmentInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_GetSegmentInfos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentInfos'
|
|
type MockCompactionMeta_GetSegmentInfos_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSegmentInfos is a helper method to define mock.On call
|
|
// - segIDs []int64
|
|
func (_e *MockCompactionMeta_Expecter) GetSegmentInfos(segIDs interface{}) *MockCompactionMeta_GetSegmentInfos_Call {
|
|
return &MockCompactionMeta_GetSegmentInfos_Call{Call: _e.mock.On("GetSegmentInfos", segIDs)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetSegmentInfos_Call) Run(run func(segIDs []int64)) *MockCompactionMeta_GetSegmentInfos_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].([]int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetSegmentInfos_Call) Return(_a0 []*SegmentInfo) *MockCompactionMeta_GetSegmentInfos_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_GetSegmentInfos_Call) RunAndReturn(run func([]int64) []*SegmentInfo) *MockCompactionMeta_GetSegmentInfos_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SaveCompactionTask provides a mock function with given fields: ctx, task
|
|
func (_m *MockCompactionMeta) SaveCompactionTask(ctx context.Context, task *datapb.CompactionTask) error {
|
|
ret := _m.Called(ctx, task)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SaveCompactionTask")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *datapb.CompactionTask) error); ok {
|
|
r0 = rf(ctx, task)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_SaveCompactionTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveCompactionTask'
|
|
type MockCompactionMeta_SaveCompactionTask_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SaveCompactionTask is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - task *datapb.CompactionTask
|
|
func (_e *MockCompactionMeta_Expecter) SaveCompactionTask(ctx interface{}, task interface{}) *MockCompactionMeta_SaveCompactionTask_Call {
|
|
return &MockCompactionMeta_SaveCompactionTask_Call{Call: _e.mock.On("SaveCompactionTask", ctx, task)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_SaveCompactionTask_Call) Run(run func(ctx context.Context, task *datapb.CompactionTask)) *MockCompactionMeta_SaveCompactionTask_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*datapb.CompactionTask))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_SaveCompactionTask_Call) Return(_a0 error) *MockCompactionMeta_SaveCompactionTask_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_SaveCompactionTask_Call) RunAndReturn(run func(context.Context, *datapb.CompactionTask) error) *MockCompactionMeta_SaveCompactionTask_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SelectSegments provides a mock function with given fields: ctx, filters
|
|
func (_m *MockCompactionMeta) SelectSegments(ctx context.Context, filters ...SegmentFilter) []*SegmentInfo {
|
|
_va := make([]interface{}, len(filters))
|
|
for _i := range filters {
|
|
_va[_i] = filters[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SelectSegments")
|
|
}
|
|
|
|
var r0 []*SegmentInfo
|
|
if rf, ok := ret.Get(0).(func(context.Context, ...SegmentFilter) []*SegmentInfo); ok {
|
|
r0 = rf(ctx, filters...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*SegmentInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_SelectSegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectSegments'
|
|
type MockCompactionMeta_SelectSegments_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SelectSegments is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - filters ...SegmentFilter
|
|
func (_e *MockCompactionMeta_Expecter) SelectSegments(ctx interface{}, filters ...interface{}) *MockCompactionMeta_SelectSegments_Call {
|
|
return &MockCompactionMeta_SelectSegments_Call{Call: _e.mock.On("SelectSegments",
|
|
append([]interface{}{ctx}, filters...)...)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_SelectSegments_Call) Run(run func(ctx context.Context, filters ...SegmentFilter)) *MockCompactionMeta_SelectSegments_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]SegmentFilter, len(args)-1)
|
|
for i, a := range args[1:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(SegmentFilter)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_SelectSegments_Call) Return(_a0 []*SegmentInfo) *MockCompactionMeta_SelectSegments_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_SelectSegments_Call) RunAndReturn(run func(context.Context, ...SegmentFilter) []*SegmentInfo) *MockCompactionMeta_SelectSegments_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetSegmentsCompacting provides a mock function with given fields: ctx, segmentID, compacting
|
|
func (_m *MockCompactionMeta) SetSegmentsCompacting(ctx context.Context, segmentID []int64, compacting bool) {
|
|
_m.Called(ctx, segmentID, compacting)
|
|
}
|
|
|
|
// MockCompactionMeta_SetSegmentsCompacting_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSegmentsCompacting'
|
|
type MockCompactionMeta_SetSegmentsCompacting_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetSegmentsCompacting is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - segmentID []int64
|
|
// - compacting bool
|
|
func (_e *MockCompactionMeta_Expecter) SetSegmentsCompacting(ctx interface{}, segmentID interface{}, compacting interface{}) *MockCompactionMeta_SetSegmentsCompacting_Call {
|
|
return &MockCompactionMeta_SetSegmentsCompacting_Call{Call: _e.mock.On("SetSegmentsCompacting", ctx, segmentID, compacting)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_SetSegmentsCompacting_Call) Run(run func(ctx context.Context, segmentID []int64, compacting bool)) *MockCompactionMeta_SetSegmentsCompacting_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].([]int64), args[2].(bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_SetSegmentsCompacting_Call) Return() *MockCompactionMeta_SetSegmentsCompacting_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_SetSegmentsCompacting_Call) RunAndReturn(run func(context.Context, []int64, bool)) *MockCompactionMeta_SetSegmentsCompacting_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateSegmentsInfo provides a mock function with given fields: ctx, operators
|
|
func (_m *MockCompactionMeta) UpdateSegmentsInfo(ctx context.Context, operators ...UpdateOperator) error {
|
|
_va := make([]interface{}, len(operators))
|
|
for _i := range operators {
|
|
_va[_i] = operators[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateSegmentsInfo")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, ...UpdateOperator) error); ok {
|
|
r0 = rf(ctx, operators...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_UpdateSegmentsInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSegmentsInfo'
|
|
type MockCompactionMeta_UpdateSegmentsInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateSegmentsInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - operators ...UpdateOperator
|
|
func (_e *MockCompactionMeta_Expecter) UpdateSegmentsInfo(ctx interface{}, operators ...interface{}) *MockCompactionMeta_UpdateSegmentsInfo_Call {
|
|
return &MockCompactionMeta_UpdateSegmentsInfo_Call{Call: _e.mock.On("UpdateSegmentsInfo",
|
|
append([]interface{}{ctx}, operators...)...)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_UpdateSegmentsInfo_Call) Run(run func(ctx context.Context, operators ...UpdateOperator)) *MockCompactionMeta_UpdateSegmentsInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]UpdateOperator, len(args)-1)
|
|
for i, a := range args[1:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(UpdateOperator)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_UpdateSegmentsInfo_Call) Return(_a0 error) *MockCompactionMeta_UpdateSegmentsInfo_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_UpdateSegmentsInfo_Call) RunAndReturn(run func(context.Context, ...UpdateOperator) error) *MockCompactionMeta_UpdateSegmentsInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ValidateSegmentStateBeforeCompleteCompactionMutation provides a mock function with given fields: t
|
|
func (_m *MockCompactionMeta) ValidateSegmentStateBeforeCompleteCompactionMutation(t *datapb.CompactionTask) error {
|
|
ret := _m.Called(t)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ValidateSegmentStateBeforeCompleteCompactionMutation")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*datapb.CompactionTask) error); ok {
|
|
r0 = rf(t)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockCompactionMeta_ValidateSegmentStateBeforeCompleteCompactionMutation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateSegmentStateBeforeCompleteCompactionMutation'
|
|
type MockCompactionMeta_ValidateSegmentStateBeforeCompleteCompactionMutation_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ValidateSegmentStateBeforeCompleteCompactionMutation is a helper method to define mock.On call
|
|
// - t *datapb.CompactionTask
|
|
func (_e *MockCompactionMeta_Expecter) ValidateSegmentStateBeforeCompleteCompactionMutation(t interface{}) *MockCompactionMeta_ValidateSegmentStateBeforeCompleteCompactionMutation_Call {
|
|
return &MockCompactionMeta_ValidateSegmentStateBeforeCompleteCompactionMutation_Call{Call: _e.mock.On("ValidateSegmentStateBeforeCompleteCompactionMutation", t)}
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_ValidateSegmentStateBeforeCompleteCompactionMutation_Call) Run(run func(t *datapb.CompactionTask)) *MockCompactionMeta_ValidateSegmentStateBeforeCompleteCompactionMutation_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*datapb.CompactionTask))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_ValidateSegmentStateBeforeCompleteCompactionMutation_Call) Return(_a0 error) *MockCompactionMeta_ValidateSegmentStateBeforeCompleteCompactionMutation_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCompactionMeta_ValidateSegmentStateBeforeCompleteCompactionMutation_Call) RunAndReturn(run func(*datapb.CompactionTask) error) *MockCompactionMeta_ValidateSegmentStateBeforeCompleteCompactionMutation_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockCompactionMeta creates a new instance of MockCompactionMeta. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewMockCompactionMeta(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockCompactionMeta {
|
|
mock := &MockCompactionMeta{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|