New implementation of NowPlaying

utils/singleton/singleton.go

@@ -0,0 +1,48 @@
+package singleton
+
+import (
+	"reflect"
+	"strings"
+
+	"github.com/navidrome/navidrome/log"
+)
+
+var (
+	instances    = make(map[string]interface{})
+	getOrCreateC = make(chan *entry, 1)
+)
+
+type entry struct {
+	constructor func() interface{}
+	object      interface{}
+	resultC     chan interface{}
+}
+
+// Get returns an existing instance of object. If it is not yet created, calls `constructor`, stores the
+// result for future calls and return it
+func Get(object interface{}, constructor func() interface{}) interface{} {
+	e := &entry{
+		constructor: constructor,
+		object:      object,
+		resultC:     make(chan interface{}),
+	}
+	getOrCreateC <- e
+	return <-e.resultC
+}
+
+func init() {
+	go func() {
+		for {
+			e := <-getOrCreateC
+			name := reflect.TypeOf(e.object).String()
+			name = strings.TrimPrefix(name, "*")
+			v, created := instances[name]
+			if !created {
+				v = e.constructor()
+				log.Trace("Created new singleton", "object", name, "instance", v)
+				instances[name] = v
+			}
+			e.resultC <- v
+		}
+	}()
+}

utils/singleton/singleton_test.go

@@ -0,0 +1,53 @@
+package singleton_test
+
+import (
+	"testing"
+
+	"github.com/navidrome/navidrome/utils/singleton"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestSingleton(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Singleton Suite")
+}
+
+var _ = Describe("Get", func() {
+	type T struct{ val int }
+	var wasCalled bool
+	var instance interface{}
+	constructor := func() interface{} {
+		wasCalled = true
+		return &T{}
+	}
+
+	BeforeEach(func() {
+		instance = singleton.Get(T{}, constructor)
+	})
+
+	It("calls the constructor to create a new instance", func() {
+		Expect(wasCalled).To(BeTrue())
+		Expect(instance).To(BeAssignableToTypeOf(&T{}))
+	})
+
+	It("does not call the constructor the next time", func() {
+		instance.(*T).val = 10
+		wasCalled = false
+
+		newInstance := singleton.Get(T{}, constructor)
+
+		Expect(newInstance.(*T).val).To(Equal(10))
+		Expect(wasCalled).To(BeFalse())
+	})
+
+	It("does not call the constructor even if a pointer is passed as the object", func() {
+		instance.(*T).val = 20
+		wasCalled = false
+
+		newInstance := singleton.Get(&T{}, constructor)
+
+		Expect(newInstance.(*T).val).To(Equal(20))
+		Expect(wasCalled).To(BeFalse())
+	})
+})