mirrors/navidrome
1
0
Fork 0
mirror of https://github.com/navidrome/navidrome.git synced 2025-04-04 04:57:37 +03:00
Code Issues Projects Releases Packages Wiki Activity

NowPlaying is not a repo, now it is part of the main engine

Browse source
This commit is contained in:
Deluan 2020-01-18 20:21:25 -05:00
parent 128e165aba
commit 3c66da0b17
11 changed files with 168 additions and 178 deletions
Download patch file Download diff file Expand all files Collapse all files

4
engine/list_generator.go
View file

@ -22,7 +22,7 @@ type ListGenerator interface {
GetRandomSongs(size int) (Entries, error)
}
func NewListGenerator(arr model.ArtistRepository, alr model.AlbumRepository, mfr model.MediaFileRepository, npr model.NowPlayingRepository) ListGenerator {
func NewListGenerator(arr model.ArtistRepository, alr model.AlbumRepository, mfr model.MediaFileRepository, npr NowPlayingRepository) ListGenerator {
return &listGenerator{arr, alr, mfr, npr}
}
@ -30,7 +30,7 @@ type listGenerator struct {
artistRepo model.ArtistRepository
albumRepo model.AlbumRepository
mfRepository model.MediaFileRepository
npRepo model.NowPlayingRepository
npRepo NowPlayingRepository
}
func (g *listGenerator) query(qo model.QueryOptions, offset int, size int) (Entries, error) {

22
engine/mock_nowplaying_repo.go
View file

@ -3,8 +3,6 @@ package engine
import (
"errors"
"time"
"github.com/cloudsonic/sonic-server/model"
)
func CreateMockNowPlayingRepo() *MockNowPlaying {
@ -12,8 +10,8 @@ func CreateMockNowPlayingRepo() *MockNowPlaying {
}
type MockNowPlaying struct {
model.NowPlayingRepository
data []model.NowPlayingInfo
NowPlayingRepository
data []NowPlayingInfo
t time.Time
err bool
}
@ -22,12 +20,12 @@ func (m *MockNowPlaying) SetError(err bool) {
m.err = err
}
func (m *MockNowPlaying) Enqueue(info *model.NowPlayingInfo) error {
func (m *MockNowPlaying) Enqueue(info *NowPlayingInfo) error {
if m.err {
return errors.New("Error!")
}
m.data = append(m.data, model.NowPlayingInfo{})
m.data = append(m.data, NowPlayingInfo{})
copy(m.data[1:], m.data[0:])
m.data[0] = *info
@ -39,7 +37,7 @@ func (m *MockNowPlaying) Enqueue(info *model.NowPlayingInfo) error {
return nil
}
func (m *MockNowPlaying) Dequeue(playerId int) (*model.NowPlayingInfo, error) {
func (m *MockNowPlaying) Dequeue(playerId int) (*NowPlayingInfo, error) {
if len(m.data) == 0 {
return nil, nil
}
@ -54,15 +52,15 @@ func (m *MockNowPlaying) Count(playerId int) (int64, error) {
return int64(len(m.data)), nil
}
func (m *MockNowPlaying) GetAll() ([]*model.NowPlayingInfo, error) {
func (m *MockNowPlaying) GetAll() ([]*NowPlayingInfo, error) {
np, err := m.Head(1)
if np == nil || err != nil {
return nil, err
}
return []*model.NowPlayingInfo{np}, err
return []*NowPlayingInfo{np}, err
}
func (m *MockNowPlaying) Head(playerId int) (*model.NowPlayingInfo, error) {
func (m *MockNowPlaying) Head(playerId int) (*NowPlayingInfo, error) {
if len(m.data) == 0 {
return nil, nil
}
@ -70,7 +68,7 @@ func (m *MockNowPlaying) Head(playerId int) (*model.NowPlayingInfo, error) {
return &info, nil
}
func (m *MockNowPlaying) Tail(playerId int) (*model.NowPlayingInfo, error) {
func (m *MockNowPlaying) Tail(playerId int) (*NowPlayingInfo, error) {
if len(m.data) == 0 {
return nil, nil
}
@ -79,7 +77,7 @@ func (m *MockNowPlaying) Tail(playerId int) (*model.NowPlayingInfo, error) {
}
func (m *MockNowPlaying) ClearAll() {
m.data = make([]model.NowPlayingInfo, 0)
m.data = make([]NowPlayingInfo, 0)
m.err = false
}

102
engine/nowplaying.go Normal file
View file

@ -0,0 +1,102 @@
package engine
import (
"container/list"
"sync"
"time"
)
const NowPlayingExpire = 60 * time.Minute
type NowPlayingInfo struct {
TrackID string
Start time.Time
Username string
PlayerId int
PlayerName string
}
// This repo must have the semantics of a FIFO queue, for each playerId
type NowPlayingRepository interface {
// Insert at the head of the queue
Enqueue(*NowPlayingInfo) error
// Removes and returns the element at the end of the queue
Dequeue(playerId int) (*NowPlayingInfo, error)
// Returns the element at the head of the queue (last inserted one)
Head(playerId int) (*NowPlayingInfo, error)
// Returns the element at the end of the queue (first inserted one)
Tail(playerId int) (*NowPlayingInfo, error)
// Size of the queue for the playerId
Count(playerId int) (int64, error)
// Returns all heads from all playerIds
GetAll() ([]*NowPlayingInfo, error)
}
var playerMap = sync.Map{}
type nowPlayingRepository struct{}
func NewNowPlayingRepository() NowPlayingRepository {
r := &nowPlayingRepository{}
return r
}
func (r *nowPlayingRepository) getList(id int) *list.List {
l, _ := playerMap.LoadOrStore(id, list.New())
return l.(*list.List)
}
func (r *nowPlayingRepository) Enqueue(info *NowPlayingInfo) error {
l := r.getList(info.PlayerId)
l.PushFront(info)
return nil
}
func (r *nowPlayingRepository) Dequeue(playerId int) (*NowPlayingInfo, error) {
l := r.getList(playerId)
e := l.Back()
if e == nil {
return nil, nil
}
l.Remove(e)
return e.Value.(*NowPlayingInfo), nil
}
func (r *nowPlayingRepository) Head(playerId int) (*NowPlayingInfo, error) {
l := r.getList(playerId)
e := l.Front()
if e == nil {
return nil, nil
}
return e.Value.(*NowPlayingInfo), nil
}
func (r *nowPlayingRepository) Tail(playerId int) (*NowPlayingInfo, error) {
l := r.getList(playerId)
e := l.Back()
if e == nil {
return nil, nil
}
return e.Value.(*NowPlayingInfo), nil
}
func (r *nowPlayingRepository) Count(playerId int) (int64, error) {
l := r.getList(playerId)
return int64(l.Len()), nil
}
func (r *nowPlayingRepository) GetAll() ([]*NowPlayingInfo, error) {
var all []*NowPlayingInfo
playerMap.Range(func(playerId, l interface{}) bool {
ll := l.(*list.List)
e := ll.Front()
all = append(all, e.Value.(*NowPlayingInfo))
return true
})
return all, nil
}

49
engine/nowplaying_repository_test.go Normal file
View file

@ -0,0 +1,49 @@
package engine
import (
"sync"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("NowPlayingRepository", func() {
var repo NowPlayingRepository
BeforeEach(func() {
playerMap = sync.Map{}
repo = NewNowPlayingRepository()
})
It("enqueues and dequeues records", func() {
Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA"})).To(BeNil())
Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 1, TrackID: "BBB"})).To(BeNil())
Expect(repo.Tail(1)).To(Equal(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Head(1)).To(Equal(&NowPlayingInfo{PlayerId: 1, TrackID: "BBB"}))
Expect(repo.Count(1)).To(Equal(int64(2)))
Expect(repo.Dequeue(1)).To(Equal(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Count(1)).To(Equal(int64(1)))
})
It("handles multiple players", func() {
Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA"})).To(BeNil())
Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 1, TrackID: "BBB"})).To(BeNil())
Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 2, TrackID: "CCC"})).To(BeNil())
Expect(repo.Enqueue(&NowPlayingInfo{PlayerId: 2, TrackID: "DDD"})).To(BeNil())
Expect(repo.GetAll()).To(ConsistOf([]*NowPlayingInfo{
{PlayerId: 1, TrackID: "BBB"},
{PlayerId: 2, TrackID: "DDD"},
}))
Expect(repo.Count(2)).To(Equal(int64(2)))
Expect(repo.Count(2)).To(Equal(int64(2)))
Expect(repo.Tail(1)).To(Equal(&NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Head(2)).To(Equal(&NowPlayingInfo{PlayerId: 2, TrackID: "DDD"}))
})
})

6
engine/scrobbler.go
View file

@ -21,14 +21,14 @@ type Scrobbler interface {
NowPlaying(ctx context.Context, playerId int, playerName, trackId, username string) (*model.MediaFile, error)
}
func NewScrobbler(itunes itunesbridge.ItunesControl, mr model.MediaFileRepository, npr model.NowPlayingRepository) Scrobbler {
func NewScrobbler(itunes itunesbridge.ItunesControl, mr model.MediaFileRepository, npr NowPlayingRepository) Scrobbler {
return &scrobbler{itunes, mr, npr}
}
type scrobbler struct {
itunes itunesbridge.ItunesControl
mfRepo model.MediaFileRepository
npRepo model.NowPlayingRepository
npRepo NowPlayingRepository
}
func (s *scrobbler) detectSkipped(ctx context.Context, playerId int, trackId string) {
@ -96,6 +96,6 @@ func (s *scrobbler) NowPlaying(ctx context.Context, playerId int, playerName, tr
return nil, errors.New(fmt.Sprintf(`ID "%s" not found`, trackId))
}
info := &model.NowPlayingInfo{TrackID: trackId, Username: username, Start: time.Now(), PlayerId: playerId, PlayerName: playerName}
info := &NowPlayingInfo{TrackID: trackId, Username: username, Start: time.Now(), PlayerId: playerId, PlayerName: playerName}
return mf, s.npRepo.Enqueue(info)
}

1
engine/wire_providers.go
View file

@ -10,4 +10,5 @@ var Set = wire.NewSet(
NewRatings,
NewScrobbler,
NewSearch,
NewNowPlayingRepository,
)

34
model/nowplaying.go
View file

@ -1,34 +0,0 @@
package model
import "time"
const NowPlayingExpire = 60 * time.Minute
type NowPlayingInfo struct {
TrackID string
Start time.Time
Username string
PlayerId int
PlayerName string
}
// This repo must have the semantics of a FIFO queue, for each playerId
type NowPlayingRepository interface {
// Insert at the head of the queue
Enqueue(*NowPlayingInfo) error
// Removes and returns the element at the end of the queue
Dequeue(playerId int) (*NowPlayingInfo, error)
// Returns the element at the head of the queue (last inserted one)
Head(playerId int) (*NowPlayingInfo, error)
// Returns the element at the end of the queue (first inserted one)
Tail(playerId int) (*NowPlayingInfo, error)
// Size of the queue for the playerId
Count(playerId int) (int64, error)
// Returns all heads from all playerIds
GetAll() ([]*NowPlayingInfo, error)
}

75
persistence/nowplaying_repository.go
View file

@ -1,75 +0,0 @@
package persistence
import (
"container/list"
"sync"
"github.com/cloudsonic/sonic-server/model"
)
var playerMap = sync.Map{}
type nowPlayingRepository struct{}
// TODO Make it persistent
func NewNowPlayingRepository() model.NowPlayingRepository {
r := &nowPlayingRepository{}
return r
}
func (r *nowPlayingRepository) getList(id int) *list.List {
l, _ := playerMap.LoadOrStore(id, list.New())
return l.(*list.List)
}
func (r *nowPlayingRepository) Enqueue(info *model.NowPlayingInfo) error {
l := r.getList(info.PlayerId)
l.PushFront(info)
return nil
}
func (r *nowPlayingRepository) Dequeue(playerId int) (*model.NowPlayingInfo, error) {
l := r.getList(playerId)
e := l.Back()
if e == nil {
return nil, nil
}
l.Remove(e)
return e.Value.(*model.NowPlayingInfo), nil
}
func (r *nowPlayingRepository) Head(playerId int) (*model.NowPlayingInfo, error) {
l := r.getList(playerId)
e := l.Front()
if e == nil {
return nil, nil
}
return e.Value.(*model.NowPlayingInfo), nil
}
func (r *nowPlayingRepository) Tail(playerId int) (*model.NowPlayingInfo, error) {
l := r.getList(playerId)
e := l.Back()
if e == nil {
return nil, nil
}
return e.Value.(*model.NowPlayingInfo), nil
}
func (r *nowPlayingRepository) Count(playerId int) (int64, error) {
l := r.getList(playerId)
return int64(l.Len()), nil
}
func (r *nowPlayingRepository) GetAll() ([]*model.NowPlayingInfo, error) {
var all []*model.NowPlayingInfo
playerMap.Range(func(playerId, l interface{}) bool {
ll := l.(*list.List)
e := ll.Front()
all = append(all, e.Value.(*model.NowPlayingInfo))
return true
})
return all, nil
}
var _ model.NowPlayingRepository = (*nowPlayingRepository)(nil)

50
persistence/nowplaying_repository_test.go
View file

@ -1,50 +0,0 @@
package persistence
import (
"sync"
"github.com/cloudsonic/sonic-server/model"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("NowPlayingRepository", func() {
var repo model.NowPlayingRepository
BeforeEach(func() {
playerMap = sync.Map{}
repo = NewNowPlayingRepository()
})
It("enqueues and dequeues records", func() {
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"})).To(BeNil())
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 1, TrackID: "BBB"})).To(BeNil())
Expect(repo.Tail(1)).To(Equal(&model.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Head(1)).To(Equal(&model.NowPlayingInfo{PlayerId: 1, TrackID: "BBB"}))
Expect(repo.Count(1)).To(Equal(int64(2)))
Expect(repo.Dequeue(1)).To(Equal(&model.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Count(1)).To(Equal(int64(1)))
})
It("handles multiple players", func() {
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"})).To(BeNil())
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 1, TrackID: "BBB"})).To(BeNil())
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 2, TrackID: "CCC"})).To(BeNil())
Expect(repo.Enqueue(&model.NowPlayingInfo{PlayerId: 2, TrackID: "DDD"})).To(BeNil())
Expect(repo.GetAll()).To(ConsistOf([]*model.NowPlayingInfo{
{PlayerId: 1, TrackID: "BBB"},
{PlayerId: 2, TrackID: "DDD"},
}))
Expect(repo.Count(2)).To(Equal(int64(2)))
Expect(repo.Count(2)).To(Equal(int64(2)))
Expect(repo.Tail(1)).To(Equal(&model.NowPlayingInfo{PlayerId: 1, TrackID: "AAA"}))
Expect(repo.Head(2)).To(Equal(&model.NowPlayingInfo{PlayerId: 2, TrackID: "DDD"}))
})
})

1
persistence/wire_provider.go
View file

@ -11,7 +11,6 @@ var Set = wire.NewSet(
NewCheckSumRepository,
NewPropertyRepository,
NewPlaylistRepository,
NewNowPlayingRepository,
NewMediaFolderRepository,
NewGenreRepository,
)

2
wire_gen.go
View file

@ -42,7 +42,7 @@ func CreateSubsonicAPIRouter() *api.Router {
genreRepository := persistence.NewGenreRepository()
browser := engine.NewBrowser(propertyRepository, mediaFolderRepository, artistRepository, albumRepository, mediaFileRepository, genreRepository)
cover := engine.NewCover(mediaFileRepository, albumRepository)
nowPlayingRepository := persistence.NewNowPlayingRepository()
nowPlayingRepository := engine.NewNowPlayingRepository()
listGenerator := engine.NewListGenerator(artistRepository, albumRepository, mediaFileRepository, nowPlayingRepository)
itunesControl := itunesbridge.NewItunesControl()
playlistRepository := persistence.NewPlaylistRepository()