Merge pull request #179 from go-git/memfm

memfs: Add support for umask

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,126 @@ 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()
+
+			if runtime.GOOS == "windows" && tt.umask == nil {
+				tt.expectedFileMode |= 0o022
+				tt.expectedDirMode |= 0o022
+			}
+
+			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())
+
+	want := 0o644
+	if runtime.GOOS == "windows" {
+		want |= 0o022
+	}
+
+	fi, err := fs.Stat("/test.txt")
+	require.NoError(t, err)
+	assert.Equal(t, os.FileMode(want), 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,13 +269,17 @@ func TestStatLink(t *testing.T) {
 		err = fs.Symlink("bar", "foo/qux")
 		require.NoError(t, err)
 
+		if runtime.GOOS == "windows" {
+			want |= 0o022
+		}
+
 		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.ModTime().IsZero(), false)
-		assert.Equal(t, fi.IsDir(), false)
+		assert.Equal(t, "qux", fi.Name())
+		assert.Equal(t, int64(3), fi.Size())
+		assert.Equal(t, want, fi.Mode())
+		assert.Equal(t, false, fi.ModTime().IsZero())
+		assert.Equal(t, false, fi.IsDir())
 	})
 }