Make persistence provider pluggable at runtime

conf/configuration.go

@@ -24,8 +24,9 @@ type sonic struct {
 	PlsIgnoredPatterns  string `default:"^iCloud;\\~"`
 
 	// DevFlags
-	DevDisableAuthentication bool `default:"false"`
+	DevDisableAuthentication bool   `default:"false"`
-	DevDisableFileCheck      bool `default:"false"`
+	DevDisableFileCheck      bool   `default:"false"`
+	DevPersistenceProvider   string `default:"ledisdb"`
 }
 
 var Sonic *sonic

main.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/cloudsonic/sonic-server/conf"
+	"github.com/cloudsonic/sonic-server/persistence"
 )
 
 func main() {
@@ -11,7 +12,9 @@ func main() {
 
 	fmt.Printf("\nCloudSonic Server v%s\n\n", "0.2")
 
-	a := createApp(conf.Sonic.MusicFolder)
+	provider := persistence.ProviderIdentifier(conf.Sonic.DevPersistenceProvider)
-	a.MountRouter("/rest/", initRouter())
+
+	a := CreateApp(conf.Sonic.MusicFolder, provider)
+	a.MountRouter("/rest/", CreateSubsonicAPIRouter(provider))
 	a.Run(":" + conf.Sonic.Port)
 }

persistence/db_ledis/wire_providers.go

@@ -15,4 +15,5 @@ var Set = wire.NewSet(
 	NewCheckSumRepository,
 	NewNowPlayingRepository,
 	persistence.NewMediaFolderRepository,
+	wire.Value(persistence.ProviderIdentifier("levisdb")),
 )

persistence/db_storm/wire_providers.go

@@ -15,4 +15,5 @@ var Set = wire.NewSet(
 	NewCheckSumRepository,
 	persistence.NewNowPlayingRepository,
 	persistence.NewMediaFolderRepository,
+	wire.Value(persistence.ProviderIdentifier("storm")),
 )

persistence/persistence.go

@@ -0,0 +1,3 @@
+package persistence
+
+type ProviderIdentifier string

wire_gen.go

@@ -7,6 +7,7 @@ package main
 
 import (
 	"github.com/cloudsonic/sonic-server/api"
+	"github.com/cloudsonic/sonic-server/domain"
 	"github.com/cloudsonic/sonic-server/engine"
 	"github.com/cloudsonic/sonic-server/itunesbridge"
 	"github.com/cloudsonic/sonic-server/persistence"
@@ -20,15 +21,16 @@ import (
 
 // Injectors from wire_injectors.go:
 
-func createApp(musicFolder string) *App {
+func CreateApp(musicFolder string, p persistence.ProviderIdentifier) *App {
-	checkSumRepository := db_storm.NewCheckSumRepository()
+	provider := createPersistenceProvider(p)
+	checkSumRepository := provider.CheckSumRepository
 	itunesScanner := scanner.NewItunesScanner(checkSumRepository)
-	mediaFileRepository := db_storm.NewMediaFileRepository()
+	mediaFileRepository := provider.MediaFileRepository
-	albumRepository := db_storm.NewAlbumRepository()
+	albumRepository := provider.AlbumRepository
-	artistRepository := db_storm.NewArtistRepository()
+	artistRepository := provider.ArtistRepository
-	artistIndexRepository := db_storm.NewArtistIndexRepository()
+	artistIndexRepository := provider.ArtistIndexRepository
-	playlistRepository := db_storm.NewPlaylistRepository()
+	playlistRepository := provider.PlaylistRepository
-	propertyRepository := db_storm.NewPropertyRepository()
+	propertyRepository := provider.PropertyRepository
 	db := newDB()
 	search := engine.NewSearch(artistRepository, albumRepository, mediaFileRepository, db)
 	importer := scanner.NewImporter(musicFolder, itunesScanner, mediaFileRepository, albumRepository, artistRepository, artistIndexRepository, playlistRepository, propertyRepository, search)
@@ -36,19 +38,20 @@ func createApp(musicFolder string) *App {
 	return app
 }
 
-func initRouter() *api.Router {
+func CreateSubsonicAPIRouter(p persistence.ProviderIdentifier) *api.Router {
-	propertyRepository := db_storm.NewPropertyRepository()
+	provider := createPersistenceProvider(p)
-	mediaFolderRepository := persistence.NewMediaFolderRepository()
+	propertyRepository := provider.PropertyRepository
-	artistIndexRepository := db_storm.NewArtistIndexRepository()
+	mediaFolderRepository := provider.MediaFolderRepository
-	artistRepository := db_storm.NewArtistRepository()
+	artistIndexRepository := provider.ArtistIndexRepository
-	albumRepository := db_storm.NewAlbumRepository()
+	artistRepository := provider.ArtistRepository
-	mediaFileRepository := db_storm.NewMediaFileRepository()
+	albumRepository := provider.AlbumRepository
+	mediaFileRepository := provider.MediaFileRepository
 	browser := engine.NewBrowser(propertyRepository, mediaFolderRepository, artistIndexRepository, artistRepository, albumRepository, mediaFileRepository)
 	cover := engine.NewCover(mediaFileRepository, albumRepository)
-	nowPlayingRepository := persistence.NewNowPlayingRepository()
+	nowPlayingRepository := provider.NowPlayingRepository
 	listGenerator := engine.NewListGenerator(albumRepository, mediaFileRepository, nowPlayingRepository)
 	itunesControl := itunesbridge.NewItunesControl()
-	playlistRepository := db_storm.NewPlaylistRepository()
+	playlistRepository := provider.PlaylistRepository
 	playlists := engine.NewPlaylists(itunesControl, playlistRepository, mediaFileRepository)
 	ratings := engine.NewRatings(itunesControl, mediaFileRepository, albumRepository, artistRepository)
 	scrobbler := engine.NewScrobbler(itunesControl, mediaFileRepository, nowPlayingRepository)
@@ -58,9 +61,81 @@ func initRouter() *api.Router {
 	return router
 }
 
+func createLedisDBProvider() *Provider {
+	albumRepository := db_ledis.NewAlbumRepository()
+	artistRepository := db_ledis.NewArtistRepository()
+	checkSumRepository := db_ledis.NewCheckSumRepository()
+	artistIndexRepository := db_ledis.NewArtistIndexRepository()
+	mediaFileRepository := db_ledis.NewMediaFileRepository()
+	mediaFolderRepository := persistence.NewMediaFolderRepository()
+	nowPlayingRepository := db_ledis.NewNowPlayingRepository()
+	playlistRepository := db_ledis.NewPlaylistRepository()
+	propertyRepository := db_ledis.NewPropertyRepository()
+	provider := &Provider{
+		AlbumRepository:       albumRepository,
+		ArtistRepository:      artistRepository,
+		CheckSumRepository:    checkSumRepository,
+		ArtistIndexRepository: artistIndexRepository,
+		MediaFileRepository:   mediaFileRepository,
+		MediaFolderRepository: mediaFolderRepository,
+		NowPlayingRepository:  nowPlayingRepository,
+		PlaylistRepository:    playlistRepository,
+		PropertyRepository:    propertyRepository,
+	}
+	return provider
+}
+
+func createStormProvider() *Provider {
+	albumRepository := db_storm.NewAlbumRepository()
+	artistRepository := db_storm.NewArtistRepository()
+	checkSumRepository := db_storm.NewCheckSumRepository()
+	artistIndexRepository := db_storm.NewArtistIndexRepository()
+	mediaFileRepository := db_storm.NewMediaFileRepository()
+	mediaFolderRepository := persistence.NewMediaFolderRepository()
+	nowPlayingRepository := persistence.NewNowPlayingRepository()
+	playlistRepository := db_storm.NewPlaylistRepository()
+	propertyRepository := db_storm.NewPropertyRepository()
+	provider := &Provider{
+		AlbumRepository:       albumRepository,
+		ArtistRepository:      artistRepository,
+		CheckSumRepository:    checkSumRepository,
+		ArtistIndexRepository: artistIndexRepository,
+		MediaFileRepository:   mediaFileRepository,
+		MediaFolderRepository: mediaFolderRepository,
+		NowPlayingRepository:  nowPlayingRepository,
+		PlaylistRepository:    playlistRepository,
+		PropertyRepository:    propertyRepository,
+	}
+	return provider
+}
+
 // wire_injectors.go:
 
-var allProviders = wire.NewSet(itunesbridge.NewItunesControl, db_storm.Set, engine.Set, scanner.Set, newDB, api.NewRouter)
+type Provider struct {
+	AlbumRepository       domain.AlbumRepository
+	ArtistRepository      domain.ArtistRepository
+	CheckSumRepository    scanner.CheckSumRepository
+	ArtistIndexRepository domain.ArtistIndexRepository
+	MediaFileRepository   domain.MediaFileRepository
+	MediaFolderRepository domain.MediaFolderRepository
+	NowPlayingRepository  domain.NowPlayingRepository
+	PlaylistRepository    domain.PlaylistRepository
+	PropertyRepository    domain.PropertyRepository
+}
+
+var allProviders = wire.NewSet(itunesbridge.NewItunesControl, engine.Set, scanner.Set, newDB, api.NewRouter, wire.FieldsOf(new(*Provider), "AlbumRepository", "ArtistRepository", "CheckSumRepository",
+	"ArtistIndexRepository", "MediaFileRepository", "MediaFolderRepository", "NowPlayingRepository",
+	"PlaylistRepository", "PropertyRepository"), createPersistenceProvider,
+)
+
+func createPersistenceProvider(provider persistence.ProviderIdentifier) *Provider {
+	switch provider {
+	case "storm":
+		return createStormProvider()
+	default:
+		return createLedisDBProvider()
+	}
+}
 
 func newDB() gomate.DB {
 	return ledis.NewEmbeddedDB(db_ledis.Db())

wire_injectors.go

@@ -4,8 +4,10 @@ package main
 
 import (
 	"github.com/cloudsonic/sonic-server/api"
+	"github.com/cloudsonic/sonic-server/domain"
 	"github.com/cloudsonic/sonic-server/engine"
 	"github.com/cloudsonic/sonic-server/itunesbridge"
+	"github.com/cloudsonic/sonic-server/persistence"
 	"github.com/cloudsonic/sonic-server/persistence/db_ledis"
 	"github.com/cloudsonic/sonic-server/persistence/db_storm"
 	"github.com/cloudsonic/sonic-server/scanner"
@@ -14,27 +16,64 @@ import (
 	"github.com/google/wire"
 )
 
+type Provider struct {
+	AlbumRepository       domain.AlbumRepository
+	ArtistRepository      domain.ArtistRepository
+	CheckSumRepository    scanner.CheckSumRepository
+	ArtistIndexRepository domain.ArtistIndexRepository
+	MediaFileRepository   domain.MediaFileRepository
+	MediaFolderRepository domain.MediaFolderRepository
+	NowPlayingRepository  domain.NowPlayingRepository
+	PlaylistRepository    domain.PlaylistRepository
+	PropertyRepository    domain.PropertyRepository
+}
+
 var allProviders = wire.NewSet(
 	itunesbridge.NewItunesControl,
-	//db_ledis.Set,
-	db_storm.Set,
 	engine.Set,
 	scanner.Set,
 	newDB,
 	api.NewRouter,
+	wire.FieldsOf(new(*Provider), "AlbumRepository", "ArtistRepository", "CheckSumRepository",
+		"ArtistIndexRepository", "MediaFileRepository", "MediaFolderRepository", "NowPlayingRepository",
+		"PlaylistRepository", "PropertyRepository"),
+	createPersistenceProvider,
 )
 
-func createApp(musicFolder string) *App {
+func CreateApp(musicFolder string, p persistence.ProviderIdentifier) *App {
 	panic(wire.Build(
 		NewApp,
 		allProviders,
 	))
 }
 
-func initRouter() *api.Router {
+func CreateSubsonicAPIRouter(p persistence.ProviderIdentifier) *api.Router {
 	panic(wire.Build(allProviders))
 }
 
+func createPersistenceProvider(provider persistence.ProviderIdentifier) *Provider {
+	switch provider {
+	case "storm":
+		return createStormProvider()
+	default:
+		return createLedisDBProvider()
+	}
+}
+
+func createLedisDBProvider() *Provider {
+	panic(wire.Build(
+		db_ledis.Set,
+		wire.Struct(new(Provider), "*"),
+	))
+}
+
+func createStormProvider() *Provider {
+	panic(wire.Build(
+		db_storm.Set,
+		wire.Struct(new(Provider), "*"),
+	))
+}
+
 func newDB() gomate.DB {
 	return ledis.NewEmbeddedDB(db_ledis.Db())
 }