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

engine/list_generator.go

@@ -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) {

engine/mock_nowplaying_repo.go

@@ -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
+	NowPlayingRepository
-	data []model.NowPlayingInfo
+	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
 }
 

engine/nowplaying.go

@@ -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
+}

engine/nowplaying_repository_test.go

@@ -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"}))
+	})
+})

engine/scrobbler.go

@@ -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)
 }

engine/wire_providers.go

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

model/nowplaying.go

@@ -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)
-}

persistence/nowplaying_repository.go

@@ -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)

persistence/nowplaying_repository_test.go

@@ -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"}))
-	})
-})

persistence/wire_provider.go

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

wire_gen.go

@@ -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()