dragonflyoss
/
dragonfly
mirror of https://github.com/dragonflyoss/dragonfly.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: rename scheduler package to scheduling (#2087) 

Signed-off-by: Gaius <gaius.qi@gmail.com>
This commit is contained in:
Gaius 2023-02-17 16:31:54 +08:00
parent 010396a0f8
commit dacf1f01a6
No known key found for this signature in database
GPG Key ID: 8B4E5D1290FA2FFB
22 changed files with 283 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
.github/workflows/ci.yml vendored
View File

@ -65,8 +65,11 @@ jobs:
with: with:
go-version: ${{ env.GO_VERSION }} go-version: ${{ env.GO_VERSION }}
- name: Setup Docker - name: Setup QEMU
uses: docker-practice/actions-setup-docker@v1 uses: docker/setup-qemu-action@v2
- name: Setup Docker Buildx
uses: docker/setup-buildx-action@v2
- name: Check out code - name: Check out code
uses: actions/checkout@v3 uses: actions/checkout@v3

8
scheduler/rpcserver/rpcserver.go
View File

@ -22,7 +22,7 @@ import (
"d7y.io/dragonfly/v2/pkg/rpc/scheduler/server" "d7y.io/dragonfly/v2/pkg/rpc/scheduler/server"
"d7y.io/dragonfly/v2/scheduler/config" "d7y.io/dragonfly/v2/scheduler/config"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler" "d7y.io/dragonfly/v2/scheduler/scheduling"
"d7y.io/dragonfly/v2/scheduler/storage" "d7y.io/dragonfly/v2/scheduler/storage"
) )
@ -30,13 +30,13 @@ import (
func New( func New(
cfg *config.Config, cfg *config.Config,
resource resource.Resource, resource resource.Resource,
scheduler scheduler.Scheduler, scheduling scheduling.Scheduling,
dynconfig config.DynconfigInterface, dynconfig config.DynconfigInterface,
storage storage.Storage, storage storage.Storage,
opts ...grpc.ServerOption, opts ...grpc.ServerOption,
) *grpc.Server { ) *grpc.Server {
return server.New( return server.New(
newSchedulerServerV1(cfg, resource, scheduler, dynconfig, storage), newSchedulerServerV1(cfg, resource, scheduling, dynconfig, storage),
newSchedulerServerV2(cfg, resource, scheduler, dynconfig, storage), newSchedulerServerV2(cfg, resource, scheduling, dynconfig, storage),
opts...) opts...)
} }

6
scheduler/rpcserver/rpcserver_test.go
View File

@ -27,7 +27,7 @@ import (
"d7y.io/dragonfly/v2/scheduler/config" "d7y.io/dragonfly/v2/scheduler/config"
configmocks "d7y.io/dragonfly/v2/scheduler/config/mocks" configmocks "d7y.io/dragonfly/v2/scheduler/config/mocks"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler/mocks" "d7y.io/dragonfly/v2/scheduler/scheduling/mocks"
storagemocks "d7y.io/dragonfly/v2/scheduler/storage/mocks" storagemocks "d7y.io/dragonfly/v2/scheduler/storage/mocks"
) )
@ -58,12 +58,12 @@ func TestRPCServer_New(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
svr := New(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduler, dynconfig, storage) svr := New(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduling, dynconfig, storage)
tc.expect(t, svr) tc.expect(t, svr)
}) })
} }

6
scheduler/rpcserver/scheduler_server_v1.go
View File

@ -27,7 +27,7 @@ import (
"d7y.io/dragonfly/v2/scheduler/config" "d7y.io/dragonfly/v2/scheduler/config"
"d7y.io/dragonfly/v2/scheduler/metrics" "d7y.io/dragonfly/v2/scheduler/metrics"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler" "d7y.io/dragonfly/v2/scheduler/scheduling"
"d7y.io/dragonfly/v2/scheduler/service" "d7y.io/dragonfly/v2/scheduler/service"
"d7y.io/dragonfly/v2/scheduler/storage" "d7y.io/dragonfly/v2/scheduler/storage"
) )
@ -42,11 +42,11 @@ type schedulerServerV1 struct {
func newSchedulerServerV1( func newSchedulerServerV1(
cfg *config.Config, cfg *config.Config,
resource resource.Resource, resource resource.Resource,
scheduler scheduler.Scheduler, scheduling scheduling.Scheduling,
dynconfig config.DynconfigInterface, dynconfig config.DynconfigInterface,
storage storage.Storage, storage storage.Storage,
) schedulerv1.SchedulerServer { ) schedulerv1.SchedulerServer {
return &schedulerServerV1{service.NewV1(cfg, resource, scheduler, dynconfig, storage)} return &schedulerServerV1{service.NewV1(cfg, resource, scheduling, dynconfig, storage)}
} }
// RegisterPeerTask registers peer and triggers seed peer download task. // RegisterPeerTask registers peer and triggers seed peer download task.

6
scheduler/rpcserver/scheduler_server_v2.go
View File

@ -26,7 +26,7 @@ import (
"d7y.io/dragonfly/v2/scheduler/config" "d7y.io/dragonfly/v2/scheduler/config"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler" "d7y.io/dragonfly/v2/scheduler/scheduling"
"d7y.io/dragonfly/v2/scheduler/service" "d7y.io/dragonfly/v2/scheduler/service"
"d7y.io/dragonfly/v2/scheduler/storage" "d7y.io/dragonfly/v2/scheduler/storage"
) )
@ -42,11 +42,11 @@ type schedulerServerV2 struct {
func newSchedulerServerV2( func newSchedulerServerV2(
cfg *config.Config, cfg *config.Config,
resource resource.Resource, resource resource.Resource,
scheduler scheduler.Scheduler, scheduling scheduling.Scheduling,
dynconfig config.DynconfigInterface, dynconfig config.DynconfigInterface,
storage storage.Storage, storage storage.Storage,
) schedulerv2.SchedulerServer { ) schedulerv2.SchedulerServer {
return &schedulerServerV2{service.NewV2(cfg, resource, scheduler, dynconfig, storage)} return &schedulerServerV2{service.NewV2(cfg, resource, scheduling, dynconfig, storage)}
} }
// AnnouncePeer announces peer to scheduler. // AnnouncePeer announces peer to scheduler.

8
scheduler/scheduler.go
View File

@ -49,7 +49,7 @@ import (
"d7y.io/dragonfly/v2/scheduler/metrics" "d7y.io/dragonfly/v2/scheduler/metrics"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/rpcserver" "d7y.io/dragonfly/v2/scheduler/rpcserver"
"d7y.io/dragonfly/v2/scheduler/scheduler" "d7y.io/dragonfly/v2/scheduler/scheduling"
"d7y.io/dragonfly/v2/scheduler/storage" "d7y.io/dragonfly/v2/scheduler/storage"
) )
@ -182,8 +182,8 @@ func New(ctx context.Context, cfg *config.Config, d dfpath.Dfpath) (*Server, err
} }
s.resource = resource s.resource = resource
// Initialize scheduler. // Initialize scheduling.
scheduler := scheduler.New(&cfg.Scheduler, dynconfig, d.PluginDir()) scheduling := scheduling.New(&cfg.Scheduler, dynconfig, d.PluginDir())
// Initialize Storage. // Initialize Storage.
storage, err := storage.New( storage, err := storage.New(
@ -210,7 +210,7 @@ func New(ctx context.Context, cfg *config.Config, d dfpath.Dfpath) (*Server, err
schedulerServerOptions = append(schedulerServerOptions, grpc.Creds(insecure.NewCredentials())) schedulerServerOptions = append(schedulerServerOptions, grpc.Creds(insecure.NewCredentials()))
} }
svr := rpcserver.New(cfg, resource, scheduler, dynconfig, s.storage, schedulerServerOptions...) svr := rpcserver.New(cfg, resource, scheduling, dynconfig, s.storage, schedulerServerOptions...)
s.grpcServer = svr s.grpcServer = svr
// Initialize job service. // Initialize job service.

79
scheduler/scheduler/mocks/scheduler_mock.go
View File

@ -1,79 +0,0 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: scheduler.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
set "d7y.io/dragonfly/v2/pkg/container/set"
resource "d7y.io/dragonfly/v2/scheduler/resource"
gomock "github.com/golang/mock/gomock"
)
// MockScheduler is a mock of Scheduler interface.
type MockScheduler struct {
ctrl *gomock.Controller
recorder *MockSchedulerMockRecorder
}
// MockSchedulerMockRecorder is the mock recorder for MockScheduler.
type MockSchedulerMockRecorder struct {
mock *MockScheduler
}
// NewMockScheduler creates a new mock instance.
func NewMockScheduler(ctrl *gomock.Controller) *MockScheduler {
mock := &MockScheduler{ctrl: ctrl}
mock.recorder = &MockSchedulerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockScheduler) EXPECT() *MockSchedulerMockRecorder {
return m.recorder
}
// FindParent mocks base method.
func (m *MockScheduler) FindParent(arg0 context.Context, arg1 *resource.Peer, arg2 set.SafeSet[string]) (*resource.Peer, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindParent", arg0, arg1, arg2)
ret0, _ := ret[0].(*resource.Peer)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// FindParent indicates an expected call of FindParent.
func (mr *MockSchedulerMockRecorder) FindParent(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindParent", reflect.TypeOf((*MockScheduler)(nil).FindParent), arg0, arg1, arg2)
}
// NotifyAndFindParent mocks base method.
func (m *MockScheduler) NotifyAndFindParent(arg0 context.Context, arg1 *resource.Peer, arg2 set.SafeSet[string]) ([]*resource.Peer, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NotifyAndFindParent", arg0, arg1, arg2)
ret0, _ := ret[0].([]*resource.Peer)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// NotifyAndFindParent indicates an expected call of NotifyAndFindParent.
func (mr *MockSchedulerMockRecorder) NotifyAndFindParent(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyAndFindParent", reflect.TypeOf((*MockScheduler)(nil).NotifyAndFindParent), arg0, arg1, arg2)
}
// ScheduleParent mocks base method.
func (m *MockScheduler) ScheduleParent(arg0 context.Context, arg1 *resource.Peer, arg2 set.SafeSet[string]) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "ScheduleParent", arg0, arg1, arg2)
}
// ScheduleParent indicates an expected call of ScheduleParent.
func (mr *MockSchedulerMockRecorder) ScheduleParent(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleParent", reflect.TypeOf((*MockScheduler)(nil).ScheduleParent), arg0, arg1, arg2)
}

0
scheduler/scheduler/evaluator/evaluator.go → scheduler/scheduling/evaluator/evaluator.go
View File

0
scheduler/scheduler/evaluator/evaluator_base.go → scheduler/scheduling/evaluator/evaluator_base.go
View File

0
scheduler/scheduler/evaluator/evaluator_base_test.go → scheduler/scheduling/evaluator/evaluator_base_test.go
View File

0
scheduler/scheduler/evaluator/evaluator_test.go → scheduler/scheduling/evaluator/evaluator_test.go
View File

0
scheduler/scheduler/evaluator/plugin.go → scheduler/scheduling/evaluator/plugin.go
View File

0
scheduler/scheduler/evaluator/plugin_test.go → scheduler/scheduling/evaluator/plugin_test.go
View File

2
scheduler/scheduler/evaluator/testdata/main.go → scheduler/scheduling/evaluator/testdata/main.go vendored
View File

@ -21,7 +21,7 @@ import (
"os" "os"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler/evaluator" "d7y.io/dragonfly/v2/scheduler/scheduling/evaluator"
) )
func main() { func main() {

0
scheduler/scheduler/evaluator/testdata/plugin/evaluator.go → scheduler/scheduling/evaluator/testdata/plugin/evaluator.go vendored
View File

79
scheduler/scheduling/mocks/scheduling_mock.go Normal file
View File

@ -0,0 +1,79 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: scheduling.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
set "d7y.io/dragonfly/v2/pkg/container/set"
resource "d7y.io/dragonfly/v2/scheduler/resource"
gomock "github.com/golang/mock/gomock"
)
// MockScheduling is a mock of Scheduling interface.
type MockScheduling struct {
ctrl *gomock.Controller
recorder *MockSchedulingMockRecorder
}
// MockSchedulingMockRecorder is the mock recorder for MockScheduling.
type MockSchedulingMockRecorder struct {
mock *MockScheduling
}
// NewMockScheduling creates a new mock instance.
func NewMockScheduling(ctrl *gomock.Controller) *MockScheduling {
mock := &MockScheduling{ctrl: ctrl}
mock.recorder = &MockSchedulingMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockScheduling) EXPECT() *MockSchedulingMockRecorder {
return m.recorder
}
// FindParent mocks base method.
func (m *MockScheduling) FindParent(arg0 context.Context, arg1 *resource.Peer, arg2 set.SafeSet[string]) (*resource.Peer, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindParent", arg0, arg1, arg2)
ret0, _ := ret[0].(*resource.Peer)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// FindParent indicates an expected call of FindParent.
func (mr *MockSchedulingMockRecorder) FindParent(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindParent", reflect.TypeOf((*MockScheduling)(nil).FindParent), arg0, arg1, arg2)
}
// NotifyAndFindParent mocks base method.
func (m *MockScheduling) NotifyAndFindParent(arg0 context.Context, arg1 *resource.Peer, arg2 set.SafeSet[string]) ([]*resource.Peer, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NotifyAndFindParent", arg0, arg1, arg2)
ret0, _ := ret[0].([]*resource.Peer)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
// NotifyAndFindParent indicates an expected call of NotifyAndFindParent.
func (mr *MockSchedulingMockRecorder) NotifyAndFindParent(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyAndFindParent", reflect.TypeOf((*MockScheduling)(nil).NotifyAndFindParent), arg0, arg1, arg2)
}
// ScheduleParent mocks base method.
func (m *MockScheduling) ScheduleParent(arg0 context.Context, arg1 *resource.Peer, arg2 set.SafeSet[string]) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "ScheduleParent", arg0, arg1, arg2)
}
// ScheduleParent indicates an expected call of ScheduleParent.
func (mr *MockSchedulingMockRecorder) ScheduleParent(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleParent", reflect.TypeOf((*MockScheduling)(nil).ScheduleParent), arg0, arg1, arg2)
}

22
scheduler/scheduler/scheduler.go → scheduler/scheduling/scheduling.go
View File

@ -14,9 +14,9 @@
* limitations under the License. * limitations under the License.
*/ */
//go:generate mockgen -destination mocks/scheduler_mock.go -source scheduler.go -package mocks //go:generate mockgen -destination mocks/scheduling_mock.go -source scheduling.go -package mocks
package scheduler package scheduling
import ( import (
"context" "context"
@ -30,10 +30,10 @@ import (
"d7y.io/dragonfly/v2/pkg/types" "d7y.io/dragonfly/v2/pkg/types"
"d7y.io/dragonfly/v2/scheduler/config" "d7y.io/dragonfly/v2/scheduler/config"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler/evaluator" "d7y.io/dragonfly/v2/scheduler/scheduling/evaluator"
) )
type Scheduler interface { type Scheduling interface {
// ScheduleParent schedule a parent and candidates to a peer. // ScheduleParent schedule a parent and candidates to a peer.
ScheduleParent(context.Context, *resource.Peer, set.SafeSet[string]) ScheduleParent(context.Context, *resource.Peer, set.SafeSet[string])
@ -44,7 +44,7 @@ type Scheduler interface {
FindParent(context.Context, *resource.Peer, set.SafeSet[string]) (*resource.Peer, bool) FindParent(context.Context, *resource.Peer, set.SafeSet[string]) (*resource.Peer, bool)
} }
type scheduler struct { type scheduling struct {
// Evaluator interface. // Evaluator interface.
evaluator evaluator.Evaluator evaluator evaluator.Evaluator
@ -55,8 +55,8 @@ type scheduler struct {
dynconfig config.DynconfigInterface dynconfig config.DynconfigInterface
} }
func New(cfg *config.SchedulerConfig, dynconfig config.DynconfigInterface, pluginDir string) Scheduler { func New(cfg *config.SchedulerConfig, dynconfig config.DynconfigInterface, pluginDir string) Scheduling {
return &scheduler{ return &scheduling{
evaluator: evaluator.New(cfg.Algorithm, pluginDir), evaluator: evaluator.New(cfg.Algorithm, pluginDir),
config: cfg, config: cfg,
dynconfig: dynconfig, dynconfig: dynconfig,
@ -64,7 +64,7 @@ func New(cfg *config.SchedulerConfig, dynconfig config.DynconfigInterface, plugi
} }
// ScheduleParent schedule a parent and candidates to a peer. // ScheduleParent schedule a parent and candidates to a peer.
func (s *scheduler) ScheduleParent(ctx context.Context, peer *resource.Peer, blocklist set.SafeSet[string]) { func (s *scheduling) ScheduleParent(ctx context.Context, peer *resource.Peer, blocklist set.SafeSet[string]) {
var n int var n int
for { for {
select { select {
@ -142,7 +142,7 @@ func (s *scheduler) ScheduleParent(ctx context.Context, peer *resource.Peer, blo
} }
// NotifyAndFindParent finds parent that best matches the evaluation and notify peer. // NotifyAndFindParent finds parent that best matches the evaluation and notify peer.
func (s *scheduler) NotifyAndFindParent(ctx context.Context, peer *resource.Peer, blocklist set.SafeSet[string]) ([]*resource.Peer, bool) { func (s *scheduling) NotifyAndFindParent(ctx context.Context, peer *resource.Peer, blocklist set.SafeSet[string]) ([]*resource.Peer, bool) {
// Only PeerStateRunning peers need to be rescheduled, // Only PeerStateRunning peers need to be rescheduled,
// and other states including the PeerStateBackToSource indicate that // and other states including the PeerStateBackToSource indicate that
// they have been scheduled. // they have been scheduled.
@ -209,7 +209,7 @@ func (s *scheduler) NotifyAndFindParent(ctx context.Context, peer *resource.Peer
} }
// FindParent finds parent that best matches the evaluation. // FindParent finds parent that best matches the evaluation.
func (s *scheduler) FindParent(ctx context.Context, peer *resource.Peer, blocklist set.SafeSet[string]) (*resource.Peer, bool) { func (s *scheduling) FindParent(ctx context.Context, peer *resource.Peer, blocklist set.SafeSet[string]) (*resource.Peer, bool) {
// Filter the candidate parent that can be scheduled. // Filter the candidate parent that can be scheduled.
candidateParents := s.filterCandidateParents(peer, blocklist) candidateParents := s.filterCandidateParents(peer, blocklist)
if len(candidateParents) == 0 { if len(candidateParents) == 0 {
@ -231,7 +231,7 @@ func (s *scheduler) FindParent(ctx context.Context, peer *resource.Peer, blockli
} }
// Filter the candidate parent that can be scheduled. // Filter the candidate parent that can be scheduled.
func (s *scheduler) filterCandidateParents(peer *resource.Peer, blocklist set.SafeSet[string]) []*resource.Peer { func (s *scheduling) filterCandidateParents(peer *resource.Peer, blocklist set.SafeSet[string]) []*resource.Peer {
filterParentLimit := config.DefaultSchedulerFilterParentLimit filterParentLimit := config.DefaultSchedulerFilterParentLimit
filterParentRangeLimit := config.DefaultSchedulerFilterParentRangeLimit filterParentRangeLimit := config.DefaultSchedulerFilterParentRangeLimit
if config, err := s.dynconfig.GetSchedulerClusterConfig(); err == nil { if config, err := s.dynconfig.GetSchedulerClusterConfig(); err == nil {

34
scheduler/scheduler/scheduler_test.go → scheduler/scheduling/scheduling_test.go
View File

@ -14,7 +14,7 @@
* limitations under the License. * limitations under the License.
*/ */
package scheduler package scheduling
import ( import (
"context" "context"
@ -41,7 +41,7 @@ import (
"d7y.io/dragonfly/v2/scheduler/config" "d7y.io/dragonfly/v2/scheduler/config"
configmocks "d7y.io/dragonfly/v2/scheduler/config/mocks" configmocks "d7y.io/dragonfly/v2/scheduler/config/mocks"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler/evaluator" "d7y.io/dragonfly/v2/scheduler/scheduling/evaluator"
) )
var ( var (
@ -164,26 +164,26 @@ var (
mockSeedPeerID = idgen.PeerIDV2() mockSeedPeerID = idgen.PeerIDV2()
) )
func TestScheduler_New(t *testing.T) { func TestScheduling_New(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
pluginDir string pluginDir string
expect func(t *testing.T, s any) expect func(t *testing.T, s any)
}{ }{
{ {
name: "new scheduler", name: "new scheduling",
pluginDir: "bar", pluginDir: "bar",
expect: func(t *testing.T, s any) { expect: func(t *testing.T, s any) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(reflect.TypeOf(s).Elem().Name(), "scheduler") assert.Equal(reflect.TypeOf(s).Elem().Name(), "scheduling")
}, },
}, },
{ {
name: "new scheduler with empty pluginDir", name: "new scheduling with empty pluginDir",
pluginDir: "", pluginDir: "",
expect: func(t *testing.T, s any) { expect: func(t *testing.T, s any) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(reflect.TypeOf(s).Elem().Name(), "scheduler") assert.Equal(reflect.TypeOf(s).Elem().Name(), "scheduling")
}, },
}, },
} }
@ -199,7 +199,7 @@ func TestScheduler_New(t *testing.T) {
} }
} }
func TestScheduler_ScheduleParent(t *testing.T) { func TestScheduling_ScheduleParent(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
mock func(cancel context.CancelFunc, peer *resource.Peer, seedPeer *resource.Peer, blocklist set.SafeSet[string], stream schedulerv1.Scheduler_ReportPieceResultServer, mr *mocks.MockScheduler_ReportPieceResultServerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder) mock func(cancel context.CancelFunc, peer *resource.Peer, seedPeer *resource.Peer, blocklist set.SafeSet[string], stream schedulerv1.Scheduler_ReportPieceResultServer, mr *mocks.MockScheduler_ReportPieceResultServerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder)
@ -395,14 +395,14 @@ func TestScheduler_ScheduleParent(t *testing.T) {
blocklist := set.NewSafeSet[string]() blocklist := set.NewSafeSet[string]()
tc.mock(cancel, peer, seedPeer, blocklist, stream, stream.EXPECT(), dynconfig.EXPECT()) tc.mock(cancel, peer, seedPeer, blocklist, stream, stream.EXPECT(), dynconfig.EXPECT())
scheduler := New(mockSchedulerConfig, dynconfig, mockPluginDir) scheduling := New(mockSchedulerConfig, dynconfig, mockPluginDir)
scheduler.ScheduleParent(ctx, peer, blocklist) scheduling.ScheduleParent(ctx, peer, blocklist)
tc.expect(t, peer) tc.expect(t, peer)
}) })
} }
} }
func TestScheduler_NotifyAndFindParent(t *testing.T) { func TestScheduling_NotifyAndFindParent(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
mock func(peer *resource.Peer, mockTask *resource.Task, mockPeer *resource.Peer, blocklist set.SafeSet[string], stream schedulerv1.Scheduler_ReportPieceResultServer, dynconfig config.DynconfigInterface, ms *mocks.MockScheduler_ReportPieceResultServerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder) mock func(peer *resource.Peer, mockTask *resource.Task, mockPeer *resource.Peer, blocklist set.SafeSet[string], stream schedulerv1.Scheduler_ReportPieceResultServer, dynconfig config.DynconfigInterface, ms *mocks.MockScheduler_ReportPieceResultServerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder)
@ -673,14 +673,14 @@ func TestScheduler_NotifyAndFindParent(t *testing.T) {
blocklist := set.NewSafeSet[string]() blocklist := set.NewSafeSet[string]()
tc.mock(peer, mockTask, mockPeer, blocklist, stream, dynconfig, stream.EXPECT(), dynconfig.EXPECT()) tc.mock(peer, mockTask, mockPeer, blocklist, stream, dynconfig, stream.EXPECT(), dynconfig.EXPECT())
scheduler := New(mockSchedulerConfig, dynconfig, mockPluginDir) scheduling := New(mockSchedulerConfig, dynconfig, mockPluginDir)
parents, ok := scheduler.NotifyAndFindParent(context.Background(), peer, blocklist) parents, ok := scheduling.NotifyAndFindParent(context.Background(), peer, blocklist)
tc.expect(t, peer, parents, ok) tc.expect(t, peer, parents, ok)
}) })
} }
} }
func TestScheduler_FindParent(t *testing.T) { func TestScheduling_FindParent(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
mock func(peer *resource.Peer, mockPeers []*resource.Peer, blocklist set.SafeSet[string], md *configmocks.MockDynconfigInterfaceMockRecorder) mock func(peer *resource.Peer, mockPeers []*resource.Peer, blocklist set.SafeSet[string], md *configmocks.MockDynconfigInterfaceMockRecorder)
@ -950,14 +950,14 @@ func TestScheduler_FindParent(t *testing.T) {
blocklist := set.NewSafeSet[string]() blocklist := set.NewSafeSet[string]()
tc.mock(peer, mockPeers, blocklist, dynconfig.EXPECT()) tc.mock(peer, mockPeers, blocklist, dynconfig.EXPECT())
scheduler := New(mockSchedulerConfig, dynconfig, mockPluginDir) scheduling := New(mockSchedulerConfig, dynconfig, mockPluginDir)
parent, found := scheduler.FindParent(context.Background(), peer, blocklist) parent, found := scheduling.FindParent(context.Background(), peer, blocklist)
tc.expect(t, peer, mockPeers, parent, found) tc.expect(t, peer, mockPeers, parent, found)
}) })
} }
} }
func TestScheduler_constructSuccessPeerPacket(t *testing.T) { func TestScheduling_constructSuccessPeerPacket(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
mock func(md *configmocks.MockDynconfigInterfaceMockRecorder) mock func(md *configmocks.MockDynconfigInterfaceMockRecorder)

30
scheduler/service/service_v1.go
View File

@ -44,7 +44,7 @@ import (
"d7y.io/dragonfly/v2/scheduler/config" "d7y.io/dragonfly/v2/scheduler/config"
"d7y.io/dragonfly/v2/scheduler/metrics" "d7y.io/dragonfly/v2/scheduler/metrics"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler" "d7y.io/dragonfly/v2/scheduler/scheduling"
"d7y.io/dragonfly/v2/scheduler/storage" "d7y.io/dragonfly/v2/scheduler/storage"
) )
@ -53,8 +53,8 @@ type V1 struct {
// Resource interface. // Resource interface.
resource resource.Resource resource resource.Resource
// Scheduler interface. // Scheduling interface.
scheduler scheduler.Scheduler scheduling scheduling.Scheduling
// Scheduelr service config. // Scheduelr service config.
config *config.Config config *config.Config
@ -70,16 +70,16 @@ type V1 struct {
func NewV1( func NewV1(
cfg *config.Config, cfg *config.Config,
resource resource.Resource, resource resource.Resource,
scheduler scheduler.Scheduler, scheduling scheduling.Scheduling,
dynconfig config.DynconfigInterface, dynconfig config.DynconfigInterface,
storage storage.Storage, storage storage.Storage,
) *V1 { ) *V1 {
return &V1{ return &V1{
resource: resource, resource: resource,
scheduler: scheduler, scheduling: scheduling,
config: cfg, config: cfg,
dynconfig: dynconfig, dynconfig: dynconfig,
storage: storage, storage: storage,
} }
} }
@ -851,7 +851,7 @@ func (v *V1) registerTinyTask(ctx context.Context, peer *resource.Peer) (*schedu
// registerSmallTask registers the small task. // registerSmallTask registers the small task.
func (v *V1) registerSmallTask(ctx context.Context, peer *resource.Peer) (*schedulerv1.RegisterResult, error) { func (v *V1) registerSmallTask(ctx context.Context, peer *resource.Peer) (*schedulerv1.RegisterResult, error) {
parent, found := v.scheduler.FindParent(ctx, peer, set.NewSafeSet[string]()) parent, found := v.scheduling.FindParent(ctx, peer, set.NewSafeSet[string]())
if !found { if !found {
return nil, errors.New("parent not found") return nil, errors.New("parent not found")
} }
@ -962,7 +962,7 @@ func (v *V1) handleBeginOfPiece(ctx context.Context, peer *resource.Peer) {
return return
} }
v.scheduler.ScheduleParent(ctx, peer, set.NewSafeSet[string]()) v.scheduling.ScheduleParent(ctx, peer, set.NewSafeSet[string]())
default: default:
} }
} }
@ -1032,7 +1032,7 @@ func (v *V1) handlePieceFailure(ctx context.Context, peer *resource.Peer, piece
if !loaded { if !loaded {
peer.Log.Errorf("parent %s not found", piece.DstPid) peer.Log.Errorf("parent %s not found", piece.DstPid)
peer.BlockParents.Add(piece.DstPid) peer.BlockParents.Add(piece.DstPid)
v.scheduler.ScheduleParent(ctx, peer, peer.BlockParents) v.scheduling.ScheduleParent(ctx, peer, peer.BlockParents)
return return
} }
@ -1091,7 +1091,7 @@ func (v *V1) handlePieceFailure(ctx context.Context, peer *resource.Peer, piece
peer.Log.Infof("reschedule parent because of failed piece") peer.Log.Infof("reschedule parent because of failed piece")
peer.BlockParents.Add(parent.ID) peer.BlockParents.Add(parent.ID)
v.scheduler.ScheduleParent(ctx, peer, peer.BlockParents) v.scheduling.ScheduleParent(ctx, peer, peer.BlockParents)
} }
// handlePeerSuccess handles successful peer. // handlePeerSuccess handles successful peer.
@ -1139,7 +1139,7 @@ func (v *V1) handlePeerFailure(ctx context.Context, peer *resource.Peer) {
// Reschedule a new parent to children of peer to exclude the current failed peer. // Reschedule a new parent to children of peer to exclude the current failed peer.
for _, child := range peer.Children() { for _, child := range peer.Children() {
child.Log.Infof("reschedule parent because of parent peer %s is failed", peer.ID) child.Log.Infof("reschedule parent because of parent peer %s is failed", peer.ID)
v.scheduler.ScheduleParent(ctx, child, child.BlockParents) v.scheduling.ScheduleParent(ctx, child, child.BlockParents)
} }
} }
@ -1154,7 +1154,7 @@ func (v *V1) handleLegacySeedPeer(ctx context.Context, peer *resource.Peer) {
// Reschedule a new parent to children of peer to exclude the current failed peer. // Reschedule a new parent to children of peer to exclude the current failed peer.
for _, child := range peer.Children() { for _, child := range peer.Children() {
child.Log.Infof("reschedule parent because of parent peer %s is failed", peer.ID) child.Log.Infof("reschedule parent because of parent peer %s is failed", peer.ID)
v.scheduler.ScheduleParent(ctx, child, child.BlockParents) v.scheduling.ScheduleParent(ctx, child, child.BlockParents)
} }
} }

250
scheduler/service/service_v1_test.go
View File

@ -54,8 +54,8 @@ import (
"d7y.io/dragonfly/v2/scheduler/config" "d7y.io/dragonfly/v2/scheduler/config"
configmocks "d7y.io/dragonfly/v2/scheduler/config/mocks" configmocks "d7y.io/dragonfly/v2/scheduler/config/mocks"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler" "d7y.io/dragonfly/v2/scheduler/scheduling"
"d7y.io/dragonfly/v2/scheduler/scheduler/mocks" "d7y.io/dragonfly/v2/scheduler/scheduling/mocks"
"d7y.io/dragonfly/v2/scheduler/storage" "d7y.io/dragonfly/v2/scheduler/storage"
storagemocks "d7y.io/dragonfly/v2/scheduler/storage/mocks" storagemocks "d7y.io/dragonfly/v2/scheduler/storage/mocks"
) )
@ -213,11 +213,11 @@ func TestService_NewV1(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
resource := resource.NewMockResource(ctl) resource := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
tc.expect(t, NewV1(&config.Config{Scheduler: mockSchedulerConfig}, resource, scheduler, dynconfig, storage)) tc.expect(t, NewV1(&config.Config{Scheduler: mockSchedulerConfig}, resource, scheduling, dynconfig, storage))
}) })
} }
} }
@ -228,8 +228,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
req *schedulerv1.PeerTaskRequest req *schedulerv1.PeerTaskRequest
mock func( mock func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) )
expect func(t *testing.T, peer *resource.Peer, result *schedulerv1.RegisterResult, err error) expect func(t *testing.T, peer *resource.Peer, result *schedulerv1.RegisterResult, err error)
@ -246,8 +246,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateRunning) mockPeer.Task.FSM.SetState(resource.TaskStateRunning)
@ -282,8 +282,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduler scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStatePending) mockPeer.Task.FSM.SetState(resource.TaskStatePending)
@ -327,8 +327,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateRunning) mockPeer.Task.FSM.SetState(resource.TaskStateRunning)
@ -367,8 +367,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -405,8 +405,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -445,8 +445,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -487,8 +487,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -526,8 +526,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -568,8 +568,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -614,8 +614,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -662,8 +662,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -710,8 +710,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -754,8 +754,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -799,8 +799,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -841,8 +841,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
}, },
mock: func( mock: func(
req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer, req *schedulerv1.PeerTaskRequest, mockPeer *resource.Peer, mockSeedPeer *resource.Peer,
scheduler scheduler.Scheduler, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager, scheduling scheduling.Scheduling, res resource.Resource, hostManager resource.HostManager, taskManager resource.TaskManager, peerManager resource.PeerManager,
ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder, mt *resource.MockTaskManagerMockRecorder,
mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder, mp *resource.MockPeerManagerMockRecorder, md *configmocks.MockDynconfigInterfaceMockRecorder,
) { ) {
mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded) mockPeer.Task.FSM.SetState(resource.TaskStateSucceeded)
@ -874,14 +874,14 @@ func TestService_RegisterPeerTask(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
hostManager := resource.NewMockHostManager(ctl) hostManager := resource.NewMockHostManager(ctl)
taskManager := resource.NewMockTaskManager(ctl) taskManager := resource.NewMockTaskManager(ctl)
peerManager := resource.NewMockPeerManager(ctl) peerManager := resource.NewMockPeerManager(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduling, dynconfig, storage)
mockHost := resource.NewHost( mockHost := resource.NewHost(
mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname, mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname,
@ -894,8 +894,8 @@ func TestService_RegisterPeerTask(t *testing.T) {
mockSeedPeer := resource.NewPeer(mockSeedPeerID, mockTask, mockSeedHost) mockSeedPeer := resource.NewPeer(mockSeedPeerID, mockTask, mockSeedHost)
tc.mock( tc.mock(
tc.req, mockPeer, mockSeedPeer, tc.req, mockPeer, mockSeedPeer,
scheduler, res, hostManager, taskManager, peerManager, scheduling, res, hostManager, taskManager, peerManager,
scheduler.EXPECT(), res.EXPECT(), hostManager.EXPECT(), scheduling.EXPECT(), res.EXPECT(), hostManager.EXPECT(),
taskManager.EXPECT(), peerManager.EXPECT(), dynconfig.EXPECT(), taskManager.EXPECT(), peerManager.EXPECT(), dynconfig.EXPECT(),
) )
@ -1139,13 +1139,13 @@ func TestService_ReportPieceResult(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
peerManager := resource.NewMockPeerManager(ctl) peerManager := resource.NewMockPeerManager(ctl)
stream := schedulerv1mocks.NewMockScheduler_ReportPieceResultServer(ctl) stream := schedulerv1mocks.NewMockScheduler_ReportPieceResultServer(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduling, dynconfig, storage)
mockHost := resource.NewHost( mockHost := resource.NewHost(
mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname, mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname,
@ -1338,12 +1338,12 @@ func TestService_ReportPeerResult(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
peerManager := resource.NewMockPeerManager(ctl) peerManager := resource.NewMockPeerManager(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduling, dynconfig, storage)
mockHost := resource.NewHost( mockHost := resource.NewHost(
mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname, mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname,
@ -1402,12 +1402,12 @@ func TestService_StatTask(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
taskManager := resource.NewMockTaskManager(ctl) taskManager := resource.NewMockTaskManager(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduling, dynconfig, storage)
mockTask := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength)) mockTask := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength))
tc.mock(mockTask, taskManager, res.EXPECT(), taskManager.EXPECT()) tc.mock(mockTask, taskManager, res.EXPECT(), taskManager.EXPECT())
@ -1696,14 +1696,14 @@ func TestService_AnnounceTask(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
hostManager := resource.NewMockHostManager(ctl) hostManager := resource.NewMockHostManager(ctl)
taskManager := resource.NewMockTaskManager(ctl) taskManager := resource.NewMockTaskManager(ctl)
peerManager := resource.NewMockPeerManager(ctl) peerManager := resource.NewMockPeerManager(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduling, dynconfig, storage)
mockHost := resource.NewHost( mockHost := resource.NewHost(
mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname, mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname,
mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type) mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type)
@ -1719,12 +1719,12 @@ func TestService_AnnounceTask(t *testing.T) {
func TestService_LeaveTask(t *testing.T) { func TestService_LeaveTask(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
mock func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) mock func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder)
expect func(t *testing.T, peer *resource.Peer, err error) expect func(t *testing.T, peer *resource.Peer, err error)
}{ }{
{ {
name: "peer state is PeerStateLeave", name: "peer state is PeerStateLeave",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
peer.FSM.SetState(resource.PeerStateLeave) peer.FSM.SetState(resource.PeerStateLeave)
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
@ -1741,7 +1741,7 @@ func TestService_LeaveTask(t *testing.T) {
}, },
{ {
name: "peer not found", name: "peer not found",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
mp.Load(gomock.Any()).Return(nil, false).Times(1), mp.Load(gomock.Any()).Return(nil, false).Times(1),
@ -1756,7 +1756,7 @@ func TestService_LeaveTask(t *testing.T) {
}, },
{ {
name: "peer state is PeerStatePending", name: "peer state is PeerStatePending",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
peer.FSM.SetState(resource.PeerStatePending) peer.FSM.SetState(resource.PeerStatePending)
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
@ -1771,7 +1771,7 @@ func TestService_LeaveTask(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedEmpty", name: "peer state is PeerStateReceivedEmpty",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
peer.FSM.SetState(resource.PeerStateReceivedEmpty) peer.FSM.SetState(resource.PeerStateReceivedEmpty)
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
@ -1786,7 +1786,7 @@ func TestService_LeaveTask(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedTiny", name: "peer state is PeerStateReceivedTiny",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
peer.FSM.SetState(resource.PeerStateReceivedTiny) peer.FSM.SetState(resource.PeerStateReceivedTiny)
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
@ -1801,7 +1801,7 @@ func TestService_LeaveTask(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedSmall", name: "peer state is PeerStateReceivedSmall",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
peer.FSM.SetState(resource.PeerStateReceivedSmall) peer.FSM.SetState(resource.PeerStateReceivedSmall)
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
@ -1816,7 +1816,7 @@ func TestService_LeaveTask(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedNormal", name: "peer state is PeerStateReceivedNormal",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
peer.FSM.SetState(resource.PeerStateReceivedNormal) peer.FSM.SetState(resource.PeerStateReceivedNormal)
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
@ -1832,7 +1832,7 @@ func TestService_LeaveTask(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateRunning", name: "peer state is PeerStateRunning",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
peer.FSM.SetState(resource.PeerStateRunning) peer.FSM.SetState(resource.PeerStateRunning)
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
@ -1847,7 +1847,7 @@ func TestService_LeaveTask(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateBackToSource", name: "peer state is PeerStateBackToSource",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
peer.FSM.SetState(resource.PeerStateBackToSource) peer.FSM.SetState(resource.PeerStateBackToSource)
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
@ -1862,7 +1862,7 @@ func TestService_LeaveTask(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateFailed", name: "peer state is PeerStateFailed",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
peer.FSM.SetState(resource.PeerStateFailed) peer.FSM.SetState(resource.PeerStateFailed)
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
@ -1877,7 +1877,7 @@ func TestService_LeaveTask(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateSucceeded", name: "peer state is PeerStateSucceeded",
mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) { mock: func(peer *resource.Peer, peerManager resource.PeerManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder) {
peer.FSM.SetState(resource.PeerStateSucceeded) peer.FSM.SetState(resource.PeerStateSucceeded)
gomock.InOrder( gomock.InOrder(
mr.PeerManager().Return(peerManager).Times(1), mr.PeerManager().Return(peerManager).Times(1),
@ -1896,7 +1896,7 @@ func TestService_LeaveTask(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
@ -1906,9 +1906,9 @@ func TestService_LeaveTask(t *testing.T) {
mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type) mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type)
mockTask := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength)) mockTask := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength))
peer := resource.NewPeer(mockSeedPeerID, mockTask, mockHost) peer := resource.NewPeer(mockSeedPeerID, mockTask, mockHost)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduling, dynconfig, storage)
tc.mock(peer, peerManager, scheduler.EXPECT(), res.EXPECT(), peerManager.EXPECT()) tc.mock(peer, peerManager, scheduling.EXPECT(), res.EXPECT(), peerManager.EXPECT())
tc.expect(t, peer, svc.LeaveTask(context.Background(), &schedulerv1.PeerTarget{})) tc.expect(t, peer, svc.LeaveTask(context.Background(), &schedulerv1.PeerTarget{}))
}) })
} }
@ -1917,12 +1917,12 @@ func TestService_LeaveTask(t *testing.T) {
func TestService_LeaveHost(t *testing.T) { func TestService_LeaveHost(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
mock func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) mock func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder)
expect func(t *testing.T, peer *resource.Peer, err error) expect func(t *testing.T, peer *resource.Peer, err error)
}{ }{
{ {
name: "host not found", name: "host not found",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
gomock.InOrder( gomock.InOrder(
mr.HostManager().Return(hostManager).Times(1), mr.HostManager().Return(hostManager).Times(1),
mh.Load(gomock.Any()).Return(nil, false).Times(1), mh.Load(gomock.Any()).Return(nil, false).Times(1),
@ -1935,7 +1935,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "host has not peers", name: "host has not peers",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
gomock.InOrder( gomock.InOrder(
mr.HostManager().Return(hostManager).Times(1), mr.HostManager().Return(hostManager).Times(1),
mh.Load(gomock.Any()).Return(host, true).Times(1), mh.Load(gomock.Any()).Return(host, true).Times(1),
@ -1948,7 +1948,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateLeave", name: "peer state is PeerStateLeave",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
host.Peers.Store(mockPeer.ID, mockPeer) host.Peers.Store(mockPeer.ID, mockPeer)
mockPeer.FSM.SetState(resource.PeerStateLeave) mockPeer.FSM.SetState(resource.PeerStateLeave)
gomock.InOrder( gomock.InOrder(
@ -1963,7 +1963,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "peer state is PeerStatePending", name: "peer state is PeerStatePending",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
host.Peers.Store(mockPeer.ID, mockPeer) host.Peers.Store(mockPeer.ID, mockPeer)
mockPeer.FSM.SetState(resource.PeerStatePending) mockPeer.FSM.SetState(resource.PeerStatePending)
gomock.InOrder( gomock.InOrder(
@ -1979,7 +1979,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedEmpty", name: "peer state is PeerStateReceivedEmpty",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
host.Peers.Store(mockPeer.ID, mockPeer) host.Peers.Store(mockPeer.ID, mockPeer)
mockPeer.FSM.SetState(resource.PeerStateReceivedEmpty) mockPeer.FSM.SetState(resource.PeerStateReceivedEmpty)
gomock.InOrder( gomock.InOrder(
@ -1995,7 +1995,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedTiny", name: "peer state is PeerStateReceivedTiny",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
host.Peers.Store(mockPeer.ID, mockPeer) host.Peers.Store(mockPeer.ID, mockPeer)
mockPeer.FSM.SetState(resource.PeerStateReceivedTiny) mockPeer.FSM.SetState(resource.PeerStateReceivedTiny)
gomock.InOrder( gomock.InOrder(
@ -2011,7 +2011,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedSmall", name: "peer state is PeerStateReceivedSmall",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
host.Peers.Store(mockPeer.ID, mockPeer) host.Peers.Store(mockPeer.ID, mockPeer)
mockPeer.FSM.SetState(resource.PeerStateReceivedSmall) mockPeer.FSM.SetState(resource.PeerStateReceivedSmall)
gomock.InOrder( gomock.InOrder(
@ -2027,7 +2027,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedNormal", name: "peer state is PeerStateReceivedNormal",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
host.Peers.Store(mockPeer.ID, mockPeer) host.Peers.Store(mockPeer.ID, mockPeer)
mockPeer.FSM.SetState(resource.PeerStateReceivedNormal) mockPeer.FSM.SetState(resource.PeerStateReceivedNormal)
gomock.InOrder( gomock.InOrder(
@ -2043,7 +2043,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateRunning", name: "peer state is PeerStateRunning",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
host.Peers.Store(mockPeer.ID, mockPeer) host.Peers.Store(mockPeer.ID, mockPeer)
mockPeer.FSM.SetState(resource.PeerStateRunning) mockPeer.FSM.SetState(resource.PeerStateRunning)
gomock.InOrder( gomock.InOrder(
@ -2059,7 +2059,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateBackToSource", name: "peer state is PeerStateBackToSource",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
host.Peers.Store(mockPeer.ID, mockPeer) host.Peers.Store(mockPeer.ID, mockPeer)
mockPeer.FSM.SetState(resource.PeerStateBackToSource) mockPeer.FSM.SetState(resource.PeerStateBackToSource)
gomock.InOrder( gomock.InOrder(
@ -2075,7 +2075,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateSucceeded", name: "peer state is PeerStateSucceeded",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
host.Peers.Store(mockPeer.ID, mockPeer) host.Peers.Store(mockPeer.ID, mockPeer)
mockPeer.FSM.SetState(resource.PeerStateSucceeded) mockPeer.FSM.SetState(resource.PeerStateSucceeded)
gomock.InOrder( gomock.InOrder(
@ -2091,7 +2091,7 @@ func TestService_LeaveHost(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateFailed", name: "peer state is PeerStateFailed",
mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) { mock: func(host *resource.Host, mockPeer *resource.Peer, hostManager resource.HostManager, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mh *resource.MockHostManagerMockRecorder) {
host.Peers.Store(mockPeer.ID, mockPeer) host.Peers.Store(mockPeer.ID, mockPeer)
mockPeer.FSM.SetState(resource.PeerStateFailed) mockPeer.FSM.SetState(resource.PeerStateFailed)
gomock.InOrder( gomock.InOrder(
@ -2111,7 +2111,7 @@ func TestService_LeaveHost(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
@ -2121,9 +2121,9 @@ func TestService_LeaveHost(t *testing.T) {
mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type) mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type)
mockTask := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength)) mockTask := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength))
mockPeer := resource.NewPeer(mockSeedPeerID, mockTask, host) mockPeer := resource.NewPeer(mockSeedPeerID, mockTask, host)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduling, dynconfig, storage)
tc.mock(host, mockPeer, hostManager, scheduler.EXPECT(), res.EXPECT(), hostManager.EXPECT()) tc.mock(host, mockPeer, hostManager, scheduling.EXPECT(), res.EXPECT(), hostManager.EXPECT())
tc.expect(t, mockPeer, svc.LeaveHost(context.Background(), &schedulerv1.LeaveHostRequest{ tc.expect(t, mockPeer, svc.LeaveHost(context.Background(), &schedulerv1.LeaveHostRequest{
Id: idgen.HostIDV2(host.IP, host.Hostname), Id: idgen.HostIDV2(host.IP, host.Hostname),
})) }))
@ -2577,11 +2577,11 @@ func TestService_triggerTask(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
svc := NewV1(tc.config, res, scheduler, dynconfig, storage) svc := NewV1(tc.config, res, scheduling, dynconfig, storage)
mockHost := resource.NewHost( mockHost := resource.NewHost(
mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname, mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname,
@ -2681,11 +2681,11 @@ func TestService_storeTask(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduling, dynconfig, storage)
taskManager := resource.NewMockTaskManager(ctl) taskManager := resource.NewMockTaskManager(ctl)
tc.run(t, svc, taskManager, res.EXPECT(), taskManager.EXPECT()) tc.run(t, svc, taskManager, res.EXPECT(), taskManager.EXPECT())
}) })
@ -2759,11 +2759,11 @@ func TestService_storeHost(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduling, dynconfig, storage)
hostManager := resource.NewMockHostManager(ctl) hostManager := resource.NewMockHostManager(ctl)
mockHost := resource.NewHost( mockHost := resource.NewHost(
mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname, mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname,
@ -2844,11 +2844,11 @@ func TestService_storePeer(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduling, dynconfig, storage)
peerManager := resource.NewMockPeerManager(ctl) peerManager := resource.NewMockPeerManager(ctl)
tc.run(t, svc, peerManager, res.EXPECT(), peerManager.EXPECT()) tc.run(t, svc, peerManager, res.EXPECT(), peerManager.EXPECT())
@ -2903,7 +2903,7 @@ func TestService_triggerSeedPeerTask(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
@ -2913,7 +2913,7 @@ func TestService_triggerSeedPeerTask(t *testing.T) {
mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type) mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type)
task := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength)) task := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength))
peer := resource.NewPeer(mockPeerID, task, mockHost) peer := resource.NewPeer(mockPeerID, task, mockHost)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduling, dynconfig, storage)
tc.mock(task, peer, seedPeer, res.EXPECT(), seedPeer.EXPECT()) tc.mock(task, peer, seedPeer, res.EXPECT(), seedPeer.EXPECT())
svc.triggerSeedPeerTask(context.Background(), &mockPeerRange, task) svc.triggerSeedPeerTask(context.Background(), &mockPeerRange, task)
@ -2925,12 +2925,12 @@ func TestService_triggerSeedPeerTask(t *testing.T) {
func TestService_handleBeginOfPiece(t *testing.T) { func TestService_handleBeginOfPiece(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
mock func(peer *resource.Peer, scheduler *mocks.MockSchedulerMockRecorder) mock func(peer *resource.Peer, scheduling *mocks.MockSchedulingMockRecorder)
expect func(t *testing.T, peer *resource.Peer) expect func(t *testing.T, peer *resource.Peer)
}{ }{
{ {
name: "peer state is PeerStateBackToSource", name: "peer state is PeerStateBackToSource",
mock: func(peer *resource.Peer, scheduler *mocks.MockSchedulerMockRecorder) { mock: func(peer *resource.Peer, scheduling *mocks.MockSchedulingMockRecorder) {
peer.FSM.SetState(resource.PeerStateBackToSource) peer.FSM.SetState(resource.PeerStateBackToSource)
}, },
expect: func(t *testing.T, peer *resource.Peer) { expect: func(t *testing.T, peer *resource.Peer) {
@ -2940,7 +2940,7 @@ func TestService_handleBeginOfPiece(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedTiny", name: "peer state is PeerStateReceivedTiny",
mock: func(peer *resource.Peer, scheduler *mocks.MockSchedulerMockRecorder) { mock: func(peer *resource.Peer, scheduling *mocks.MockSchedulingMockRecorder) {
peer.FSM.SetState(resource.PeerStateReceivedTiny) peer.FSM.SetState(resource.PeerStateReceivedTiny)
}, },
expect: func(t *testing.T, peer *resource.Peer) { expect: func(t *testing.T, peer *resource.Peer) {
@ -2950,7 +2950,7 @@ func TestService_handleBeginOfPiece(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedSmall", name: "peer state is PeerStateReceivedSmall",
mock: func(peer *resource.Peer, scheduler *mocks.MockSchedulerMockRecorder) { mock: func(peer *resource.Peer, scheduling *mocks.MockSchedulingMockRecorder) {
peer.FSM.SetState(resource.PeerStateReceivedSmall) peer.FSM.SetState(resource.PeerStateReceivedSmall)
}, },
expect: func(t *testing.T, peer *resource.Peer) { expect: func(t *testing.T, peer *resource.Peer) {
@ -2960,9 +2960,9 @@ func TestService_handleBeginOfPiece(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateReceivedNormal", name: "peer state is PeerStateReceivedNormal",
mock: func(peer *resource.Peer, scheduler *mocks.MockSchedulerMockRecorder) { mock: func(peer *resource.Peer, scheduling *mocks.MockSchedulingMockRecorder) {
peer.FSM.SetState(resource.PeerStateReceivedNormal) peer.FSM.SetState(resource.PeerStateReceivedNormal)
scheduler.ScheduleParent(gomock.Any(), gomock.Eq(peer), gomock.Eq(set.NewSafeSet[string]())).Return().Times(1) scheduling.ScheduleParent(gomock.Any(), gomock.Eq(peer), gomock.Eq(set.NewSafeSet[string]())).Return().Times(1)
}, },
expect: func(t *testing.T, peer *resource.Peer) { expect: func(t *testing.T, peer *resource.Peer) {
assert := assert.New(t) assert := assert.New(t)
@ -2971,7 +2971,7 @@ func TestService_handleBeginOfPiece(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateSucceeded", name: "peer state is PeerStateSucceeded",
mock: func(peer *resource.Peer, scheduler *mocks.MockSchedulerMockRecorder) { mock: func(peer *resource.Peer, scheduling *mocks.MockSchedulingMockRecorder) {
peer.FSM.SetState(resource.PeerStateSucceeded) peer.FSM.SetState(resource.PeerStateSucceeded)
}, },
expect: func(t *testing.T, peer *resource.Peer) { expect: func(t *testing.T, peer *resource.Peer) {
@ -2985,7 +2985,7 @@ func TestService_handleBeginOfPiece(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
@ -2994,9 +2994,9 @@ func TestService_handleBeginOfPiece(t *testing.T) {
mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type) mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type)
mockTask := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength)) mockTask := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength))
peer := resource.NewPeer(mockPeerID, mockTask, mockHost) peer := resource.NewPeer(mockPeerID, mockTask, mockHost)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig}, res, scheduling, dynconfig, storage)
tc.mock(peer, scheduler.EXPECT()) tc.mock(peer, scheduling.EXPECT())
svc.handleBeginOfPiece(context.Background(), peer) svc.handleBeginOfPiece(context.Background(), peer)
tc.expect(t, peer) tc.expect(t, peer)
}) })
@ -3124,12 +3124,12 @@ func TestService_handlePieceSuccess(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
peerManager := resource.NewMockPeerManager(ctl) peerManager := resource.NewMockPeerManager(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduling, dynconfig, storage)
tc.mock(tc.peer, peerManager, res.EXPECT(), peerManager.EXPECT()) tc.mock(tc.peer, peerManager, res.EXPECT(), peerManager.EXPECT())
svc.handlePieceSuccess(context.Background(), tc.peer, tc.piece) svc.handlePieceSuccess(context.Background(), tc.peer, tc.piece)
@ -3146,7 +3146,7 @@ func TestService_handlePieceFail(t *testing.T) {
piece *schedulerv1.PieceResult piece *schedulerv1.PieceResult
peer *resource.Peer peer *resource.Peer
parent *resource.Peer parent *resource.Peer
run func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) run func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder)
}{ }{
{ {
name: "peer state is PeerStateBackToSource", name: "peer state is PeerStateBackToSource",
@ -3156,7 +3156,7 @@ func TestService_handlePieceFail(t *testing.T) {
Metrics: config.MetricsConfig{EnableHost: true}, Metrics: config.MetricsConfig{EnableHost: true},
}, },
piece: &schedulerv1.PieceResult{}, piece: &schedulerv1.PieceResult{},
run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) { run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) {
peer.FSM.SetState(resource.PeerStateBackToSource) peer.FSM.SetState(resource.PeerStateBackToSource)
svc.handlePieceFailure(context.Background(), peer, piece) svc.handlePieceFailure(context.Background(), peer, piece)
@ -3176,7 +3176,7 @@ func TestService_handlePieceFail(t *testing.T) {
Code: commonv1.Code_ClientWaitPieceReady, Code: commonv1.Code_ClientWaitPieceReady,
DstPid: mockSeedPeerID, DstPid: mockSeedPeerID,
}, },
run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) { run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) {
peer.FSM.SetState(resource.PeerStateRunning) peer.FSM.SetState(resource.PeerStateRunning)
blocklist := set.NewSafeSet[string]() blocklist := set.NewSafeSet[string]()
blocklist.Add(mockSeedPeerID) blocklist.Add(mockSeedPeerID)
@ -3203,7 +3203,7 @@ func TestService_handlePieceFail(t *testing.T) {
Code: commonv1.Code_PeerTaskNotFound, Code: commonv1.Code_PeerTaskNotFound,
DstPid: mockSeedPeerID, DstPid: mockSeedPeerID,
}, },
run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) { run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) {
peer.FSM.SetState(resource.PeerStateRunning) peer.FSM.SetState(resource.PeerStateRunning)
parent.FSM.SetState(resource.PeerStateRunning) parent.FSM.SetState(resource.PeerStateRunning)
blocklist := set.NewSafeSet[string]() blocklist := set.NewSafeSet[string]()
@ -3232,7 +3232,7 @@ func TestService_handlePieceFail(t *testing.T) {
Code: commonv1.Code_ClientPieceNotFound, Code: commonv1.Code_ClientPieceNotFound,
DstPid: mockSeedPeerID, DstPid: mockSeedPeerID,
}, },
run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) { run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) {
peer.FSM.SetState(resource.PeerStateRunning) peer.FSM.SetState(resource.PeerStateRunning)
peer.Host.Type = pkgtypes.HostTypeNormal peer.Host.Type = pkgtypes.HostTypeNormal
blocklist := set.NewSafeSet[string]() blocklist := set.NewSafeSet[string]()
@ -3260,7 +3260,7 @@ func TestService_handlePieceFail(t *testing.T) {
Code: commonv1.Code_ClientPieceRequestFail, Code: commonv1.Code_ClientPieceRequestFail,
DstPid: mockSeedPeerID, DstPid: mockSeedPeerID,
}, },
run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) { run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) {
peer.FSM.SetState(resource.PeerStateRunning) peer.FSM.SetState(resource.PeerStateRunning)
parent.FSM.SetState(resource.PeerStateRunning) parent.FSM.SetState(resource.PeerStateRunning)
blocklist := set.NewSafeSet[string]() blocklist := set.NewSafeSet[string]()
@ -3289,7 +3289,7 @@ func TestService_handlePieceFail(t *testing.T) {
Code: commonv1.Code_ClientPieceRequestFail, Code: commonv1.Code_ClientPieceRequestFail,
DstPid: mockSeedPeerID, DstPid: mockSeedPeerID,
}, },
run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulerMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) { run: func(t *testing.T, svc *V1, peer *resource.Peer, parent *resource.Peer, piece *schedulerv1.PieceResult, peerManager resource.PeerManager, seedPeer resource.SeedPeer, ms *mocks.MockSchedulingMockRecorder, mr *resource.MockResourceMockRecorder, mp *resource.MockPeerManagerMockRecorder, mc *resource.MockSeedPeerMockRecorder) {
peer.FSM.SetState(resource.PeerStateRunning) peer.FSM.SetState(resource.PeerStateRunning)
parent.FSM.SetState(resource.PeerStateRunning) parent.FSM.SetState(resource.PeerStateRunning)
blocklist := set.NewSafeSet[string]() blocklist := set.NewSafeSet[string]()
@ -3313,7 +3313,7 @@ func TestService_handlePieceFail(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
@ -3325,9 +3325,9 @@ func TestService_handlePieceFail(t *testing.T) {
peer := resource.NewPeer(mockPeerID, mockTask, mockHost) peer := resource.NewPeer(mockPeerID, mockTask, mockHost)
parent := resource.NewPeer(mockSeedPeerID, mockTask, mockHost) parent := resource.NewPeer(mockSeedPeerID, mockTask, mockHost)
seedPeer := resource.NewMockSeedPeer(ctl) seedPeer := resource.NewMockSeedPeer(ctl)
svc := NewV1(tc.config, res, scheduler, dynconfig, storage) svc := NewV1(tc.config, res, scheduling, dynconfig, storage)
tc.run(t, svc, peer, parent, tc.piece, peerManager, seedPeer, scheduler.EXPECT(), res.EXPECT(), peerManager.EXPECT(), seedPeer.EXPECT()) tc.run(t, svc, peer, parent, tc.piece, peerManager, seedPeer, scheduling.EXPECT(), res.EXPECT(), peerManager.EXPECT(), seedPeer.EXPECT())
}) })
} }
} }
@ -3421,7 +3421,7 @@ func TestService_handlePeerSuccess(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
@ -3448,7 +3448,7 @@ func TestService_handlePeerSuccess(t *testing.T) {
mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type) mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type)
mockTask := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength)) mockTask := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength))
peer := resource.NewPeer(mockPeerID, mockTask, mockHost) peer := resource.NewPeer(mockPeerID, mockTask, mockHost)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduling, dynconfig, storage)
tc.mock(peer) tc.mock(peer)
svc.handlePeerSuccess(context.Background(), peer) svc.handlePeerSuccess(context.Background(), peer)
@ -3461,12 +3461,12 @@ func TestService_handlePeerFail(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
mock func(peer *resource.Peer, child *resource.Peer, ms *mocks.MockSchedulerMockRecorder) mock func(peer *resource.Peer, child *resource.Peer, ms *mocks.MockSchedulingMockRecorder)
expect func(t *testing.T, peer *resource.Peer, child *resource.Peer) expect func(t *testing.T, peer *resource.Peer, child *resource.Peer)
}{ }{
{ {
name: "peer state is PeerStateFailed", name: "peer state is PeerStateFailed",
mock: func(peer *resource.Peer, child *resource.Peer, ms *mocks.MockSchedulerMockRecorder) { mock: func(peer *resource.Peer, child *resource.Peer, ms *mocks.MockSchedulingMockRecorder) {
peer.FSM.SetState(resource.PeerStateFailed) peer.FSM.SetState(resource.PeerStateFailed)
}, },
expect: func(t *testing.T, peer *resource.Peer, child *resource.Peer) { expect: func(t *testing.T, peer *resource.Peer, child *resource.Peer) {
@ -3476,7 +3476,7 @@ func TestService_handlePeerFail(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateLeave", name: "peer state is PeerStateLeave",
mock: func(peer *resource.Peer, child *resource.Peer, ms *mocks.MockSchedulerMockRecorder) { mock: func(peer *resource.Peer, child *resource.Peer, ms *mocks.MockSchedulingMockRecorder) {
peer.FSM.SetState(resource.PeerStateLeave) peer.FSM.SetState(resource.PeerStateLeave)
}, },
expect: func(t *testing.T, peer *resource.Peer, child *resource.Peer) { expect: func(t *testing.T, peer *resource.Peer, child *resource.Peer) {
@ -3486,7 +3486,7 @@ func TestService_handlePeerFail(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateRunning and children need to be scheduled", name: "peer state is PeerStateRunning and children need to be scheduled",
mock: func(peer *resource.Peer, child *resource.Peer, ms *mocks.MockSchedulerMockRecorder) { mock: func(peer *resource.Peer, child *resource.Peer, ms *mocks.MockSchedulingMockRecorder) {
peer.Task.StorePeer(peer) peer.Task.StorePeer(peer)
peer.Task.StorePeer(child) peer.Task.StorePeer(child)
if err := peer.Task.AddPeerEdge(peer, child); err != nil { if err := peer.Task.AddPeerEdge(peer, child); err != nil {
@ -3504,7 +3504,7 @@ func TestService_handlePeerFail(t *testing.T) {
}, },
{ {
name: "peer state is PeerStateRunning and it has no children", name: "peer state is PeerStateRunning and it has no children",
mock: func(peer *resource.Peer, child *resource.Peer, ms *mocks.MockSchedulerMockRecorder) { mock: func(peer *resource.Peer, child *resource.Peer, ms *mocks.MockSchedulingMockRecorder) {
peer.Task.StorePeer(peer) peer.Task.StorePeer(peer)
peer.FSM.SetState(resource.PeerStateRunning) peer.FSM.SetState(resource.PeerStateRunning)
}, },
@ -3519,11 +3519,11 @@ func TestService_handlePeerFail(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduling, dynconfig, storage)
mockHost := resource.NewHost( mockHost := resource.NewHost(
mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname, mockRawHost.ID, mockRawHost.IP, mockRawHost.Hostname,
mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type) mockRawHost.Port, mockRawHost.DownloadPort, mockRawHost.Type)
@ -3531,7 +3531,7 @@ func TestService_handlePeerFail(t *testing.T) {
peer := resource.NewPeer(mockSeedPeerID, mockTask, mockHost) peer := resource.NewPeer(mockSeedPeerID, mockTask, mockHost)
child := resource.NewPeer(mockPeerID, mockTask, mockHost) child := resource.NewPeer(mockPeerID, mockTask, mockHost)
tc.mock(peer, child, scheduler.EXPECT()) tc.mock(peer, child, scheduling.EXPECT())
svc.handlePeerFailure(context.Background(), peer) svc.handlePeerFailure(context.Background(), peer)
tc.expect(t, peer, child) tc.expect(t, peer, child)
}) })
@ -3605,11 +3605,11 @@ func TestService_handleTaskSuccess(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduling, dynconfig, storage)
task := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength)) task := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength))
tc.mock(task) tc.mock(task)
@ -3744,11 +3744,11 @@ func TestService_handleTaskFail(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
res := resource.NewMockResource(ctl) res := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduler, dynconfig, storage) svc := NewV1(&config.Config{Scheduler: mockSchedulerConfig, Metrics: config.MetricsConfig{EnableHost: true}}, res, scheduling, dynconfig, storage)
task := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength)) task := resource.NewTask(mockTaskID, mockTaskURL, mockTaskTag, mockTaskApplication, commonv2.TaskType_DFDAEMON, mockTaskFilters, mockTaskHeader, mockTaskBackToSourceLimit, resource.WithDigest(mockTaskDigest), resource.WithPieceLength(mockTaskPieceLength))
tc.mock(task) tc.mock(task)

20
scheduler/service/service_v2.go
View File

@ -24,7 +24,7 @@ import (
"d7y.io/dragonfly/v2/scheduler/config" "d7y.io/dragonfly/v2/scheduler/config"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler" "d7y.io/dragonfly/v2/scheduler/scheduling"
"d7y.io/dragonfly/v2/scheduler/storage" "d7y.io/dragonfly/v2/scheduler/storage"
) )
@ -34,10 +34,10 @@ type V2 struct {
// Resource interface. // Resource interface.
resource resource.Resource resource resource.Resource
// Scheduler interface. // Scheduling interface.
scheduler scheduler.Scheduler scheduling scheduling.Scheduling
// Scheduelr service config. // Scheduler service config.
config *config.Config config *config.Config
// Dynamic config. // Dynamic config.
@ -51,16 +51,16 @@ type V2 struct {
func NewV2( func NewV2(
cfg *config.Config, cfg *config.Config,
resource resource.Resource, resource resource.Resource,
scheduler scheduler.Scheduler, scheduling scheduling.Scheduling,
dynconfig config.DynconfigInterface, dynconfig config.DynconfigInterface,
storage storage.Storage, storage storage.Storage,
) *V2 { ) *V2 {
return &V2{ return &V2{
resource: resource, resource: resource,
scheduler: scheduler, scheduling: scheduling,
config: cfg, config: cfg,
dynconfig: dynconfig, dynconfig: dynconfig,
storage: storage, storage: storage,
} }
} }

6
scheduler/service/service_v2_test.go
View File

@ -26,7 +26,7 @@ import (
"d7y.io/dragonfly/v2/scheduler/config" "d7y.io/dragonfly/v2/scheduler/config"
configmocks "d7y.io/dragonfly/v2/scheduler/config/mocks" configmocks "d7y.io/dragonfly/v2/scheduler/config/mocks"
"d7y.io/dragonfly/v2/scheduler/resource" "d7y.io/dragonfly/v2/scheduler/resource"
"d7y.io/dragonfly/v2/scheduler/scheduler/mocks" "d7y.io/dragonfly/v2/scheduler/scheduling/mocks"
storagemocks "d7y.io/dragonfly/v2/scheduler/storage/mocks" storagemocks "d7y.io/dragonfly/v2/scheduler/storage/mocks"
) )
@ -48,11 +48,11 @@ func TestService_NewV2(t *testing.T) {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
ctl := gomock.NewController(t) ctl := gomock.NewController(t)
defer ctl.Finish() defer ctl.Finish()
scheduler := mocks.NewMockScheduler(ctl) scheduling := mocks.NewMockScheduling(ctl)
resource := resource.NewMockResource(ctl) resource := resource.NewMockResource(ctl)
dynconfig := configmocks.NewMockDynconfigInterface(ctl) dynconfig := configmocks.NewMockDynconfigInterface(ctl)
storage := storagemocks.NewMockStorage(ctl) storage := storagemocks.NewMockStorage(ctl)
tc.expect(t, NewV2(&config.Config{Scheduler: mockSchedulerConfig}, resource, scheduler, dynconfig, storage)) tc.expect(t, NewV2(&config.Config{Scheduler: mockSchedulerConfig}, resource, scheduling, dynconfig, storage))
}) })
} }
} }