Renamed persistence packages

persistence/db_storm/album_repository.go

@@ -0,0 +1,110 @@
+package db_storm
+
+import (
+	"time"
+
+	"github.com/asdine/storm/q"
+	"github.com/cloudsonic/sonic-server/domain"
+)
+
+type _Album struct {
+	ID           string    ``
+	Name         string    `storm:"index"`
+	ArtistID     string    `storm:"index"`
+	CoverArtPath string    ``
+	CoverArtId   string    ``
+	Artist       string    `storm:"index"`
+	AlbumArtist  string    ``
+	Year         int       `storm:"index"`
+	Compilation  bool      ``
+	Starred      bool      `storm:"index"`
+	PlayCount    int       `storm:"index"`
+	PlayDate     time.Time `storm:"index"`
+	SongCount    int       ``
+	Duration     int       ``
+	Rating       int       `storm:"index"`
+	Genre        string    ``
+	StarredAt    time.Time `storm:"index"`
+	CreatedAt    time.Time `storm:"index"`
+	UpdatedAt    time.Time ``
+}
+
+type albumRepository struct {
+	stormRepository
+}
+
+func NewAlbumRepository() domain.AlbumRepository {
+	r := &albumRepository{}
+	r.init(&_Album{})
+	return r
+}
+
+func (r *albumRepository) Put(a *domain.Album) error {
+	ta := _Album(*a)
+	return Db().Save(&ta)
+}
+
+func (r *albumRepository) Get(id string) (*domain.Album, error) {
+	ta := &_Album{}
+	err := r.getByID(id, ta)
+	if err != nil {
+		return nil, err
+	}
+	a := domain.Album(*ta)
+	return &a, err
+}
+
+func (r *albumRepository) FindByArtist(artistId string) (domain.Albums, error) {
+	var albums []_Album
+	err := r.execute(q.Eq("ArtistID", artistId), &albums)
+	if err != nil {
+		return nil, err
+	}
+	return r.toAlbums(albums)
+}
+
+func (r *albumRepository) GetAll(options domain.QueryOptions) (domain.Albums, error) {
+	var all []_Album
+	err := r.getAll(&all, &options)
+	if err != nil {
+		return nil, err
+	}
+	return r.toAlbums(all)
+}
+
+func (r *albumRepository) toAlbums(all []_Album) (domain.Albums, error) {
+	result := make(domain.Albums, len(all))
+	for i, a := range all {
+		result[i] = domain.Album(a)
+	}
+	return result, nil
+}
+
+func (r *albumRepository) GetAllIds() ([]string, error) {
+	var all []_Album
+	err := r.getAll(&all, &domain.QueryOptions{})
+	if err != nil {
+		return nil, err
+	}
+	result := make([]string, len(all))
+	for i, a := range all {
+		result[i] = domain.Album(a).ID
+	}
+	return result, nil
+}
+
+func (r *albumRepository) PurgeInactive(activeList domain.Albums) ([]string, error) {
+	return r.purgeInactive(activeList)
+}
+
+func (r *albumRepository) GetStarred(options domain.QueryOptions) (domain.Albums, error) {
+	var starred []_Album
+	err := r.execute(q.Eq("Starred", true), &starred, &options)
+	if err != nil {
+		return nil, err
+	}
+	return r.toAlbums(starred)
+}
+
+var _ domain.AlbumRepository = (*albumRepository)(nil)
+var _ = domain.Album(_Album{})

persistence/db_storm/album_repository_test.go

@@ -0,0 +1,67 @@
+package db_storm
+
+import (
+	"github.com/cloudsonic/sonic-server/domain"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("AlbumRepository", func() {
+	var repo domain.AlbumRepository
+
+	BeforeEach(func() {
+		repo = NewAlbumRepository()
+	})
+
+	Describe("GetAll", func() {
+		It("returns all records", func() {
+			Expect(repo.GetAll(domain.QueryOptions{})).To(Equal(testAlbums))
+		})
+
+		It("returns all records sorted", func() {
+			Expect(repo.GetAll(domain.QueryOptions{SortBy: "Name"})).To(Equal(domain.Albums{
+				{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "1"},
+				{ID: "3", Name: "Radioactivity", Artist: "Kraftwerk", ArtistID: "2", Starred: true},
+				{ID: "1", Name: "Sgt Peppers", Artist: "The Beatles", ArtistID: "1"},
+			}))
+		})
+
+		It("returns all records sorted desc", func() {
+			Expect(repo.GetAll(domain.QueryOptions{SortBy: "Name", Desc: true})).To(Equal(domain.Albums{
+				{ID: "1", Name: "Sgt Peppers", Artist: "The Beatles", ArtistID: "1"},
+				{ID: "3", Name: "Radioactivity", Artist: "Kraftwerk", ArtistID: "2", Starred: true},
+				{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "1"},
+			}))
+		})
+
+		It("paginates the result", func() {
+			Expect(repo.GetAll(domain.QueryOptions{Offset: 1, Size: 1})).To(Equal(domain.Albums{
+				{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "1"},
+			}))
+		})
+	})
+
+	Describe("GetAllIds", func() {
+		It("returns all records", func() {
+			Expect(repo.GetAllIds()).To(Equal([]string{"1", "2", "3"}))
+		})
+	})
+
+	Describe("GetStarred", func() {
+		It("returns all starred records", func() {
+			Expect(repo.GetStarred(domain.QueryOptions{})).To(Equal(domain.Albums{
+				{ID: "3", Name: "Radioactivity", Artist: "Kraftwerk", ArtistID: "2", Starred: true},
+			}))
+		})
+	})
+
+	Describe("FindByArtist", func() {
+		It("returns all records from a given ArtistID", func() {
+			Expect(repo.FindByArtist("1")).To(Equal(domain.Albums{
+				{ID: "1", Name: "Sgt Peppers", Artist: "The Beatles", ArtistID: "1"},
+				{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "1"},
+			}))
+		})
+	})
+
+})

persistence/db_storm/artist_repository.go

@@ -0,0 +1,44 @@
+package db_storm
+
+import (
+	"github.com/cloudsonic/sonic-server/domain"
+)
+
+// This is used to isolate Storm's struct tags from the domain, to keep it agnostic of persistence details
+type _Artist struct {
+	ID         string
+	Name       string `storm:"index"`
+	AlbumCount int
+}
+
+type artistRepository struct {
+	stormRepository
+}
+
+func NewArtistRepository() domain.ArtistRepository {
+	r := &artistRepository{}
+	r.init(&_Artist{})
+	return r
+}
+
+func (r *artistRepository) Put(a *domain.Artist) error {
+	ta := _Artist(*a)
+	return Db().Save(&ta)
+}
+
+func (r *artistRepository) Get(id string) (*domain.Artist, error) {
+	ta := &_Artist{}
+	err := r.getByID(id, ta)
+	if err != nil {
+		return nil, err
+	}
+	a := domain.Artist(*ta)
+	return &a, nil
+}
+
+func (r *artistRepository) PurgeInactive(activeList domain.Artists) ([]string, error) {
+	return r.purgeInactive(activeList)
+}
+
+var _ domain.ArtistRepository = (*artistRepository)(nil)
+var _ = domain.Artist(_Artist{})

persistence/db_storm/artist_repository_test.go

@@ -0,0 +1,45 @@
+package db_storm
+
+import (
+	"github.com/cloudsonic/sonic-server/domain"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("ArtistRepository", func() {
+	var repo domain.ArtistRepository
+
+	BeforeEach(func() {
+		repo = NewArtistRepository()
+	})
+
+	It("saves and retrieves data", func() {
+		Expect(repo.Get("1")).To(Equal(&domain.Artist{ID: "1", Name: "Saara Saara"}))
+	})
+
+	It("returns ErrNotFound when the ID does not exist", func() {
+		_, err := repo.Get("999")
+		Expect(err).To(MatchError(domain.ErrNotFound))
+	})
+
+	Describe("PurgeInactive", func() {
+		var data domain.Artists
+
+		BeforeEach(func() {
+			for _, a := range data {
+				repo.Put(&a)
+			}
+		})
+
+		It("purges inactive records", func() {
+			active := domain.Artists{{ID: "1"}, {ID: "3"}}
+			Expect(repo.PurgeInactive(active)).To(Equal([]string{"2"}))
+		})
+
+		It("doesn't delete anything if all is active", func() {
+			active := domain.Artists{{ID: "1"}, {ID: "2"}, {ID: "3"}}
+			Expect(repo.PurgeInactive(active)).To(BeEmpty())
+		})
+	})
+
+})

persistence/db_storm/index_repository.go

@@ -0,0 +1,59 @@
+package db_storm
+
+import (
+	"github.com/cloudsonic/sonic-server/domain"
+)
+
+type _ArtistIndex struct {
+	ID      string
+	Artists domain.ArtistInfos
+}
+
+type artistIndexRepository struct {
+	stormRepository
+}
+
+func NewArtistIndexRepository() domain.ArtistIndexRepository {
+	r := &artistIndexRepository{}
+	r.init(&_ArtistIndex{})
+	return r
+}
+
+func (r *artistIndexRepository) Put(i *domain.ArtistIndex) error {
+	ti := _ArtistIndex(*i)
+	return Db().Save(&ti)
+}
+
+func (r *artistIndexRepository) Get(id string) (*domain.ArtistIndex, error) {
+	ta := &_ArtistIndex{}
+	err := r.getByID(id, ta)
+	if err != nil {
+		return nil, err
+	}
+	a := domain.ArtistIndex(*ta)
+	return &a, err
+}
+
+func (r *artistIndexRepository) GetAll() (domain.ArtistIndexes, error) {
+	var all []_ArtistIndex
+	err := r.getAll(&all, &domain.QueryOptions{})
+	if err != nil {
+		return nil, err
+	}
+	return r.toArtistIndexes(all)
+}
+
+func (r *artistIndexRepository) toArtistIndexes(all []_ArtistIndex) (domain.ArtistIndexes, error) {
+	result := make(domain.ArtistIndexes, len(all))
+	for i, a := range all {
+		result[i] = domain.ArtistIndex(a)
+	}
+	return result, nil
+}
+
+func (r *artistIndexRepository) DeleteAll() error {
+	return Db().Drop(&_ArtistIndex{})
+}
+
+var _ domain.ArtistIndexRepository = (*artistIndexRepository)(nil)
+var _ = domain.ArtistIndex(_ArtistIndex{})

persistence/db_storm/mediafile_repository.go

@@ -0,0 +1,107 @@
+package db_storm
+
+import (
+	"time"
+
+	"github.com/asdine/storm/q"
+	"github.com/cloudsonic/sonic-server/domain"
+)
+
+type _MediaFile struct {
+	ID          string    ``
+	Path        string    ``
+	Title       string    ``
+	Album       string    ``
+	Artist      string    ``
+	ArtistID    string    ``
+	AlbumArtist string    ``
+	AlbumID     string    `storm:"index"`
+	HasCoverArt bool      ``
+	TrackNumber int       ``
+	DiscNumber  int       ``
+	Year        int       ``
+	Size        string    ``
+	Suffix      string    ``
+	Duration    int       ``
+	BitRate     int       ``
+	Genre       string    ``
+	Compilation bool      ``
+	PlayCount   int       ``
+	PlayDate    time.Time ``
+	Rating      int       ``
+	Starred     bool      `storm:"index"`
+	StarredAt   time.Time ``
+	CreatedAt   time.Time ``
+	UpdatedAt   time.Time ``
+}
+
+type mediaFileRepository struct {
+	stormRepository
+}
+
+func NewMediaFileRepository() domain.MediaFileRepository {
+	r := &mediaFileRepository{}
+	r.init(&_MediaFile{})
+	return r
+}
+
+func (r *mediaFileRepository) Put(m *domain.MediaFile) error {
+	tm := _MediaFile(*m)
+	return Db().Save(&tm)
+}
+
+func (r *mediaFileRepository) Get(id string) (*domain.MediaFile, error) {
+	tm := &_MediaFile{}
+	err := r.getByID(id, tm)
+	if err != nil {
+		return nil, err
+	}
+	a := domain.MediaFile(*tm)
+	return &a, nil
+}
+
+func (r *mediaFileRepository) toMediaFiles(all []_MediaFile) (domain.MediaFiles, error) {
+	result := make(domain.MediaFiles, len(all))
+	for i, m := range all {
+		result[i] = domain.MediaFile(m)
+	}
+	return result, nil
+}
+
+func (r *mediaFileRepository) FindByAlbum(albumId string) (domain.MediaFiles, error) {
+	var mfs []_MediaFile
+	err := r.execute(q.Eq("AlbumID", albumId), &mfs)
+	if err != nil {
+		return nil, err
+	}
+	return r.toMediaFiles(mfs)
+}
+
+func (r *mediaFileRepository) GetStarred(options domain.QueryOptions) (domain.MediaFiles, error) {
+	var starred []_MediaFile
+	err := r.execute(q.Eq("Starred", true), &starred, &options)
+	if err != nil {
+		return nil, err
+	}
+	return r.toMediaFiles(starred)
+}
+
+func (r *mediaFileRepository) GetAllIds() ([]string, error) {
+	var all []_MediaFile
+	err := r.getAll(&all, &domain.QueryOptions{})
+	if err != nil {
+		return nil, err
+	}
+	result := make([]string, len(all))
+	for i, m := range all {
+		result[i] = domain.MediaFile(m).ID
+	}
+	return result, nil
+}
+
+func (r *mediaFileRepository) PurgeInactive(activeList domain.MediaFiles) ([]string, error) {
+	return r.purgeInactive(activeList)
+}
+
+var _ domain.MediaFileRepository = (*mediaFileRepository)(nil)
+var _ = domain.MediaFile(_MediaFile{})

persistence/db_storm/property_repository.go

@@ -0,0 +1,42 @@
+package db_storm
+
+import (
+	"github.com/asdine/storm"
+	"github.com/cloudsonic/sonic-server/domain"
+)
+
+const propertyBucket = "Property"
+
+type propertyRepository struct {
+}
+
+func NewPropertyRepository() domain.PropertyRepository {
+	r := &propertyRepository{}
+	return r
+}
+
+func (r *propertyRepository) Put(id string, value string) error {
+	return Db().Set(propertyBucket, id, value)
+}
+
+func (r *propertyRepository) Get(id string) (string, error) {
+	var value string
+	err := Db().Get(propertyBucket, id, &value)
+	if err == storm.ErrNotFound {
+		return value, domain.ErrNotFound
+	}
+	return value, err
+}
+
+func (r *propertyRepository) DefaultGet(id string, defaultValue string) (string, error) {
+	value, err := r.Get(id)
+	if err == domain.ErrNotFound {
+		return defaultValue, nil
+	}
+	if err != nil {
+		return defaultValue, err
+	}
+	return value, nil
+}
+
+var _ domain.PropertyRepository = (*propertyRepository)(nil)

persistence/db_storm/property_repository_test.go

@@ -0,0 +1,30 @@
+package db_storm
+
+import (
+	"github.com/cloudsonic/sonic-server/domain"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("PropertyRepository", func() {
+	var repo domain.PropertyRepository
+
+	BeforeEach(func() {
+		Db().Drop(propertyBucket)
+		repo = NewPropertyRepository()
+	})
+
+	It("saves and retrieves data", func() {
+		Expect(repo.Put("1", "test")).To(BeNil())
+		Expect(repo.Get("1")).To(Equal("test"))
+	})
+
+	It("returns default if data is not found", func() {
+		Expect(repo.DefaultGet("2", "default")).To(Equal("default"))
+	})
+
+	It("returns value if found", func() {
+		Expect(repo.Put("3", "test")).To(BeNil())
+		Expect(repo.DefaultGet("3", "default")).To(Equal("test"))
+	})
+})

persistence/db_storm/storm.go

@@ -0,0 +1,23 @@
+package db_storm
+
+import (
+	"sync"
+
+	"github.com/asdine/storm"
+)
+
+var (
+	_dbInstance *storm.DB
+	once        sync.Once
+)
+
+func Db() *storm.DB {
+	once.Do(func() {
+		instance, err := storm.Open("./storm.db")
+		if err != nil {
+			panic(err)
+		}
+		_dbInstance = instance
+	})
+	return _dbInstance
+}

persistence/db_storm/storm_repository.go

@@ -0,0 +1,127 @@
+package db_storm
+
+import (
+	"reflect"
+
+	"github.com/asdine/storm"
+	"github.com/asdine/storm/index"
+	"github.com/asdine/storm/q"
+	"github.com/cloudsonic/sonic-server/domain"
+)
+
+type stormRepository struct {
+	bucket interface{}
+}
+
+func (r *stormRepository) init(entity interface{}) {
+	r.bucket = entity
+	if err := Db().Init(r.bucket); err != nil {
+		panic(err)
+	}
+	if err := Db().ReIndex(r.bucket); err != nil {
+		panic(err)
+	}
+}
+
+func (r *stormRepository) CountAll() (int64, error) {
+	c, err := Db().Count(r.bucket)
+	return int64(c), err
+}
+
+func (r *stormRepository) Exists(id string) (bool, error) {
+	err := Db().One("ID", id, r.bucket)
+	if err != nil {
+		return false, err
+	}
+	return err != storm.ErrNotFound, nil
+}
+
+func (r *stormRepository) extractID(record interface{}) string {
+	v := reflect.ValueOf(record).Elem()
+	id := v.FieldByName("ID").String()
+	return id
+}
+
+func (r *stormRepository) getByID(id string, ta interface{}) error {
+	err := Db().One("ID", id, ta)
+	if err == storm.ErrNotFound {
+		return domain.ErrNotFound
+	}
+	return nil
+}
+
+func (r *stormRepository) purgeInactive(activeList interface{}) (deleted []string, err error) {
+	reflected := reflect.ValueOf(activeList)
+	totalActive := reflected.Len()
+	activeIDs := make([]string, totalActive)
+	for i := 0; i < totalActive; i++ {
+		item := reflected.Index(i)
+		activeIDs[i] = item.FieldByName("ID").String()
+	}
+
+	query := Db().Select(q.Not(q.In("ID", activeIDs)))
+
+	// Collect IDs that will be deleted
+	err = query.Each(r.bucket, func(record interface{}) error {
+		id := r.extractID(record)
+		deleted = append(deleted, id)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if len(deleted) == 0 {
+		return
+	}
+
+	err = query.Delete(r.bucket)
+	if err != nil {
+		return nil, err
+	}
+	return deleted, nil
+}
+
+func (r *stormRepository) execute(matcher q.Matcher, result interface{}, options ...*domain.QueryOptions) error {
+	query := Db().Select(matcher)
+	if len(options) > 0 {
+		query = addQueryOptions(query, options[0])
+	}
+	err := query.Find(result)
+	if err == storm.ErrNotFound {
+		return nil
+	}
+	return err
+}
+
+func (r *stormRepository) getAll(all interface{}, options *domain.QueryOptions) (err error) {
+	if options.SortBy != "" {
+		err = Db().AllByIndex(options.SortBy, all, stormOptions(options))
+	} else {
+		err = Db().All(all, stormOptions(options))
+	}
+	return
+}
+
+func stormOptions(options *domain.QueryOptions) func(*index.Options) {
+	return func(opts *index.Options) {
+		opts.Reverse = options.Desc
+		opts.Skip = options.Offset
+		if options.Size > 0 {
+			opts.Limit = options.Size
+		}
+	}
+}
+
+func addQueryOptions(q storm.Query, o *domain.QueryOptions) storm.Query {
+	if o.SortBy != "" {
+		q = q.OrderBy(o.SortBy)
+	}
+	if o.Desc {
+		q = q.Reverse()
+	}
+	if o.Size > 0 {
+		q = q.Limit(o.Size)
+	}
+	return q.Skip(o.Offset)
+}

persistence/db_storm/storm_suite_test.go

@@ -0,0 +1,43 @@
+package db_storm
+
+import (
+	"testing"
+
+	"github.com/cloudsonic/sonic-server/domain"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestStormPersistence(t *testing.T) {
+	//log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Storm Persistence Suite")
+}
+
+var testAlbums = domain.Albums{
+	{ID: "1", Name: "Sgt Peppers", Artist: "The Beatles", ArtistID: "1"},
+	{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "1"},
+	{ID: "3", Name: "Radioactivity", Artist: "Kraftwerk", ArtistID: "2", Starred: true},
+}
+var testArtists = domain.Artists{
+	{ID: "1", Name: "Saara Saara"},
+	{ID: "2", Name: "Kraftwerk"},
+	{ID: "3", Name: "The Beatles"},
+}
+
+var _ = Describe("Initialize test DB", func() {
+	BeforeSuite(func() {
+		Db().Drop(&_Album{})
+		albumRepo := NewAlbumRepository()
+		for _, a := range testAlbums {
+			albumRepo.Put(&a)
+		}
+
+		Db().Drop(&_Artist{})
+		artistRepo := NewArtistRepository()
+		for _, a := range testArtists {
+			artistRepo.Put(&a)
+		}
+	})
+
+})

persistence/db_storm/wire_providers.go

@@ -0,0 +1,11 @@
+package db_storm
+
+import "github.com/google/wire"
+
+var Set = wire.NewSet(
+	NewPropertyRepository,
+	NewArtistRepository,
+	NewAlbumRepository,
+	NewMediaFileRepository,
+	NewArtistIndexRepository,
+)