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.

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

Author: pjbgf

memfs/memory.go

@@ -17,32 +17,41 @@ 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{}
+	o := &options{
+		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 +66,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 +172,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 +237,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())
+}