mirror of
https://github.com/temporalio/temporal.git
synced 2026-08-31 02:51:51 -07:00
44ae6d566d
## What - Don't send scale down signal when task is matched from backlog even if the poll wait time is high. - Do not send scale up signal when task queue is rate limited. ## Why - When a task comes from DB backlog, the poll wait time reflects DB read path latency, not excess pollers — the -1 is not appropriate. Instead we want to apply the normal scale up check. - Similarly, when dispatch is bottlenecked by a task queue rate limit, scaling up pollers won't help. ## How did you test it? Unit tests Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
475 lines
20 KiB
Go
475 lines
20 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: physical_task_queue_manager_interface.go
|
|
//
|
|
// Generated by this command:
|
|
//
|
|
// mockgen -package matching -source physical_task_queue_manager_interface.go -destination physical_task_queue_manager_mock.go
|
|
//
|
|
|
|
// Package matching is a generated GoMock package.
|
|
package matching
|
|
|
|
import (
|
|
context "context"
|
|
reflect "reflect"
|
|
time "time"
|
|
|
|
enums "go.temporal.io/api/enums/v1"
|
|
taskqueue "go.temporal.io/api/taskqueue/v1"
|
|
enums0 "go.temporal.io/server/api/enums/v1"
|
|
matchingservice "go.temporal.io/server/api/matchingservice/v1"
|
|
persistence "go.temporal.io/server/api/persistence/v1"
|
|
taskqueue0 "go.temporal.io/server/api/taskqueue/v1"
|
|
gomock "go.uber.org/mock/gomock"
|
|
)
|
|
|
|
// MockphysicalTaskQueueManager is a mock of physicalTaskQueueManager interface.
|
|
type MockphysicalTaskQueueManager struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockphysicalTaskQueueManagerMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockphysicalTaskQueueManagerMockRecorder is the mock recorder for MockphysicalTaskQueueManager.
|
|
type MockphysicalTaskQueueManagerMockRecorder struct {
|
|
mock *MockphysicalTaskQueueManager
|
|
}
|
|
|
|
// NewMockphysicalTaskQueueManager creates a new mock instance.
|
|
func NewMockphysicalTaskQueueManager(ctrl *gomock.Controller) *MockphysicalTaskQueueManager {
|
|
mock := &MockphysicalTaskQueueManager{ctrl: ctrl}
|
|
mock.recorder = &MockphysicalTaskQueueManagerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockphysicalTaskQueueManager) EXPECT() *MockphysicalTaskQueueManagerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddSpooledTask mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) AddSpooledTask(task *internalTask) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddSpooledTask", task)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AddSpooledTask indicates an expected call of AddSpooledTask.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) AddSpooledTask(task any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSpooledTask", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).AddSpooledTask), task)
|
|
}
|
|
|
|
// AddSpooledTaskToMatcher mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) AddSpooledTaskToMatcher(task *internalTask) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddSpooledTaskToMatcher", task)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AddSpooledTaskToMatcher indicates an expected call of AddSpooledTaskToMatcher.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) AddSpooledTaskToMatcher(task any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSpooledTaskToMatcher", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).AddSpooledTaskToMatcher), task)
|
|
}
|
|
|
|
// DispatchNexusTask mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) DispatchNexusTask(ctx context.Context, task *internalTask) (*matchingservice.DispatchNexusTaskResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DispatchNexusTask", ctx, task)
|
|
ret0, _ := ret[0].(*matchingservice.DispatchNexusTaskResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DispatchNexusTask indicates an expected call of DispatchNexusTask.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) DispatchNexusTask(ctx, task any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchNexusTask", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).DispatchNexusTask), ctx, task)
|
|
}
|
|
|
|
// DispatchQueryTask mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) DispatchQueryTask(ctx context.Context, task *internalTask) (*matchingservice.QueryWorkflowResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DispatchQueryTask", ctx, task)
|
|
ret0, _ := ret[0].(*matchingservice.QueryWorkflowResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DispatchQueryTask indicates an expected call of DispatchQueryTask.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) DispatchQueryTask(ctx, task any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchQueryTask", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).DispatchQueryTask), ctx, task)
|
|
}
|
|
|
|
// DispatchSpooledTask mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) DispatchSpooledTask(ctx context.Context, task *internalTask, userDataChanged <-chan struct{}) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DispatchSpooledTask", ctx, task, userDataChanged)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DispatchSpooledTask indicates an expected call of DispatchSpooledTask.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) DispatchSpooledTask(ctx, task, userDataChanged any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchSpooledTask", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).DispatchSpooledTask), ctx, task, userDataChanged)
|
|
}
|
|
|
|
// FinishedDraining mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) FinishedDraining() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "FinishedDraining")
|
|
}
|
|
|
|
// FinishedDraining indicates an expected call of FinishedDraining.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) FinishedDraining() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinishedDraining", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).FinishedDraining))
|
|
}
|
|
|
|
// GetAllPollerInfo mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) GetAllPollerInfo() []*taskqueue.PollerInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetAllPollerInfo")
|
|
ret0, _ := ret[0].([]*taskqueue.PollerInfo)
|
|
return ret0
|
|
}
|
|
|
|
// GetAllPollerInfo indicates an expected call of GetAllPollerInfo.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) GetAllPollerInfo() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllPollerInfo", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).GetAllPollerInfo))
|
|
}
|
|
|
|
// GetFairnessWeightOverrides mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) GetFairnessWeightOverrides() fairnessWeightOverrides {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetFairnessWeightOverrides")
|
|
ret0, _ := ret[0].(fairnessWeightOverrides)
|
|
return ret0
|
|
}
|
|
|
|
// GetFairnessWeightOverrides indicates an expected call of GetFairnessWeightOverrides.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) GetFairnessWeightOverrides() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFairnessWeightOverrides", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).GetFairnessWeightOverrides))
|
|
}
|
|
|
|
// GetInternalTaskQueueStatus mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) GetInternalTaskQueueStatus() []*taskqueue0.InternalTaskQueueStatus {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetInternalTaskQueueStatus")
|
|
ret0, _ := ret[0].([]*taskqueue0.InternalTaskQueueStatus)
|
|
return ret0
|
|
}
|
|
|
|
// GetInternalTaskQueueStatus indicates an expected call of GetInternalTaskQueueStatus.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) GetInternalTaskQueueStatus() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInternalTaskQueueStatus", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).GetInternalTaskQueueStatus))
|
|
}
|
|
|
|
// GetStatsByPriority mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) GetStatsByPriority(includeRates bool) map[int32]*taskqueue.TaskQueueStats {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetStatsByPriority", includeRates)
|
|
ret0, _ := ret[0].(map[int32]*taskqueue.TaskQueueStats)
|
|
return ret0
|
|
}
|
|
|
|
// GetStatsByPriority indicates an expected call of GetStatsByPriority.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) GetStatsByPriority(includeRates any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsByPriority", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).GetStatsByPriority), includeRates)
|
|
}
|
|
|
|
// HasPollerAfter mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) HasPollerAfter(accessTime time.Time) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasPollerAfter", accessTime)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// HasPollerAfter indicates an expected call of HasPollerAfter.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) HasPollerAfter(accessTime any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPollerAfter", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).HasPollerAfter), accessTime)
|
|
}
|
|
|
|
// LegacyDescribeTaskQueue mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) LegacyDescribeTaskQueue(includeTaskQueueStatus bool) *matchingservice.DescribeTaskQueueResponse {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "LegacyDescribeTaskQueue", includeTaskQueueStatus)
|
|
ret0, _ := ret[0].(*matchingservice.DescribeTaskQueueResponse)
|
|
return ret0
|
|
}
|
|
|
|
// LegacyDescribeTaskQueue indicates an expected call of LegacyDescribeTaskQueue.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) LegacyDescribeTaskQueue(includeTaskQueueStatus any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LegacyDescribeTaskQueue", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).LegacyDescribeTaskQueue), includeTaskQueueStatus)
|
|
}
|
|
|
|
// MakePollerScalingDecision mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) MakePollerScalingDecision(ctx context.Context, pollStartTime time.Time, taskSource enums0.TaskSource) *taskqueue.PollerScalingDecision {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "MakePollerScalingDecision", ctx, pollStartTime, taskSource)
|
|
ret0, _ := ret[0].(*taskqueue.PollerScalingDecision)
|
|
return ret0
|
|
}
|
|
|
|
// MakePollerScalingDecision indicates an expected call of MakePollerScalingDecision.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) MakePollerScalingDecision(ctx, pollStartTime, taskSource any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakePollerScalingDecision", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).MakePollerScalingDecision), ctx, pollStartTime, taskSource)
|
|
}
|
|
|
|
// MarkAlive mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) MarkAlive() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "MarkAlive")
|
|
}
|
|
|
|
// MarkAlive indicates an expected call of MarkAlive.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) MarkAlive() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkAlive", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).MarkAlive))
|
|
}
|
|
|
|
// PollTask mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) PollTask(ctx context.Context, pollMetadata *pollMetadata) (*internalTask, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "PollTask", ctx, pollMetadata)
|
|
ret0, _ := ret[0].(*internalTask)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// PollTask indicates an expected call of PollTask.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) PollTask(ctx, pollMetadata any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollTask", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).PollTask), ctx, pollMetadata)
|
|
}
|
|
|
|
// ProcessSpooledTask mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) ProcessSpooledTask(ctx context.Context, task *internalTask) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ProcessSpooledTask", ctx, task)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ProcessSpooledTask indicates an expected call of ProcessSpooledTask.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) ProcessSpooledTask(ctx, task any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessSpooledTask", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).ProcessSpooledTask), ctx, task)
|
|
}
|
|
|
|
// QueueKey mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) QueueKey() *PhysicalTaskQueueKey {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "QueueKey")
|
|
ret0, _ := ret[0].(*PhysicalTaskQueueKey)
|
|
return ret0
|
|
}
|
|
|
|
// QueueKey indicates an expected call of QueueKey.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) QueueKey() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueKey", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).QueueKey))
|
|
}
|
|
|
|
// RecordTaskAdd mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) RecordTaskAdd(result string, forwarded bool, behavior enums.VersioningBehavior) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "RecordTaskAdd", result, forwarded, behavior)
|
|
}
|
|
|
|
// RecordTaskAdd indicates an expected call of RecordTaskAdd.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) RecordTaskAdd(result, forwarded, behavior any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordTaskAdd", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).RecordTaskAdd), result, forwarded, behavior)
|
|
}
|
|
|
|
// RemovePoller mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) RemovePoller(arg0 pollerIdentity) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "RemovePoller", arg0)
|
|
}
|
|
|
|
// RemovePoller indicates an expected call of RemovePoller.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) RemovePoller(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePoller", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).RemovePoller), arg0)
|
|
}
|
|
|
|
// ReprocessRedirectedTasksAfterStop mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) ReprocessRedirectedTasksAfterStop() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "ReprocessRedirectedTasksAfterStop")
|
|
}
|
|
|
|
// ReprocessRedirectedTasksAfterStop indicates an expected call of ReprocessRedirectedTasksAfterStop.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) ReprocessRedirectedTasksAfterStop() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReprocessRedirectedTasksAfterStop", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).ReprocessRedirectedTasksAfterStop))
|
|
}
|
|
|
|
// SetupDraining mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) SetupDraining() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetupDraining")
|
|
}
|
|
|
|
// SetupDraining indicates an expected call of SetupDraining.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) SetupDraining() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupDraining", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).SetupDraining))
|
|
}
|
|
|
|
// SpoolTask mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) SpoolTask(taskInfo *persistence.TaskInfo) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SpoolTask", taskInfo)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SpoolTask indicates an expected call of SpoolTask.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) SpoolTask(taskInfo any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpoolTask", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).SpoolTask), taskInfo)
|
|
}
|
|
|
|
// Start mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) Start() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "Start")
|
|
}
|
|
|
|
// Start indicates an expected call of Start.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) Start() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).Start))
|
|
}
|
|
|
|
// StartScaleManager mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) StartScaleManager(arg0 *persistence.PartitionScaleState) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "StartScaleManager", arg0)
|
|
}
|
|
|
|
// StartScaleManager indicates an expected call of StartScaleManager.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) StartScaleManager(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartScaleManager", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).StartScaleManager), arg0)
|
|
}
|
|
|
|
// Stop mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) Stop(arg0 unloadCause) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "Stop", arg0)
|
|
}
|
|
|
|
// Stop indicates an expected call of Stop.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) Stop(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).Stop), arg0)
|
|
}
|
|
|
|
// TrySyncMatch mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) TrySyncMatch(ctx context.Context, task *internalTask) (syncMatchOutcome, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TrySyncMatch", ctx, task)
|
|
ret0, _ := ret[0].(syncMatchOutcome)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TrySyncMatch indicates an expected call of TrySyncMatch.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) TrySyncMatch(ctx, task any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrySyncMatch", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).TrySyncMatch), ctx, task)
|
|
}
|
|
|
|
// UnloadFromPartitionManager mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) UnloadFromPartitionManager(arg0 unloadCause) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "UnloadFromPartitionManager", arg0)
|
|
}
|
|
|
|
// UnloadFromPartitionManager indicates an expected call of UnloadFromPartitionManager.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) UnloadFromPartitionManager(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnloadFromPartitionManager", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).UnloadFromPartitionManager), arg0)
|
|
}
|
|
|
|
// UpdatePollerInfo mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) UpdatePollerInfo(arg0 pollerIdentity, arg1 *pollMetadata) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "UpdatePollerInfo", arg0, arg1)
|
|
}
|
|
|
|
// UpdatePollerInfo indicates an expected call of UpdatePollerInfo.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) UpdatePollerInfo(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePollerInfo", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).UpdatePollerInfo), arg0, arg1)
|
|
}
|
|
|
|
// UpdateRemotePriorityBacklogs mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) UpdateRemotePriorityBacklogs(arg0 remotePriorityBacklogSet) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "UpdateRemotePriorityBacklogs", arg0)
|
|
}
|
|
|
|
// UpdateRemotePriorityBacklogs indicates an expected call of UpdateRemotePriorityBacklogs.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) UpdateRemotePriorityBacklogs(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRemotePriorityBacklogs", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).UpdateRemotePriorityBacklogs), arg0)
|
|
}
|
|
|
|
// UpdateScaleState mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) UpdateScaleState(arg0 *persistence.PartitionScaleState, arg1 bool) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateScaleState", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateScaleState indicates an expected call of UpdateScaleState.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) UpdateScaleState(arg0, arg1 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScaleState", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).UpdateScaleState), arg0, arg1)
|
|
}
|
|
|
|
// UserDataChanged mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) UserDataChanged() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "UserDataChanged")
|
|
}
|
|
|
|
// UserDataChanged indicates an expected call of UserDataChanged.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) UserDataChanged() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserDataChanged", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).UserDataChanged))
|
|
}
|
|
|
|
// WaitUntilInitialized mocks base method.
|
|
func (m *MockphysicalTaskQueueManager) WaitUntilInitialized(arg0 context.Context) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WaitUntilInitialized", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// WaitUntilInitialized indicates an expected call of WaitUntilInitialized.
|
|
func (mr *MockphysicalTaskQueueManagerMockRecorder) WaitUntilInitialized(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInitialized", reflect.TypeOf((*MockphysicalTaskQueueManager)(nil).WaitUntilInitialized), arg0)
|
|
}
|