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

feat: change ok to loaded in loading func (#2010) 

Signed-off-by: Gaius <gaius.qi@gmail.com>
This commit is contained in:
Gaius 2023-01-17 16:27:37 +08:00
parent f89d481c43
commit c1066e60f4
No known key found for this signature in database
GPG Key ID: 8B4E5D1290FA2FFB
18 changed files with 219 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
manager/searcher/searcher_test.go
View File

@ -720,8 +720,8 @@ func TestSchedulerCluster(t *testing.T) {
for _, tc := range tests { for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
searcher := New(pluginDir) searcher := New(pluginDir)
clusters, ok := searcher.FindSchedulerClusters(context.Background(), tc.schedulerClusters, "foo", "127.0.0.1", tc.conditions) clusters, found := searcher.FindSchedulerClusters(context.Background(), tc.schedulerClusters, "foo", "127.0.0.1", tc.conditions)
tc.expect(t, clusters, ok) tc.expect(t, clusters, found)
}) })
} }
} }

6
scheduler/resource/host.go
View File

@ -157,12 +157,12 @@ func NewHost(req *schedulerv1.AnnounceHostRequest, options ...HostOption) *Host
// LoadPeer return peer for a key. // LoadPeer return peer for a key.
func (h *Host) LoadPeer(key string) (*Peer, bool) { func (h *Host) LoadPeer(key string) (*Peer, bool) {
rawPeer, ok := h.Peers.Load(key) rawPeer, loaded := h.Peers.Load(key)
if !ok { if !loaded {
return nil, false return nil, false
} }
return rawPeer.(*Peer), ok return rawPeer.(*Peer), loaded
} }
// StorePeer set peer. // StorePeer set peer.

6
scheduler/resource/host_manager.go
View File

@ -74,12 +74,12 @@ func newHostManager(cfg *config.GCConfig, gc pkggc.GC) (HostManager, error) {
} }
func (h *hostManager) Load(key string) (*Host, bool) { func (h *hostManager) Load(key string) (*Host, bool) {
rawHost, ok := h.Map.Load(key) rawHost, loaded := h.Map.Load(key)
if !ok { if !loaded {
return nil, false return nil, false
} }
return rawHost.(*Host), ok return rawHost.(*Host), loaded
} }
func (h *hostManager) Store(host *Host) { func (h *hostManager) Store(host *Host) {

52
scheduler/resource/host_manager_test.go
View File

@ -92,8 +92,8 @@ func TestHostManager_Load(t *testing.T) {
expect: func(t *testing.T, hostManager HostManager, mockHost *Host) { expect: func(t *testing.T, hostManager HostManager, mockHost *Host) {
assert := assert.New(t) assert := assert.New(t)
hostManager.Store(mockHost) hostManager.Store(mockHost)
host, ok := hostManager.Load(mockHost.ID) host, loaded := hostManager.Load(mockHost.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(host.ID, mockHost.ID) assert.Equal(host.ID, mockHost.ID)
}, },
}, },
@ -104,8 +104,8 @@ func TestHostManager_Load(t *testing.T) {
}, },
expect: func(t *testing.T, hostManager HostManager, mockHost *Host) { expect: func(t *testing.T, hostManager HostManager, mockHost *Host) {
assert := assert.New(t) assert := assert.New(t)
_, ok := hostManager.Load(mockHost.ID) _, loaded := hostManager.Load(mockHost.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -117,8 +117,8 @@ func TestHostManager_Load(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
mockHost.ID = "" mockHost.ID = ""
hostManager.Store(mockHost) hostManager.Store(mockHost)
host, ok := hostManager.Load(mockHost.ID) host, loaded := hostManager.Load(mockHost.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(host.ID, mockHost.ID) assert.Equal(host.ID, mockHost.ID)
}, },
}, },
@ -156,8 +156,8 @@ func TestHostManager_Store(t *testing.T) {
expect: func(t *testing.T, hostManager HostManager, mockHost *Host) { expect: func(t *testing.T, hostManager HostManager, mockHost *Host) {
assert := assert.New(t) assert := assert.New(t)
hostManager.Store(mockHost) hostManager.Store(mockHost)
host, ok := hostManager.Load(mockHost.ID) host, loaded := hostManager.Load(mockHost.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(host.ID, mockHost.ID) assert.Equal(host.ID, mockHost.ID)
}, },
}, },
@ -170,8 +170,8 @@ func TestHostManager_Store(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
mockHost.ID = "" mockHost.ID = ""
hostManager.Store(mockHost) hostManager.Store(mockHost)
host, ok := hostManager.Load(mockHost.ID) host, loaded := hostManager.Load(mockHost.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(host.ID, mockHost.ID) assert.Equal(host.ID, mockHost.ID)
}, },
}, },
@ -209,8 +209,8 @@ func TestHostManager_LoadOrStore(t *testing.T) {
expect: func(t *testing.T, hostManager HostManager, mockHost *Host) { expect: func(t *testing.T, hostManager HostManager, mockHost *Host) {
assert := assert.New(t) assert := assert.New(t)
hostManager.Store(mockHost) hostManager.Store(mockHost)
host, ok := hostManager.LoadOrStore(mockHost) host, loaded := hostManager.LoadOrStore(mockHost)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(host.ID, mockHost.ID) assert.Equal(host.ID, mockHost.ID)
}, },
}, },
@ -221,8 +221,8 @@ func TestHostManager_LoadOrStore(t *testing.T) {
}, },
expect: func(t *testing.T, hostManager HostManager, mockHost *Host) { expect: func(t *testing.T, hostManager HostManager, mockHost *Host) {
assert := assert.New(t) assert := assert.New(t)
host, ok := hostManager.LoadOrStore(mockHost) host, loaded := hostManager.LoadOrStore(mockHost)
assert.Equal(ok, false) assert.Equal(loaded, false)
assert.Equal(host.ID, mockHost.ID) assert.Equal(host.ID, mockHost.ID)
}, },
}, },
@ -261,8 +261,8 @@ func TestHostManager_Delete(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
hostManager.Store(mockHost) hostManager.Store(mockHost)
hostManager.Delete(mockHost.ID) hostManager.Delete(mockHost.ID)
_, ok := hostManager.Load(mockHost.ID) _, loaded := hostManager.Load(mockHost.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -275,8 +275,8 @@ func TestHostManager_Delete(t *testing.T) {
mockHost.ID = "" mockHost.ID = ""
hostManager.Store(mockHost) hostManager.Store(mockHost)
hostManager.Delete(mockHost.ID) hostManager.Delete(mockHost.ID)
_, ok := hostManager.Load(mockHost.ID) _, loaded := hostManager.Load(mockHost.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
} }
@ -316,8 +316,8 @@ func TestHostManager_RunGC(t *testing.T) {
err := hostManager.RunGC() err := hostManager.RunGC()
assert.NoError(err) assert.NoError(err)
_, ok := hostManager.Load(mockHost.ID) _, loaded := hostManager.Load(mockHost.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -332,8 +332,8 @@ func TestHostManager_RunGC(t *testing.T) {
err := hostManager.RunGC() err := hostManager.RunGC()
assert.NoError(err) assert.NoError(err)
host, ok := hostManager.Load(mockHost.ID) host, loaded := hostManager.Load(mockHost.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(host.ID, mockHost.ID) assert.Equal(host.ID, mockHost.ID)
}, },
}, },
@ -351,8 +351,8 @@ func TestHostManager_RunGC(t *testing.T) {
err := hostManager.RunGC() err := hostManager.RunGC()
assert.NoError(err) assert.NoError(err)
host, ok := hostManager.Load(mockHost.ID) host, loaded := hostManager.Load(mockHost.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(host.ID, mockHost.ID) assert.Equal(host.ID, mockHost.ID)
}, },
}, },
@ -368,8 +368,8 @@ func TestHostManager_RunGC(t *testing.T) {
err := hostManager.RunGC() err := hostManager.RunGC()
assert.NoError(err) assert.NoError(err)
host, ok := hostManager.Load(mockSeedHost.ID) host, loaded := hostManager.Load(mockSeedHost.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(host.ID, mockSeedHost.ID) assert.Equal(host.ID, mockSeedHost.ID)
}, },
}, },

40
scheduler/resource/host_test.go
View File

@ -145,15 +145,15 @@ func TestHost_LoadPeer(t *testing.T) {
rawHost *schedulerv1.AnnounceHostRequest rawHost *schedulerv1.AnnounceHostRequest
peerID string peerID string
options []HostOption options []HostOption
expect func(t *testing.T, peer *Peer, ok bool) expect func(t *testing.T, peer *Peer, loaded bool)
}{ }{
{ {
name: "load peer", name: "load peer",
rawHost: mockRawHost, rawHost: mockRawHost,
peerID: mockPeerID, peerID: mockPeerID,
expect: func(t *testing.T, peer *Peer, ok bool) { expect: func(t *testing.T, peer *Peer, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeerID) assert.Equal(peer.ID, mockPeerID)
}, },
}, },
@ -161,18 +161,18 @@ func TestHost_LoadPeer(t *testing.T) {
name: "peer does not exist", name: "peer does not exist",
rawHost: mockRawHost, rawHost: mockRawHost,
peerID: idgen.PeerID("0.0.0.0"), peerID: idgen.PeerID("0.0.0.0"),
expect: func(t *testing.T, peer *Peer, ok bool) { expect: func(t *testing.T, peer *Peer, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
name: "load key is empty", name: "load key is empty",
rawHost: mockRawHost, rawHost: mockRawHost,
peerID: "", peerID: "",
expect: func(t *testing.T, peer *Peer, ok bool) { expect: func(t *testing.T, peer *Peer, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
} }
@ -184,8 +184,8 @@ func TestHost_LoadPeer(t *testing.T) {
mockPeer := NewPeer(mockPeerID, mockTask, host) mockPeer := NewPeer(mockPeerID, mockTask, host)
host.StorePeer(mockPeer) host.StorePeer(mockPeer)
peer, ok := host.LoadPeer(tc.peerID) peer, loaded := host.LoadPeer(tc.peerID)
tc.expect(t, peer, ok) tc.expect(t, peer, loaded)
}) })
} }
} }
@ -196,15 +196,15 @@ func TestHost_StorePeer(t *testing.T) {
rawHost *schedulerv1.AnnounceHostRequest rawHost *schedulerv1.AnnounceHostRequest
peerID string peerID string
options []HostOption options []HostOption
expect func(t *testing.T, peer *Peer, ok bool) expect func(t *testing.T, peer *Peer, loaded bool)
}{ }{
{ {
name: "store peer", name: "store peer",
rawHost: mockRawHost, rawHost: mockRawHost,
peerID: mockPeerID, peerID: mockPeerID,
expect: func(t *testing.T, peer *Peer, ok bool) { expect: func(t *testing.T, peer *Peer, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeerID) assert.Equal(peer.ID, mockPeerID)
}, },
}, },
@ -212,9 +212,9 @@ func TestHost_StorePeer(t *testing.T) {
name: "store key is empty", name: "store key is empty",
rawHost: mockRawHost, rawHost: mockRawHost,
peerID: "", peerID: "",
expect: func(t *testing.T, peer *Peer, ok bool) { expect: func(t *testing.T, peer *Peer, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, "") assert.Equal(peer.ID, "")
}, },
}, },
@ -227,8 +227,8 @@ func TestHost_StorePeer(t *testing.T) {
mockPeer := NewPeer(tc.peerID, mockTask, host) mockPeer := NewPeer(tc.peerID, mockTask, host)
host.StorePeer(mockPeer) host.StorePeer(mockPeer)
peer, ok := host.LoadPeer(tc.peerID) peer, loaded := host.LoadPeer(tc.peerID)
tc.expect(t, peer, ok) tc.expect(t, peer, loaded)
}) })
} }
} }
@ -247,8 +247,8 @@ func TestHost_DeletePeer(t *testing.T) {
peerID: mockPeerID, peerID: mockPeerID,
expect: func(t *testing.T, host *Host) { expect: func(t *testing.T, host *Host) {
assert := assert.New(t) assert := assert.New(t)
_, ok := host.LoadPeer(mockPeerID) _, loaded := host.LoadPeer(mockPeerID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -257,8 +257,8 @@ func TestHost_DeletePeer(t *testing.T) {
peerID: "", peerID: "",
expect: func(t *testing.T, host *Host) { expect: func(t *testing.T, host *Host) {
assert := assert.New(t) assert := assert.New(t)
peer, ok := host.LoadPeer(mockPeerID) peer, loaded := host.LoadPeer(mockPeerID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeerID) assert.Equal(peer.ID, mockPeerID)
}, },
}, },

8
scheduler/resource/peer_manager.go
View File

@ -87,12 +87,12 @@ func newPeerManager(cfg *config.GCConfig, gc pkggc.GC) (PeerManager, error) {
} }
func (p *peerManager) Load(key string) (*Peer, bool) { func (p *peerManager) Load(key string) (*Peer, bool) {
rawPeer, ok := p.Map.Load(key) rawPeer, loaded := p.Map.Load(key)
if !ok { if !loaded {
return nil, false return nil, false
} }
return rawPeer.(*Peer), ok return rawPeer.(*Peer), loaded
} }
func (p *peerManager) Store(peer *Peer) { func (p *peerManager) Store(peer *Peer) {
@ -121,7 +121,7 @@ func (p *peerManager) Delete(key string) {
p.mu.Lock() p.mu.Lock()
defer p.mu.Unlock() defer p.mu.Unlock()
if peer, ok := p.Load(key); ok { if peer, loaded := p.Load(key); loaded {
p.Map.Delete(key) p.Map.Delete(key)
peer.Task.DeletePeer(key) peer.Task.DeletePeer(key)
peer.Host.DeletePeer(key) peer.Host.DeletePeer(key)

76
scheduler/resource/peer_manager_test.go
View File

@ -94,8 +94,8 @@ func TestPeerManager_Load(t *testing.T) {
expect: func(t *testing.T, peerManager PeerManager, mockPeer *Peer) { expect: func(t *testing.T, peerManager PeerManager, mockPeer *Peer) {
assert := assert.New(t) assert := assert.New(t)
peerManager.Store(mockPeer) peerManager.Store(mockPeer)
peer, ok := peerManager.Load(mockPeer.ID) peer, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeer.ID) assert.Equal(peer.ID, mockPeer.ID)
}, },
}, },
@ -106,8 +106,8 @@ func TestPeerManager_Load(t *testing.T) {
}, },
expect: func(t *testing.T, peerManager PeerManager, mockPeer *Peer) { expect: func(t *testing.T, peerManager PeerManager, mockPeer *Peer) {
assert := assert.New(t) assert := assert.New(t)
_, ok := peerManager.Load(mockPeer.ID) _, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -119,8 +119,8 @@ func TestPeerManager_Load(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
mockPeer.ID = "" mockPeer.ID = ""
peerManager.Store(mockPeer) peerManager.Store(mockPeer)
peer, ok := peerManager.Load(mockPeer.ID) peer, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeer.ID) assert.Equal(peer.ID, mockPeer.ID)
}, },
}, },
@ -160,8 +160,8 @@ func TestPeerManager_Store(t *testing.T) {
expect: func(t *testing.T, peerManager PeerManager, mockPeer *Peer) { expect: func(t *testing.T, peerManager PeerManager, mockPeer *Peer) {
assert := assert.New(t) assert := assert.New(t)
peerManager.Store(mockPeer) peerManager.Store(mockPeer)
peer, ok := peerManager.Load(mockPeer.ID) peer, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeer.ID) assert.Equal(peer.ID, mockPeer.ID)
}, },
}, },
@ -174,8 +174,8 @@ func TestPeerManager_Store(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
mockPeer.ID = "" mockPeer.ID = ""
peerManager.Store(mockPeer) peerManager.Store(mockPeer)
peer, ok := peerManager.Load(mockPeer.ID) peer, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeer.ID) assert.Equal(peer.ID, mockPeer.ID)
}, },
}, },
@ -215,8 +215,8 @@ func TestPeerManager_LoadOrStore(t *testing.T) {
expect: func(t *testing.T, peerManager PeerManager, mockPeer *Peer) { expect: func(t *testing.T, peerManager PeerManager, mockPeer *Peer) {
assert := assert.New(t) assert := assert.New(t)
peerManager.Store(mockPeer) peerManager.Store(mockPeer)
peer, ok := peerManager.LoadOrStore(mockPeer) peer, loaded := peerManager.LoadOrStore(mockPeer)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeer.ID) assert.Equal(peer.ID, mockPeer.ID)
}, },
}, },
@ -227,8 +227,8 @@ func TestPeerManager_LoadOrStore(t *testing.T) {
}, },
expect: func(t *testing.T, peerManager PeerManager, mockPeer *Peer) { expect: func(t *testing.T, peerManager PeerManager, mockPeer *Peer) {
assert := assert.New(t) assert := assert.New(t)
peer, ok := peerManager.LoadOrStore(mockPeer) peer, loaded := peerManager.LoadOrStore(mockPeer)
assert.Equal(ok, false) assert.Equal(loaded, false)
assert.Equal(peer.ID, mockPeer.ID) assert.Equal(peer.ID, mockPeer.ID)
}, },
}, },
@ -269,8 +269,8 @@ func TestPeerManager_Delete(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
peerManager.Store(mockPeer) peerManager.Store(mockPeer)
peerManager.Delete(mockPeer.ID) peerManager.Delete(mockPeer.ID)
_, ok := peerManager.Load(mockPeer.ID) _, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -283,8 +283,8 @@ func TestPeerManager_Delete(t *testing.T) {
mockPeer.ID = "" mockPeer.ID = ""
peerManager.Store(mockPeer) peerManager.Store(mockPeer)
peerManager.Delete(mockPeer.ID) peerManager.Delete(mockPeer.ID)
_, ok := peerManager.Load(mockPeer.ID) _, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
} }
@ -333,8 +333,8 @@ func TestPeerManager_RunGC(t *testing.T) {
err := peerManager.RunGC() err := peerManager.RunGC()
assert.NoError(err) assert.NoError(err)
peer, ok := peerManager.Load(mockPeer.ID) peer, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.FSM.Current(), PeerStateLeave) assert.Equal(peer.FSM.Current(), PeerStateLeave)
}, },
}, },
@ -355,15 +355,15 @@ func TestPeerManager_RunGC(t *testing.T) {
err := peerManager.RunGC() err := peerManager.RunGC()
assert.NoError(err) assert.NoError(err)
peer, ok := peerManager.Load(mockPeer.ID) peer, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.FSM.Current(), PeerStateLeave) assert.Equal(peer.FSM.Current(), PeerStateLeave)
err = peerManager.RunGC() err = peerManager.RunGC()
assert.NoError(err) assert.NoError(err)
_, ok = peerManager.Load(mockPeer.ID) _, loaded = peerManager.Load(mockPeer.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -383,15 +383,15 @@ func TestPeerManager_RunGC(t *testing.T) {
err := peerManager.RunGC() err := peerManager.RunGC()
assert.NoError(err) assert.NoError(err)
peer, ok := peerManager.Load(mockPeer.ID) peer, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.FSM.Current(), PeerStateLeave) assert.Equal(peer.FSM.Current(), PeerStateLeave)
err = peerManager.RunGC() err = peerManager.RunGC()
assert.NoError(err) assert.NoError(err)
_, ok = peerManager.Load(mockPeer.ID) _, loaded = peerManager.Load(mockPeer.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -411,15 +411,15 @@ func TestPeerManager_RunGC(t *testing.T) {
err := peerManager.RunGC() err := peerManager.RunGC()
assert.NoError(err) assert.NoError(err)
peer, ok := peerManager.Load(mockPeer.ID) peer, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.FSM.Current(), PeerStateLeave) assert.Equal(peer.FSM.Current(), PeerStateLeave)
err = peerManager.RunGC() err = peerManager.RunGC()
assert.NoError(err) assert.NoError(err)
_, ok = peerManager.Load(mockPeer.ID) _, loaded = peerManager.Load(mockPeer.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -439,8 +439,8 @@ func TestPeerManager_RunGC(t *testing.T) {
err := peerManager.RunGC() err := peerManager.RunGC()
assert.NoError(err) assert.NoError(err)
peer, ok := peerManager.Load(mockPeer.ID) peer, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.FSM.Current(), PeerStateLeave) assert.Equal(peer.FSM.Current(), PeerStateLeave)
}, },
}, },
@ -463,8 +463,8 @@ func TestPeerManager_RunGC(t *testing.T) {
err := peerManager.RunGC() err := peerManager.RunGC()
assert.NoError(err) assert.NoError(err)
_, ok := peerManager.Load(mockPeer.ID) _, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -489,8 +489,8 @@ func TestPeerManager_RunGC(t *testing.T) {
err := peerManager.RunGC() err := peerManager.RunGC()
assert.NoError(err) assert.NoError(err)
peer, ok := peerManager.Load(mockPeer.ID) peer, loaded := peerManager.Load(mockPeer.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.FSM.Current(), PeerStateLeave) assert.Equal(peer.FSM.Current(), PeerStateLeave)
}, },
}, },

16
scheduler/resource/peer_test.go
View File

@ -182,8 +182,8 @@ func TestPeer_LoadStream(t *testing.T) {
expect: func(t *testing.T, peer *Peer, stream schedulerv1.Scheduler_ReportPieceResultServer) { expect: func(t *testing.T, peer *Peer, stream schedulerv1.Scheduler_ReportPieceResultServer) {
assert := assert.New(t) assert := assert.New(t)
peer.StoreStream(stream) peer.StoreStream(stream)
newStream, ok := peer.LoadStream() newStream, loaded := peer.LoadStream()
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.EqualValues(newStream, stream) assert.EqualValues(newStream, stream)
}, },
}, },
@ -191,8 +191,8 @@ func TestPeer_LoadStream(t *testing.T) {
name: "stream does not exist", name: "stream does not exist",
expect: func(t *testing.T, peer *Peer, stream schedulerv1.Scheduler_ReportPieceResultServer) { expect: func(t *testing.T, peer *Peer, stream schedulerv1.Scheduler_ReportPieceResultServer) {
assert := assert.New(t) assert := assert.New(t)
_, ok := peer.LoadStream() _, loaded := peer.LoadStream()
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
} }
@ -221,8 +221,8 @@ func TestPeer_StoreStream(t *testing.T) {
expect: func(t *testing.T, peer *Peer, stream schedulerv1.Scheduler_ReportPieceResultServer) { expect: func(t *testing.T, peer *Peer, stream schedulerv1.Scheduler_ReportPieceResultServer) {
assert := assert.New(t) assert := assert.New(t)
peer.StoreStream(stream) peer.StoreStream(stream)
newStream, ok := peer.LoadStream() newStream, loaded := peer.LoadStream()
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.EqualValues(newStream, stream) assert.EqualValues(newStream, stream)
}, },
}, },
@ -253,8 +253,8 @@ func TestPeer_DeleteStream(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
peer.StoreStream(stream) peer.StoreStream(stream)
peer.DeleteStream() peer.DeleteStream()
_, ok := peer.LoadStream() _, loaded := peer.LoadStream()
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
} }

8
scheduler/resource/seed_peer.go
View File

@ -170,15 +170,15 @@ func (s *seedPeer) TriggerTask(ctx context.Context, task *Task) (*Peer, *schedul
// Initialize seed peer. // Initialize seed peer.
func (s *seedPeer) initSeedPeer(ctx context.Context, task *Task, ps *cdnsystemv1.PieceSeed) (*Peer, error) { func (s *seedPeer) initSeedPeer(ctx context.Context, task *Task, ps *cdnsystemv1.PieceSeed) (*Peer, error) {
// Load peer from manager. // Load peer from manager.
peer, ok := s.peerManager.Load(ps.PeerId) peer, loaded := s.peerManager.Load(ps.PeerId)
if ok { if loaded {
return peer, nil return peer, nil
} }
task.Log.Infof("can not find seed peer: %s", ps.PeerId) task.Log.Infof("can not find seed peer: %s", ps.PeerId)
// Load host from manager. // Load host from manager.
host, ok := s.hostManager.Load(ps.HostId) host, loaded := s.hostManager.Load(ps.HostId)
if !ok { if !loaded {
task.Log.Errorf("can not find seed host id: %s", ps.HostId) task.Log.Errorf("can not find seed host id: %s", ps.HostId)
return nil, fmt.Errorf("can not find host id: %s", ps.HostId) return nil, fmt.Errorf("can not find host id: %s", ps.HostId)
} }

2
scheduler/resource/seed_peer_client.go
View File

@ -98,7 +98,7 @@ func (sc *seedPeerClient) OnNotify(data *config.DynconfigData) {
for _, seedPeer := range diffSeedPeers { for _, seedPeer := range diffSeedPeers {
id := idgen.HostID(seedPeer.HostName, seedPeer.Port) id := idgen.HostID(seedPeer.HostName, seedPeer.Port)
logger.Infof("host %s has been reclaimed, because of seed peer ip is changed", id) logger.Infof("host %s has been reclaimed, because of seed peer ip is changed", id)
if host, ok := sc.hostManager.Load(id); ok { if host, loaded := sc.hostManager.Load(id); loaded {
host.LeavePeers() host.LeavePeers()
sc.hostManager.Delete(id) sc.hostManager.Delete(id)
} }

10
scheduler/resource/task.go
View File

@ -386,12 +386,12 @@ func (t *Task) IsSeedPeerFailed() bool {
// LoadPiece return piece for a key. // LoadPiece return piece for a key.
func (t *Task) LoadPiece(key int32) (*commonv1.PieceInfo, bool) { func (t *Task) LoadPiece(key int32) (*commonv1.PieceInfo, bool) {
rawPiece, ok := t.Pieces.Load(key) rawPiece, loaded := t.Pieces.Load(key)
if !ok { if !loaded {
return nil, false return nil, false
} }
return rawPiece.(*commonv1.PieceInfo), ok return rawPiece.(*commonv1.PieceInfo), loaded
} }
// StorePiece set piece. // StorePiece set piece.
@ -448,8 +448,8 @@ func (t *Task) NotifyPeers(peerPacket *schedulerv1.PeerPacket, event string) {
} }
if peer.FSM.Is(PeerStateRunning) { if peer.FSM.Is(PeerStateRunning) {
stream, ok := peer.LoadStream() stream, loaded := peer.LoadStream()
if !ok { if !loaded {
continue continue
} }

6
scheduler/resource/task_manager.go
View File

@ -74,12 +74,12 @@ func newTaskManager(cfg *config.GCConfig, gc pkggc.GC) (TaskManager, error) {
} }
func (t *taskManager) Load(key string) (*Task, bool) { func (t *taskManager) Load(key string) (*Task, bool) {
rawTask, ok := t.Map.Load(key) rawTask, loaded := t.Map.Load(key)
if !ok { if !loaded {
return nil, false return nil, false
} }
return rawTask.(*Task), ok return rawTask.(*Task), loaded
} }
func (t *taskManager) Store(task *Task) { func (t *taskManager) Store(task *Task) {

48
scheduler/resource/task_manager_test.go
View File

@ -92,8 +92,8 @@ func TestTaskManager_Load(t *testing.T) {
expect: func(t *testing.T, taskManager TaskManager, mockTask *Task) { expect: func(t *testing.T, taskManager TaskManager, mockTask *Task) {
assert := assert.New(t) assert := assert.New(t)
taskManager.Store(mockTask) taskManager.Store(mockTask)
task, ok := taskManager.Load(mockTask.ID) task, loaded := taskManager.Load(mockTask.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(task.ID, mockTask.ID) assert.Equal(task.ID, mockTask.ID)
}, },
}, },
@ -104,8 +104,8 @@ func TestTaskManager_Load(t *testing.T) {
}, },
expect: func(t *testing.T, taskManager TaskManager, mockTask *Task) { expect: func(t *testing.T, taskManager TaskManager, mockTask *Task) {
assert := assert.New(t) assert := assert.New(t)
_, ok := taskManager.Load(mockTask.ID) _, loaded := taskManager.Load(mockTask.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -117,8 +117,8 @@ func TestTaskManager_Load(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
mockTask.ID = "" mockTask.ID = ""
taskManager.Store(mockTask) taskManager.Store(mockTask)
task, ok := taskManager.Load(mockTask.ID) task, loaded := taskManager.Load(mockTask.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(task.ID, mockTask.ID) assert.Equal(task.ID, mockTask.ID)
}, },
}, },
@ -156,8 +156,8 @@ func TestTaskManager_Store(t *testing.T) {
expect: func(t *testing.T, taskManager TaskManager, mockTask *Task) { expect: func(t *testing.T, taskManager TaskManager, mockTask *Task) {
assert := assert.New(t) assert := assert.New(t)
taskManager.Store(mockTask) taskManager.Store(mockTask)
task, ok := taskManager.Load(mockTask.ID) task, loaded := taskManager.Load(mockTask.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(task.ID, mockTask.ID) assert.Equal(task.ID, mockTask.ID)
}, },
}, },
@ -170,8 +170,8 @@ func TestTaskManager_Store(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
mockTask.ID = "" mockTask.ID = ""
taskManager.Store(mockTask) taskManager.Store(mockTask)
task, ok := taskManager.Load(mockTask.ID) task, loaded := taskManager.Load(mockTask.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(task.ID, mockTask.ID) assert.Equal(task.ID, mockTask.ID)
}, },
}, },
@ -209,8 +209,8 @@ func TestTaskManager_LoadOrStore(t *testing.T) {
expect: func(t *testing.T, taskManager TaskManager, mockTask *Task) { expect: func(t *testing.T, taskManager TaskManager, mockTask *Task) {
assert := assert.New(t) assert := assert.New(t)
taskManager.Store(mockTask) taskManager.Store(mockTask)
task, ok := taskManager.LoadOrStore(mockTask) task, loaded := taskManager.LoadOrStore(mockTask)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(task.ID, mockTask.ID) assert.Equal(task.ID, mockTask.ID)
}, },
}, },
@ -221,8 +221,8 @@ func TestTaskManager_LoadOrStore(t *testing.T) {
}, },
expect: func(t *testing.T, taskManager TaskManager, mockTask *Task) { expect: func(t *testing.T, taskManager TaskManager, mockTask *Task) {
assert := assert.New(t) assert := assert.New(t)
task, ok := taskManager.LoadOrStore(mockTask) task, loaded := taskManager.LoadOrStore(mockTask)
assert.Equal(ok, false) assert.Equal(loaded, false)
assert.Equal(task.ID, mockTask.ID) assert.Equal(task.ID, mockTask.ID)
}, },
}, },
@ -261,8 +261,8 @@ func TestTaskManager_Delete(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
taskManager.Store(mockTask) taskManager.Store(mockTask)
taskManager.Delete(mockTask.ID) taskManager.Delete(mockTask.ID)
_, ok := taskManager.Load(mockTask.ID) _, loaded := taskManager.Load(mockTask.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -275,8 +275,8 @@ func TestTaskManager_Delete(t *testing.T) {
mockTask.ID = "" mockTask.ID = ""
taskManager.Store(mockTask) taskManager.Store(mockTask)
taskManager.Delete(mockTask.ID) taskManager.Delete(mockTask.ID)
_, ok := taskManager.Load(mockTask.ID) _, loaded := taskManager.Load(mockTask.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
} }
@ -316,14 +316,14 @@ func TestTaskManager_RunGC(t *testing.T) {
err := taskManager.RunGC() err := taskManager.RunGC()
assert.NoError(err) assert.NoError(err)
task, ok := taskManager.Load(mockTask.ID) task, loaded := taskManager.Load(mockTask.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(task.FSM.Current(), TaskStateLeave) assert.Equal(task.FSM.Current(), TaskStateLeave)
err = taskManager.RunGC() err = taskManager.RunGC()
assert.NoError(err) assert.NoError(err)
_, ok = taskManager.Load(mockTask.ID) _, loaded = taskManager.Load(mockTask.ID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -338,8 +338,8 @@ func TestTaskManager_RunGC(t *testing.T) {
err := taskManager.RunGC() err := taskManager.RunGC()
assert.NoError(err) assert.NoError(err)
task, ok := taskManager.Load(mockTask.ID) task, loaded := taskManager.Load(mockTask.ID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(task.ID, mockTask.ID) assert.Equal(task.ID, mockTask.ID)
assert.Equal(task.FSM.Current(), TaskStatePending) assert.Equal(task.FSM.Current(), TaskStatePending)
}, },

92
scheduler/resource/task_test.go
View File

@ -105,7 +105,7 @@ func TestTask_LoadPeer(t *testing.T) {
url string url string
backToSourceLimit int32 backToSourceLimit int32
peerID string peerID string
expect func(t *testing.T, peer *Peer, ok bool) expect func(t *testing.T, peer *Peer, loaded bool)
}{ }{
{ {
name: "load peer", name: "load peer",
@ -114,9 +114,9 @@ func TestTask_LoadPeer(t *testing.T) {
url: mockTaskURL, url: mockTaskURL,
backToSourceLimit: mockTaskBackToSourceLimit, backToSourceLimit: mockTaskBackToSourceLimit,
peerID: mockPeerID, peerID: mockPeerID,
expect: func(t *testing.T, peer *Peer, ok bool) { expect: func(t *testing.T, peer *Peer, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeerID) assert.Equal(peer.ID, mockPeerID)
}, },
}, },
@ -127,9 +127,9 @@ func TestTask_LoadPeer(t *testing.T) {
url: mockTaskURL, url: mockTaskURL,
backToSourceLimit: mockTaskBackToSourceLimit, backToSourceLimit: mockTaskBackToSourceLimit,
peerID: idgen.PeerID("0.0.0.0"), peerID: idgen.PeerID("0.0.0.0"),
expect: func(t *testing.T, peer *Peer, ok bool) { expect: func(t *testing.T, peer *Peer, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -139,9 +139,9 @@ func TestTask_LoadPeer(t *testing.T) {
url: mockTaskURL, url: mockTaskURL,
backToSourceLimit: mockTaskBackToSourceLimit, backToSourceLimit: mockTaskBackToSourceLimit,
peerID: "", peerID: "",
expect: func(t *testing.T, peer *Peer, ok bool) { expect: func(t *testing.T, peer *Peer, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
} }
@ -153,8 +153,8 @@ func TestTask_LoadPeer(t *testing.T) {
mockPeer := NewPeer(mockPeerID, task, mockHost) mockPeer := NewPeer(mockPeerID, task, mockHost)
task.StorePeer(mockPeer) task.StorePeer(mockPeer)
peer, ok := task.LoadPeer(tc.peerID) peer, loaded := task.LoadPeer(tc.peerID)
tc.expect(t, peer, ok) tc.expect(t, peer, loaded)
}) })
} }
} }
@ -231,7 +231,7 @@ func TestTask_StorePeer(t *testing.T) {
url string url string
backToSourceLimit int32 backToSourceLimit int32
peerID string peerID string
expect func(t *testing.T, peer *Peer, ok bool) expect func(t *testing.T, peer *Peer, loaded bool)
}{ }{
{ {
name: "store peer", name: "store peer",
@ -240,9 +240,9 @@ func TestTask_StorePeer(t *testing.T) {
url: mockTaskURL, url: mockTaskURL,
backToSourceLimit: mockTaskBackToSourceLimit, backToSourceLimit: mockTaskBackToSourceLimit,
peerID: mockPeerID, peerID: mockPeerID,
expect: func(t *testing.T, peer *Peer, ok bool) { expect: func(t *testing.T, peer *Peer, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeerID) assert.Equal(peer.ID, mockPeerID)
}, },
}, },
@ -253,9 +253,9 @@ func TestTask_StorePeer(t *testing.T) {
url: mockTaskURL, url: mockTaskURL,
backToSourceLimit: mockTaskBackToSourceLimit, backToSourceLimit: mockTaskBackToSourceLimit,
peerID: "", peerID: "",
expect: func(t *testing.T, peer *Peer, ok bool) { expect: func(t *testing.T, peer *Peer, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, "") assert.Equal(peer.ID, "")
}, },
}, },
@ -268,8 +268,8 @@ func TestTask_StorePeer(t *testing.T) {
mockPeer := NewPeer(tc.peerID, task, mockHost) mockPeer := NewPeer(tc.peerID, task, mockHost)
task.StorePeer(mockPeer) task.StorePeer(mockPeer)
peer, ok := task.LoadPeer(tc.peerID) peer, loaded := task.LoadPeer(tc.peerID)
tc.expect(t, peer, ok) tc.expect(t, peer, loaded)
}) })
} }
} }
@ -293,8 +293,8 @@ func TestTask_DeletePeer(t *testing.T) {
peerID: mockPeerID, peerID: mockPeerID,
expect: func(t *testing.T, task *Task) { expect: func(t *testing.T, task *Task) {
assert := assert.New(t) assert := assert.New(t)
_, ok := task.LoadPeer(mockPeerID) _, loaded := task.LoadPeer(mockPeerID)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -306,8 +306,8 @@ func TestTask_DeletePeer(t *testing.T) {
peerID: "", peerID: "",
expect: func(t *testing.T, task *Task) { expect: func(t *testing.T, task *Task) {
assert := assert.New(t) assert := assert.New(t)
peer, ok := task.LoadPeer(mockPeerID) peer, loaded := task.LoadPeer(mockPeerID)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(peer.ID, mockPeerID) assert.Equal(peer.ID, mockPeerID)
}, },
}, },
@ -1046,8 +1046,8 @@ func TestTask_LoadSeedPeer(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
task.StorePeer(mockPeer) task.StorePeer(mockPeer)
task.StorePeer(mockSeedPeer) task.StorePeer(mockSeedPeer)
peer, ok := task.LoadSeedPeer() peer, loaded := task.LoadSeedPeer()
assert.True(ok) assert.True(loaded)
assert.Equal(peer.ID, mockSeedPeer.ID) assert.Equal(peer.ID, mockSeedPeer.ID)
}, },
}, },
@ -1062,8 +1062,8 @@ func TestTask_LoadSeedPeer(t *testing.T) {
mockPeer.UpdatedAt.Store(time.Now()) mockPeer.UpdatedAt.Store(time.Now())
mockSeedPeer.UpdatedAt.Store(time.Now().Add(1 * time.Second)) mockSeedPeer.UpdatedAt.Store(time.Now().Add(1 * time.Second))
peer, ok := task.LoadSeedPeer() peer, loaded := task.LoadSeedPeer()
assert.True(ok) assert.True(loaded)
assert.Equal(peer.ID, mockSeedPeer.ID) assert.Equal(peer.ID, mockSeedPeer.ID)
}, },
}, },
@ -1071,8 +1071,8 @@ func TestTask_LoadSeedPeer(t *testing.T) {
name: "peers is empty", name: "peers is empty",
expect: func(t *testing.T, task *Task, mockPeer *Peer, mockSeedPeer *Peer) { expect: func(t *testing.T, task *Task, mockPeer *Peer, mockSeedPeer *Peer) {
assert := assert.New(t) assert := assert.New(t)
_, ok := task.LoadSeedPeer() _, loaded := task.LoadSeedPeer()
assert.False(ok) assert.False(loaded)
}, },
}, },
{ {
@ -1080,8 +1080,8 @@ func TestTask_LoadSeedPeer(t *testing.T) {
expect: func(t *testing.T, task *Task, mockPeer *Peer, mockSeedPeer *Peer) { expect: func(t *testing.T, task *Task, mockPeer *Peer, mockSeedPeer *Peer) {
assert := assert.New(t) assert := assert.New(t)
task.StorePeer(mockPeer) task.StorePeer(mockPeer)
_, ok := task.LoadSeedPeer() _, loaded := task.LoadSeedPeer()
assert.False(ok) assert.False(loaded)
}, },
}, },
} }
@ -1171,7 +1171,7 @@ func TestTask_LoadPiece(t *testing.T) {
backToSourceLimit int32 backToSourceLimit int32
pieceInfo *commonv1.PieceInfo pieceInfo *commonv1.PieceInfo
pieceNum int32 pieceNum int32
expect func(t *testing.T, piece *commonv1.PieceInfo, ok bool) expect func(t *testing.T, piece *commonv1.PieceInfo, loaded bool)
}{ }{
{ {
name: "load piece", name: "load piece",
@ -1181,9 +1181,9 @@ func TestTask_LoadPiece(t *testing.T) {
backToSourceLimit: mockTaskBackToSourceLimit, backToSourceLimit: mockTaskBackToSourceLimit,
pieceInfo: mockPieceInfo, pieceInfo: mockPieceInfo,
pieceNum: mockPieceInfo.PieceNum, pieceNum: mockPieceInfo.PieceNum,
expect: func(t *testing.T, piece *commonv1.PieceInfo, ok bool) { expect: func(t *testing.T, piece *commonv1.PieceInfo, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(piece.PieceNum, mockPieceInfo.PieceNum) assert.Equal(piece.PieceNum, mockPieceInfo.PieceNum)
}, },
}, },
@ -1195,9 +1195,9 @@ func TestTask_LoadPiece(t *testing.T) {
backToSourceLimit: mockTaskBackToSourceLimit, backToSourceLimit: mockTaskBackToSourceLimit,
pieceInfo: mockPieceInfo, pieceInfo: mockPieceInfo,
pieceNum: 2, pieceNum: 2,
expect: func(t *testing.T, piece *commonv1.PieceInfo, ok bool) { expect: func(t *testing.T, piece *commonv1.PieceInfo, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -1208,9 +1208,9 @@ func TestTask_LoadPiece(t *testing.T) {
backToSourceLimit: mockTaskBackToSourceLimit, backToSourceLimit: mockTaskBackToSourceLimit,
pieceInfo: mockPieceInfo, pieceInfo: mockPieceInfo,
pieceNum: 0, pieceNum: 0,
expect: func(t *testing.T, piece *commonv1.PieceInfo, ok bool) { expect: func(t *testing.T, piece *commonv1.PieceInfo, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
} }
@ -1220,8 +1220,8 @@ func TestTask_LoadPiece(t *testing.T) {
task := NewTask(tc.id, tc.url, commonv1.TaskType_Normal, tc.urlMeta, WithBackToSourceLimit(tc.backToSourceLimit)) task := NewTask(tc.id, tc.url, commonv1.TaskType_Normal, tc.urlMeta, WithBackToSourceLimit(tc.backToSourceLimit))
task.StorePiece(tc.pieceInfo) task.StorePiece(tc.pieceInfo)
piece, ok := task.LoadPiece(tc.pieceNum) piece, loaded := task.LoadPiece(tc.pieceNum)
tc.expect(t, piece, ok) tc.expect(t, piece, loaded)
}) })
} }
} }
@ -1235,7 +1235,7 @@ func TestTask_StorePiece(t *testing.T) {
backToSourceLimit int32 backToSourceLimit int32
pieceInfo *commonv1.PieceInfo pieceInfo *commonv1.PieceInfo
pieceNum int32 pieceNum int32
expect func(t *testing.T, piece *commonv1.PieceInfo, ok bool) expect func(t *testing.T, piece *commonv1.PieceInfo, loaded bool)
}{ }{
{ {
name: "store piece", name: "store piece",
@ -1245,9 +1245,9 @@ func TestTask_StorePiece(t *testing.T) {
backToSourceLimit: mockTaskBackToSourceLimit, backToSourceLimit: mockTaskBackToSourceLimit,
pieceInfo: mockPieceInfo, pieceInfo: mockPieceInfo,
pieceNum: mockPieceInfo.PieceNum, pieceNum: mockPieceInfo.PieceNum,
expect: func(t *testing.T, piece *commonv1.PieceInfo, ok bool) { expect: func(t *testing.T, piece *commonv1.PieceInfo, loaded bool) {
assert := assert.New(t) assert := assert.New(t)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(piece.PieceNum, mockPieceInfo.PieceNum) assert.Equal(piece.PieceNum, mockPieceInfo.PieceNum)
}, },
}, },
@ -1258,8 +1258,8 @@ func TestTask_StorePiece(t *testing.T) {
task := NewTask(tc.id, tc.url, commonv1.TaskType_Normal, tc.urlMeta, WithBackToSourceLimit(tc.backToSourceLimit)) task := NewTask(tc.id, tc.url, commonv1.TaskType_Normal, tc.urlMeta, WithBackToSourceLimit(tc.backToSourceLimit))
task.StorePiece(tc.pieceInfo) task.StorePiece(tc.pieceInfo)
piece, ok := task.LoadPiece(tc.pieceNum) piece, loaded := task.LoadPiece(tc.pieceNum)
tc.expect(t, piece, ok) tc.expect(t, piece, loaded)
}) })
} }
} }
@ -1285,8 +1285,8 @@ func TestTask_DeletePiece(t *testing.T) {
pieceNum: mockPieceInfo.PieceNum, pieceNum: mockPieceInfo.PieceNum,
expect: func(t *testing.T, task *Task) { expect: func(t *testing.T, task *Task) {
assert := assert.New(t) assert := assert.New(t)
_, ok := task.LoadPiece(mockPieceInfo.PieceNum) _, loaded := task.LoadPiece(mockPieceInfo.PieceNum)
assert.Equal(ok, false) assert.Equal(loaded, false)
}, },
}, },
{ {
@ -1299,8 +1299,8 @@ func TestTask_DeletePiece(t *testing.T) {
pieceNum: 0, pieceNum: 0,
expect: func(t *testing.T, task *Task) { expect: func(t *testing.T, task *Task) {
assert := assert.New(t) assert := assert.New(t)
piece, ok := task.LoadPiece(mockPieceInfo.PieceNum) piece, loaded := task.LoadPiece(mockPieceInfo.PieceNum)
assert.Equal(ok, true) assert.Equal(loaded, true)
assert.Equal(piece.PieceNum, mockPieceInfo.PieceNum) assert.Equal(piece.PieceNum, mockPieceInfo.PieceNum)
}, },
}, },

12
scheduler/scheduler/scheduler.go
View File

@ -80,8 +80,8 @@ func (s *scheduler) ScheduleParent(ctx context.Context, peer *resource.Peer, blo
peer.Log.Infof("peer needs to back-to-source: %t", needBackToSource) peer.Log.Infof("peer needs to back-to-source: %t", needBackToSource)
if (n >= s.config.RetryBackToSourceLimit || needBackToSource) && if (n >= s.config.RetryBackToSourceLimit || needBackToSource) &&
peer.Task.CanBackToSource() { peer.Task.CanBackToSource() {
stream, ok := peer.LoadStream() stream, loaded := peer.LoadStream()
if !ok { if !loaded {
peer.Log.Error("load stream failed") peer.Log.Error("load stream failed")
return return
} }
@ -112,8 +112,8 @@ func (s *scheduler) ScheduleParent(ctx context.Context, peer *resource.Peer, blo
// Handle peer schedule failed. // Handle peer schedule failed.
if n >= s.config.RetryLimit { if n >= s.config.RetryLimit {
stream, ok := peer.LoadStream() stream, loaded := peer.LoadStream()
if !ok { if !loaded {
peer.Log.Error("load stream failed") peer.Log.Error("load stream failed")
return return
} }
@ -193,8 +193,8 @@ func (s *scheduler) NotifyAndFindParent(ctx context.Context, peer *resource.Peer
} }
// Send scheduling success message. // Send scheduling success message.
stream, ok := peer.LoadStream() stream, loaded := peer.LoadStream()
if !ok { if !loaded {
peer.Log.Error("load peer stream failed") peer.Log.Error("load peer stream failed")
return []*resource.Peer{}, false return []*resource.Peer{}, false
} }

4
scheduler/scheduler/scheduler_test.go
View File

@ -903,8 +903,8 @@ 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) scheduler := New(mockSchedulerConfig, dynconfig, mockPluginDir)
parent, ok := scheduler.FindParent(context.Background(), peer, blocklist) parent, found := scheduler.FindParent(context.Background(), peer, blocklist)
tc.expect(t, peer, mockPeers, parent, ok) tc.expect(t, peer, mockPeers, parent, found)
}) })
} }
} }

8
scheduler/service/service_v1.go
View File

@ -675,8 +675,8 @@ 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, ok := v.scheduler.FindParent(ctx, peer, set.NewSafeSet[string]()) parent, found := v.scheduler.FindParent(ctx, peer, set.NewSafeSet[string]())
if !ok { if !found {
return nil, errors.New("parent not found") return nil, errors.New("parent not found")
} }
@ -870,8 +870,8 @@ func (v *V1) handlePieceFailure(ctx context.Context, peer *resource.Peer, piece
// Returns an scheduling error if the peer // Returns an scheduling error if the peer
// state is not PeerStateRunning. // state is not PeerStateRunning.
stream, ok := peer.LoadStream() stream, loaded := peer.LoadStream()
if !ok { if !loaded {
peer.Log.Error("load stream failed") peer.Log.Error("load stream failed")
return return
} }

40
scheduler/service/service_v1_test.go
View File

@ -996,8 +996,8 @@ func TestService_ReportPieceResult(t *testing.T) {
expect: func(t *testing.T, peer *resource.Peer, err error) { expect: func(t *testing.T, peer *resource.Peer, err error) {
assert := assert.New(t) assert := assert.New(t)
assert.NoError(err) assert.NoError(err)
_, ok := peer.LoadStream() _, loaded := peer.LoadStream()
assert.False(ok) assert.False(loaded)
}, },
}, },
{ {
@ -1024,8 +1024,8 @@ func TestService_ReportPieceResult(t *testing.T) {
expect: func(t *testing.T, peer *resource.Peer, err error) { expect: func(t *testing.T, peer *resource.Peer, err error) {
assert := assert.New(t) assert := assert.New(t)
assert.NoError(err) assert.NoError(err)
_, ok := peer.LoadStream() _, loaded := peer.LoadStream()
assert.False(ok) assert.False(loaded)
}, },
}, },
{ {
@ -1053,8 +1053,8 @@ func TestService_ReportPieceResult(t *testing.T) {
expect: func(t *testing.T, peer *resource.Peer, err error) { expect: func(t *testing.T, peer *resource.Peer, err error) {
assert := assert.New(t) assert := assert.New(t)
assert.NoError(err) assert.NoError(err)
_, ok := peer.LoadStream() _, loaded := peer.LoadStream()
assert.False(ok) assert.False(loaded)
}, },
}, },
{ {
@ -1079,8 +1079,8 @@ func TestService_ReportPieceResult(t *testing.T) {
expect: func(t *testing.T, peer *resource.Peer, err error) { expect: func(t *testing.T, peer *resource.Peer, err error) {
assert := assert.New(t) assert := assert.New(t)
assert.NoError(err) assert.NoError(err)
_, ok := peer.LoadStream() _, loaded := peer.LoadStream()
assert.False(ok) assert.False(loaded)
}, },
}, },
{ {
@ -1106,8 +1106,8 @@ func TestService_ReportPieceResult(t *testing.T) {
expect: func(t *testing.T, peer *resource.Peer, err error) { expect: func(t *testing.T, peer *resource.Peer, err error) {
assert := assert.New(t) assert := assert.New(t)
assert.NoError(err) assert.NoError(err)
_, ok := peer.LoadStream() _, loaded := peer.LoadStream()
assert.False(ok) assert.False(loaded)
}, },
}, },
} }
@ -1473,8 +1473,8 @@ func TestService_AnnounceTask(t *testing.T) {
assert.Equal(mockTask.FSM.Current(), resource.TaskStateSucceeded) assert.Equal(mockTask.FSM.Current(), resource.TaskStateSucceeded)
assert.Equal(mockTask.TotalPieceCount.Load(), int32(1)) assert.Equal(mockTask.TotalPieceCount.Load(), int32(1))
assert.Equal(mockTask.ContentLength.Load(), int64(1000)) assert.Equal(mockTask.ContentLength.Load(), int64(1000))
piece, ok := mockTask.LoadPiece(1) piece, loaded := mockTask.LoadPiece(1)
assert.True(ok) assert.True(loaded)
assert.EqualValues(piece, &commonv1.PieceInfo{PieceNum: 1, DownloadCost: 1}) assert.EqualValues(piece, &commonv1.PieceInfo{PieceNum: 1, DownloadCost: 1})
assert.Equal(mockPeer.FinishedPieces.Count(), uint(1)) assert.Equal(mockPeer.FinishedPieces.Count(), uint(1))
@ -1518,8 +1518,8 @@ func TestService_AnnounceTask(t *testing.T) {
assert.Equal(mockTask.FSM.Current(), resource.TaskStateSucceeded) assert.Equal(mockTask.FSM.Current(), resource.TaskStateSucceeded)
assert.Equal(mockTask.TotalPieceCount.Load(), int32(1)) assert.Equal(mockTask.TotalPieceCount.Load(), int32(1))
assert.Equal(mockTask.ContentLength.Load(), int64(1000)) assert.Equal(mockTask.ContentLength.Load(), int64(1000))
piece, ok := mockTask.LoadPiece(1) piece, loaded := mockTask.LoadPiece(1)
assert.True(ok) assert.True(loaded)
assert.EqualValues(piece, &commonv1.PieceInfo{PieceNum: 1, DownloadCost: 1}) assert.EqualValues(piece, &commonv1.PieceInfo{PieceNum: 1, DownloadCost: 1})
assert.Equal(mockPeer.FinishedPieces.Count(), uint(1)) assert.Equal(mockPeer.FinishedPieces.Count(), uint(1))
@ -1563,8 +1563,8 @@ func TestService_AnnounceTask(t *testing.T) {
assert.Equal(mockTask.FSM.Current(), resource.TaskStateSucceeded) assert.Equal(mockTask.FSM.Current(), resource.TaskStateSucceeded)
assert.Equal(mockTask.TotalPieceCount.Load(), int32(1)) assert.Equal(mockTask.TotalPieceCount.Load(), int32(1))
assert.Equal(mockTask.ContentLength.Load(), int64(1000)) assert.Equal(mockTask.ContentLength.Load(), int64(1000))
piece, ok := mockTask.LoadPiece(1) piece, loaded := mockTask.LoadPiece(1)
assert.True(ok) assert.True(loaded)
assert.EqualValues(piece, &commonv1.PieceInfo{PieceNum: 1, DownloadCost: 1}) assert.EqualValues(piece, &commonv1.PieceInfo{PieceNum: 1, DownloadCost: 1})
assert.Equal(mockPeer.FinishedPieces.Count(), uint(1)) assert.Equal(mockPeer.FinishedPieces.Count(), uint(1))
@ -1608,8 +1608,8 @@ func TestService_AnnounceTask(t *testing.T) {
assert.Equal(mockTask.FSM.Current(), resource.TaskStateSucceeded) assert.Equal(mockTask.FSM.Current(), resource.TaskStateSucceeded)
assert.Equal(mockTask.TotalPieceCount.Load(), int32(1)) assert.Equal(mockTask.TotalPieceCount.Load(), int32(1))
assert.Equal(mockTask.ContentLength.Load(), int64(1000)) assert.Equal(mockTask.ContentLength.Load(), int64(1000))
piece, ok := mockTask.LoadPiece(1) piece, loaded := mockTask.LoadPiece(1)
assert.True(ok) assert.True(loaded)
assert.EqualValues(piece, &commonv1.PieceInfo{PieceNum: 1, DownloadCost: 1}) assert.EqualValues(piece, &commonv1.PieceInfo{PieceNum: 1, DownloadCost: 1})
assert.Equal(mockPeer.FinishedPieces.Count(), uint(1)) assert.Equal(mockPeer.FinishedPieces.Count(), uint(1))
@ -2950,8 +2950,8 @@ func TestService_handlePieceSuccess(t *testing.T) {
assert.Equal(peer.Pieces.Len(), uint(1)) assert.Equal(peer.Pieces.Len(), uint(1))
assert.Equal(peer.FinishedPieces.Count(), uint(1)) assert.Equal(peer.FinishedPieces.Count(), uint(1))
assert.Equal(peer.PieceCosts(), []int64{1}) assert.Equal(peer.PieceCosts(), []int64{1})
piece, ok := peer.Task.LoadPiece(0) piece, loaded := peer.Task.LoadPiece(0)
assert.True(ok) assert.True(loaded)
assert.EqualValues(piece, &commonv1.PieceInfo{ assert.EqualValues(piece, &commonv1.PieceInfo{
PieceNum: 0, PieceNum: 0,
PieceMd5: "ac32345ef819f03710e2105c81106fdd", PieceMd5: "ac32345ef819f03710e2105c81106fdd",