Skip to content

🎧 Your Personal Streaming Service

fix(conf): make Dir a plain value type to prevent sync.Once corruption (#5543)

Deluan Quintãofc9cdf39c809
diff --git a/conf/dir.go b/conf/dir.go
index abbe72b77..f7a14b933 100644
--- a/conf/dir.go
+++ b/conf/dir.go
@@ -1,20 +1,20 @@
package conf
import (
+ "cmp"
"fmt"
"os"
- "sync"
)
-// Dir wraps a directory path and lazily creates the directory on first use.
-// The directory is created at most once; if creation fails, the error is
-// permanently cached (sync.Once semantics). Dir is not safe for mutation
-// after Path() has been called.
+// Dir wraps a directory path and creates the directory on demand. Dir is a
+// plain value type — safe to copy, compare, and print via reflection-based
+// formatters (pretty.Sprintf("%# v", ...)) without any concurrency hazards.
+// Directory creation is delegated to os.MkdirAll on every Path() call;
+// MkdirAll is idempotent, so repeated calls cost one stat syscall when the
+// directory already exists.
type Dir struct {
path string
perm os.FileMode
- once sync.Once
- err error
}
// NewDir creates a new Dir with the given path and default permissions (os.ModePerm).
@@ -23,31 +23,32 @@ func NewDir(path string) Dir {
}
// NewDirWithPerm creates a new Dir with the given path and permissions.
+// A perm of 0 is treated as "default" and resolves to os.ModePerm at
+// directory-creation time; pass an explicit non-zero mode to constrain the
+// permissions.
func NewDirWithPerm(path string, perm os.FileMode) Dir {
return Dir{path: path, perm: perm}
}
// String returns the raw path without creating the directory. Satisfies fmt.Stringer.
-func (d *Dir) String() string {
+func (d Dir) String() string {
return d.path
}
-// Path creates the directory on first call (via sync.Once) and returns the path.
-func (d *Dir) Path() (string, error) {
- d.once.Do(func() {
- if d.path == "" {
- return
- }
- d.err = os.MkdirAll(d.path, d.perm)
- if d.err != nil {
- d.err = fmt.Errorf("creating directory %q: %w", d.path, d.err)
- }
- })
- return d.path, d.err
+// Path ensures the directory exists and returns its path. Safe to call
+// repeatedly; an empty path is returned as-is with no error.
+func (d Dir) Path() (string, error) {
+ if d.path == "" {
+ return "", nil
+ }
+ if err := os.MkdirAll(d.path, cmp.Or(d.perm, os.ModePerm)); err != nil {
+ return d.path, fmt.Errorf("creating directory %q: %w", d.path, err)
+ }
+ return d.path, nil
}
// MustPath calls Path() and calls logFatal on error.
-func (d *Dir) MustPath() string {
+func (d Dir) MustPath() string {
path, err := d.Path()
if err != nil {
logFatal("creating directory:", err)
@@ -57,12 +58,12 @@ func (d *Dir) MustPath() string {
// GoString implements fmt.GoStringer so that %#v (used by pretty.Sprintf)
// prints the path string instead of the internal struct fields.
-func (d Dir) GoString() string { //nolint:govet // uses a value receiver so Dir values satisfy GoStringer
+func (d Dir) GoString() string {
return fmt.Sprintf("%q", d.path)
}
// MarshalText returns the raw path bytes. No side effects.
-func (d *Dir) MarshalText() ([]byte, error) {
+func (d Dir) MarshalText() ([]byte, error) {
return []byte(d.path), nil
}
diff --git a/conf/dir_test.go b/conf/dir_test.go
index 2dd4250bc..79db379d2 100644
--- a/conf/dir_test.go
+++ b/conf/dir_test.go
@@ -2,7 +2,9 @@ package conf_test
import (
"os"
+ "sync"
+ "github.com/kr/pretty"
"github.com/navidrome/navidrome/conf"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
@@ -35,9 +37,9 @@ var _ = Describe("Dir", func() {
Expect(target).To(BeADirectory())
})
- It("returns the same result on subsequent calls (sync.Once)", func() {
+ It("is idempotent on subsequent calls", func() {
dir := GinkgoT().TempDir()
- target := dir + "/once"
+ target := dir + "/idempotent"
d := conf.NewDir(target)
path1, err1 := d.Path()
@@ -45,6 +47,7 @@ var _ = Describe("Dir", func() {
Expect(err1).ToNot(HaveOccurred())
Expect(err2).ToNot(HaveOccurred())
Expect(path1).To(Equal(path2))
+ Expect(target).To(BeADirectory())
})
It("returns an error when directory cannot be created", func() {
@@ -124,4 +127,38 @@ var _ = Describe("Dir", func() {
Expect(d2.String()).To(Equal(d1.String()))
})
})
+
+ Describe("GoString", func() {
+ // Regression: pretty.Sprintf("%# v", ...) is used by the
+ // configuration dump. It must render Dir as a quoted path via
+ // GoString, not dump the internal struct fields.
+ It("renders Dir as a quoted path under pretty.Sprintf", func() {
+ type host struct {
+ DataFolder conf.Dir
+ }
+ h := host{DataFolder: conf.NewDir("./data")}
+ out := pretty.Sprintf("%# v", h)
+ Expect(out).To(ContainSubstring(`DataFolder: "./data"`))
+ Expect(out).ToNot(ContainSubstring("perm:"))
+ Expect(out).ToNot(ContainSubstring("path:"))
+ })
+
+ It("is safe to copy and use concurrently", func() {
+ // Regression for the Windows "sync: unlock of unlocked mutex"
+ // crash that was caused by copying a Dir embedding sync.Once.
+ // Dir is a plain value type now, but keep the concurrent stress
+ // test to lock in the property.
+ dir := GinkgoT().TempDir()
+ d := conf.NewDir(dir + "/race")
+ var wg sync.WaitGroup
+ for range 10 {
+ wg.Go(func() {
+ copy1 := d
+ _ = pretty.Sprintf("%# v", copy1)
+ _, _ = copy1.Path()
+ })
+ }
+ wg.Wait()
+ })
+ })
})