memfs: Add support for umask

The umask construct is now supported via new WithUMask(value) option. When
not set it defaults to 0o022, as per generally used within posix systems.

The polyfill had to be changed to add support for Chmod, without that the
new TestUmaskChmod would simply fail to alter filemode of existing files.

Signed-off-by: Paulo Gomes <pjbgf@linux.com>

Author: pjbgf

helper/polyfill/polyfill.go

@@ -15,7 +15,7 @@ type Polyfill struct {
 	c capabilities
 }
 
-type capabilities struct{ tempfile, dir, symlink, chroot bool }
+type capabilities struct{ tempfile, dir, symlink, chroot, chmod bool }
 
 // New creates a new filesystem wrapping up 'fs' the intercepts all the calls
 // made and errors if fs doesn't implement any of the billy interfaces.
@@ -30,6 +30,8 @@ func New(fs billy.Basic) billy.Filesystem {
 	_, h.c.dir = h.Basic.(billy.Dir)
 	_, h.c.symlink = h.Basic.(billy.Symlink)
 	_, h.c.chroot = h.Basic.(billy.Chroot)
+	_, h.c.chmod = h.Basic.(billy.Chmod)
+
 	return h
 }
 
@@ -89,6 +91,14 @@ func (h *Polyfill) Chroot(path string) (billy.Filesystem, error) {
 	return h.Basic.(billy.Chroot).Chroot(path)
 }
 
+func (h *Polyfill) Chmod(path string, mode fs.FileMode) error {
+	if !h.c.chmod {
+		return billy.ErrNotSupported
+	}
+
+	return h.Basic.(billy.Chmod).Chmod(path, mode)
+}
+
 func (h *Polyfill) Root() string {
 	if !h.c.chroot {
 		return string(filepath.Separator)

memfs/memory.go

@@ -8,6 +8,7 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"runtime"
 	"sort"
 	"strings"
 	"syscall"
@@ -17,32 +18,44 @@ import (
 	"github.com/go-git/go-billy/v6/util"
 )
 
-const separator = filepath.Separator
+const (
+	separator       = filepath.Separator
+	defaultUmask    = 0o022
+	defaultDirMode  = 0o777
+	defaultFileMode = 0o666
+)
 
 // Memory a very convenient filesystem based on memory files.
 type Memory struct {
-	s *storage
+	s     *storage
+	umask uint32
 }
 
 // New returns a new Memory filesystem.
 func New(opts ...Option) billy.Filesystem {
 	o := &options{}
+	// Aligns default umask with general Windows behaviour.
+	if runtime.GOOS != "windows" {
+		o.umask = defaultUmask
+	}
+
 	for _, opt := range opts {
 		opt(o)
 	}
 
 	fs := &Memory{
-		s: newStorage(),
+		s:     newStorage(),
+		umask: o.umask,
 	}
-	_, err := fs.s.New("/", 0o755|os.ModeDir, 0)
+	_, err := fs.s.New("/", fs.applyUmask(defaultDirMode)|os.ModeDir, 0)
 	if err != nil {
 		log.Printf("failed to create root dir: %v", err)
 	}
 	return chroot.New(fs, string(separator))
 }
 
 func (fs *Memory) Create(filename string) (billy.File, error) {
-	return fs.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o666)
+	return fs.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, defaultFileMode)
 }
 
 func (fs *Memory) Open(filename string) (billy.File, error) {
@@ -57,7 +70,7 @@ func (fs *Memory) OpenFile(filename string, flag int, perm gofs.FileMode) (billy
 		}
 
 		var err error
-		f, err = fs.s.New(filename, perm, flag)
+		f, err = fs.s.New(filename, fs.applyUmask(perm), flag)
 		if err != nil {
 			return nil, err
 		}
@@ -163,7 +176,7 @@ func (fs *Memory) ReadDir(path string) ([]gofs.DirEntry, error) {
 }
 
 func (fs *Memory) MkdirAll(path string, perm gofs.FileMode) error {
-	_, err := fs.s.New(path, perm|os.ModeDir, 0)
+	_, err := fs.s.New(path, fs.applyUmask(perm)|os.ModeDir, 0)
 	return err
 }
 
@@ -228,6 +241,13 @@ func (fs *Memory) Capabilities() billy.Capability {
 		billy.TruncateCapability
 }
 
+// applyUmask applies the filesystem's umask to a mode by clearing the bits
+// specified in the umask. For example, with umask 0o022, the mode 0o666
+// becomes 0o644 (rw-r--r--).
+func (fs *Memory) applyUmask(mode gofs.FileMode) gofs.FileMode {
+	return mode &^ gofs.FileMode(fs.umask)
+}
+
 func (c *content) Truncate() {
 	c.bytes = make([]byte, 0)
 }

memfs/memory_option.go

@@ -2,4 +2,15 @@ package memfs
 
 type Option func(*options)
 
-type options struct{}
+type options struct {
+	umask uint32
+}
+
+// WithUmask sets the umask for the memfs filesystem. The umask controls the
+// default permissions for newly created files and directories by clearing
+// specified permission bits. If not set, defaults to 0o022.
+func WithUmask(mask uint32) Option {
+	return func(o *options) {
+		o.umask = mask
+	}
+}

memfs/memory_test.go

@@ -403,3 +403,116 @@ func TestThreadSafety(t *testing.T) {
 	require.NoError(t, err)
 	assert.Len(t, fi, files*2)
 }
+
+func TestUmask(t *testing.T) {
+	tests := []struct {
+		name             string
+		umask            *uint32
+		expectedFileMode os.FileMode
+		expectedDirMode  os.FileMode
+	}{
+		{
+			name:             "default umask (0o022)",
+			umask:            nil,
+			expectedFileMode: 0o644,
+			expectedDirMode:  0o755,
+		},
+		{
+			name:             "custom umask (0o077)",
+			umask:            func() *uint32 { u := uint32(0o077); return &u }(),
+			expectedFileMode: 0o600,
+			expectedDirMode:  0o700,
+		},
+		{
+			name:             "zero umask (0o000)",
+			umask:            func() *uint32 { u := uint32(0o000); return &u }(),
+			expectedFileMode: 0o666,
+			expectedDirMode:  0o777,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var fs billy.Filesystem
+			if tt.umask != nil {
+				fs = New(WithUmask(*tt.umask))
+			} else {
+				fs = New()
+			}
+
+			f, err := fs.Create("file.txt")
+			require.NoError(t, err)
+			f.Close()
+
+			fi, err := fs.Stat("file.txt")
+			require.NoError(t, err)
+			assert.Equal(t, tt.expectedFileMode, fi.Mode().Perm())
+
+			err = fs.MkdirAll("testdir", 0o777)
+			require.NoError(t, err)
+
+			fi, err = fs.Stat("testdir")
+			require.NoError(t, err)
+			assert.Equal(t, tt.expectedDirMode, fi.Mode().Perm())
+		})
+	}
+}
+
+func TestUmaskOpenFile(t *testing.T) {
+	fs := New(WithUmask(0o077))
+
+	f, err := fs.OpenFile("test.txt", os.O_CREATE|os.O_RDWR, 0o666)
+	require.NoError(t, err)
+	assert.NoError(t, f.Close())
+
+	fi, err := fs.Stat("test.txt")
+	require.NoError(t, err)
+	assert.Equal(t, os.FileMode(0o600), fi.Mode().Perm())
+
+	// Re-do test without the use of os.O_CREATE.
+	err = util.WriteFile(fs, "test2.txt", []byte("content"), 0o666)
+	require.NoError(t, err)
+
+	fi2, err := fs.Stat("test2.txt")
+	require.NoError(t, err)
+	assert.Equal(t, os.FileMode(0o600), fi2.Mode().Perm())
+
+	f2, err := fs.OpenFile("test2.txt", os.O_RDWR, 0o777)
+	require.NoError(t, err)
+	assert.NoError(t, f2.Close())
+
+	fi2, err = fs.Stat("test2.txt")
+	require.NoError(t, err)
+	// Mode must not be changed by OpenFile without os.O_CREATE.
+	assert.Equal(t, os.FileMode(0o600), fi2.Mode().Perm())
+}
+
+func TestUmaskChmod(t *testing.T) {
+	fs := New()
+
+	f, err := fs.Create("/test.txt")
+	require.NoError(t, err)
+	assert.NoError(t, f.Close())
+
+	fi, err := fs.Stat("/test.txt")
+	require.NoError(t, err)
+	assert.Equal(t, os.FileMode(0o644), fi.Mode().Perm())
+
+	ch, ok := fs.(billy.Chmod)
+	require.True(t, ok, "fs does not implement billy.Chmod")
+
+	err = ch.Chmod("/test.txt", 0o421)
+	require.NoError(t, err)
+
+	fi, err = fs.Stat("/test.txt")
+	require.NoError(t, err)
+	assert.Equal(t, os.FileMode(0o421), fi.Mode().Perm())
+}
+
+func TestUmaskRootDirectory(t *testing.T) {
+	fs := New(WithUmask(0o077))
+
+	fi, err := fs.Stat("/")
+	require.NoError(t, err)
+	assert.Equal(t, os.FileMode(0o700), fi.Mode().Perm())
+}

test/basic_test.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
+	"runtime"
 	"slices"
 	"strings"
 	"testing"
@@ -22,8 +23,8 @@ import (
 func eachBasicFS(t *testing.T, test func(t *testing.T, fs Basic)) {
 	t.Helper()
 
-	for _, fs := range allFS(t.TempDir) {
-		t.Run(fmt.Sprintf("%T", fs), func(t *testing.T) {
+	for i, fs := range allFS(t.TempDir) {
+		t.Run(fmt.Sprintf("%d-%T", i, fs), func(t *testing.T) {
 			test(t, fs)
 		})
 	}
@@ -251,9 +252,14 @@ func TestOpenFileWithModes(t *testing.T) {
 		require.NoError(t, err)
 		require.NoError(t, f.Close())
 
+		want := customMode
+		if runtime.GOOS == "windows" {
+			want = 0o666
+		}
+
 		fi, err := fs.Stat("foo")
 		require.NoError(t, err)
-		assert.Equal(t, customMode, fi.Mode())
+		assert.Equal(t, want, fi.Mode())
 	})
 }
 
@@ -454,11 +460,16 @@ func TestStat(t *testing.T) {
 		err := util.WriteFile(fs, "foo/bar", []byte("foo"), customMode)
 		require.NoError(t, err)
 
+		want := customMode
+		if runtime.GOOS == "windows" {
+			want = 0o666
+		}
+
 		fi, err := fs.Stat("foo/bar")
 		require.NoError(t, err)
 		assert.Equal(t, "bar", fi.Name())
 		assert.Equal(t, int64(3), fi.Size())
-		assert.Equal(t, customMode, fi.Mode())
+		assert.Equal(t, want, fi.Mode())
 		assert.False(t, fi.ModTime().IsZero())
 		assert.False(t, fi.IsDir())
 	})

test/symlink_test.go

@@ -260,6 +260,7 @@ func TestStatLink(t *testing.T) {
 		t.Skip("skipping on Plan 9; symlinks are not supported")
 	}
 
+	want := customMode
 	eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) {
 		t.Helper()
 		err := util.WriteFile(fs, "foo/bar", []byte("foo"), customMode)
@@ -268,11 +269,15 @@ func TestStatLink(t *testing.T) {
 		err = fs.Symlink("bar", "foo/qux")
 		require.NoError(t, err)
 
+		if runtime.GOOS == "windows" {
+			want = 0o777
+		}
+
 		fi, err := fs.Stat("foo/qux")
 		require.NoError(t, err)
 		assert.Equal(t, fi.Name(), "qux")
 		assert.Equal(t, fi.Size(), int64(3))
-		assert.Equal(t, fi.Mode(), customMode)
+		assert.Equal(t, fi.Mode(), want)
 		assert.Equal(t, fi.ModTime().IsZero(), false)
 		assert.Equal(t, fi.IsDir(), false)
 	})