Fs implementations (#329)

* move fs.FS into FileSystem interface definition

Signed-off-by: Avi Deitcher <[email protected]>

* implement fs.ReadDirFS

Signed-off-by: Avi Deitcher <[email protected]>

* implement fs.ReadFileFS

Signed-off-by: Avi Deitcher <[email protected]>

* implement statfs

Signed-off-by: Avi Deitcher <[email protected]>

---------

Signed-off-by: Avi Deitcher <[email protected]>

Author: deitch

examples/iso_info.go

@@ -34,6 +34,11 @@ func fileInfoFor(path string, fs filesystem.FileSystem) error {
 	}
 
 	for _, file := range files {
+		fileInfo, err := file.Info()
+		if err != nil {
+			fmt.Printf("Failed to get info for file %s: %v\n", file.Name(), err)
+			continue
+		}
 		fullPath := filepath.Join(path, file.Name())
 		if file.IsDir() {
 			err = fileInfoFor(fullPath, fs)
@@ -53,7 +58,7 @@ func fileInfoFor(path string, fs filesystem.FileSystem) error {
 			fmt.Printf("Failed to cast to iso9660.File for %s\n", fullPath)
 			continue
 		}
-		fmt.Printf("%s\n Size: %d\n Location: %d\n\n", fullPath, file.Size(), myFile.Location())
+		fmt.Printf("%s\n Size: %d\n Location: %d\n\n", fullPath, fileInfo.Size(), myFile.Location())
 	}
 	return nil
 }

filesystem/compatibility.go

@@ -76,10 +76,10 @@ func (f *fsCompatible) Open(name string) (fs.File, error) {
 		return &fsDirWrapper{name: name, compat: f, stat: &fakeRootDir{}}, nil
 	}
 	dirname := path.Dir(name)
-	if info, err := f.fs.ReadDir(dirname); err == nil {
-		for i := range info {
-			if info[i].Name() == path.Base(name) {
-				stat = info[i]
+	if de, err := f.fs.ReadDir(dirname); err == nil {
+		for i := range de {
+			if de[i].Name() == path.Base(name) {
+				stat, _ = de[i].Info()
 				break
 			}
 		}
@@ -98,15 +98,7 @@ func (f *fsCompatible) Open(name string) (fs.File, error) {
 }
 
 func (f *fsCompatible) ReadDir(name string) ([]fs.DirEntry, error) {
-	entries, err := f.fs.ReadDir(name)
-	if err != nil {
-		return nil, err
-	}
-	direntries := make([]fs.DirEntry, len(entries))
-	for i := range entries {
-		direntries[i] = fs.FileInfoToDirEntry(entries[i])
-	}
-	return direntries, nil
+	return f.fs.ReadDir(name)
 }
 
 // FS converts a diskfs FileSystem to a fs.FS for compatibility with

filesystem/ext4/directoryentry.go

@@ -3,6 +3,7 @@ package ext4
 import (
 	"encoding/binary"
 	"fmt"
+	iofs "io/fs"
 )
 
 // directoryFileType uses different constants than the file type property in the inode
@@ -23,7 +24,9 @@ const (
 	dirFileTypeSymlink   directoryFileType = 0x7
 )
 
-// directoryEntry is a single directory entry
+// directoryEntry is a single directory entry, represents a low-level entry
+// per the data on the actual disk.
+// For higher-level directory entries, see Directory struct or directoryEntryInfo.
 type directoryEntry struct {
 	inode    uint32
 	filename string
@@ -174,3 +177,32 @@ func parseDirEntriesHashed(b []byte, depth uint8, node dxNode, blocksize uint32,
 	}
 	return dirEntries, nil
 }
+
+type directoryEntryInfo struct {
+	*directoryEntry
+	*inode
+}
+
+func (de *directoryEntryInfo) Info() (iofs.FileInfo, error) {
+	return &FileInfo{
+		modTime: de.modifyTime,
+		name:    de.filename,
+		size:    int64(de.size),
+		isDir:   de.directoryEntry.fileType == dirFileTypeDirectory,
+	}, nil
+}
+
+func (de *directoryEntryInfo) Type() iofs.FileMode {
+	if de.directoryEntry.fileType == dirFileTypeDirectory {
+		return iofs.ModeDir
+	}
+	return 0
+}
+
+func (de *directoryEntryInfo) IsDir() bool {
+	return de.directoryEntry.fileType == dirFileTypeDirectory
+}
+
+func (de *directoryEntryInfo) Name() string {
+	return de.filename
+}

filesystem/ext4/ext4.go

@@ -709,7 +709,6 @@ func Read(b backend.Storage, size, start, sectorsize int64) (*FileSystem, error)
 
 // interface guard
 var _ filesystem.FileSystem = (*FileSystem)(nil)
-var _ iofs.FS = (*FileSystem)(nil)
 
 // Do cleaning job for ext4. Note that ext4 does not have side-effects so we do not do anything.
 func (fs *FileSystem) Close() error {
@@ -792,28 +791,26 @@ func (fs *FileSystem) Chown(name string, uid, gid int) error {
 
 // ReadDir return the contents of a given directory in a given filesystem.
 //
-// Returns a slice of os.FileInfo with all of the entries in the directory.
+// Returns a slice of iofs.DirEntry with all of the entries in the directory.
 //
 // Will return an error if the directory does not exist or is a regular file and not a directory
-func (fs *FileSystem) ReadDir(p string) ([]os.FileInfo, error) {
+func (fs *FileSystem) ReadDir(p string) ([]iofs.DirEntry, error) {
 	dir, err := fs.readDirWithMkdir(p, false)
 	if err != nil {
 		return nil, fmt.Errorf("error reading directory %s: %v", p, err)
 	}
 	// once we have made it here, looping is done. We have found the final entry
 	// we need to return all of the file info
 	count := len(dir.entries)
-	ret := make([]os.FileInfo, count)
+	ret := make([]iofs.DirEntry, count)
 	for i, e := range dir.entries {
 		in, err := fs.readInode(e.inode)
 		if err != nil {
 			return nil, fmt.Errorf("could not read inode %d at position %d in directory: %v", e.inode, i, err)
 		}
-		ret[i] = &FileInfo{
-			modTime: in.modifyTime,
-			name:    e.filename,
-			size:    int64(in.size),
-			isDir:   e.fileType == dirFileTypeDirectory,
+		ret[i] = &directoryEntryInfo{
+			inode:          in,
+			directoryEntry: e,
 		}
 	}
 
@@ -898,6 +895,16 @@ func (fs *FileSystem) OpenFile(p string, flag int) (filesystem.File, error) {
 	}, nil
 }
 
+// ReadFile implements ReadFileFS to read an entire file into memory
+func (fs *FileSystem) ReadFile(name string) ([]byte, error) {
+	f, err := fs.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	return io.ReadAll(f)
+}
+
 // Label read the volume label
 func (fs *FileSystem) Label() string {
 	if fs.superblock == nil {

filesystem/fat32/directoryentry.go

@@ -3,6 +3,7 @@ package fat32
 import (
 	"encoding/binary"
 	"fmt"
+	iofs "io/fs"
 	"regexp"
 	"strings"
 	"time"
@@ -47,6 +48,34 @@ type directoryEntry struct {
 	isNew              bool
 }
 
+func (de *directoryEntry) Info() (iofs.FileInfo, error) {
+	return FileInfo{
+		modTime:   de.modifyTime,
+		name:      de.filenameLong,
+		shortName: shortNameFromDirEntry(de),
+		size:      int64(de.fileSize),
+		isDir:     de.isSubdirectory,
+	}, nil
+}
+
+func (de *directoryEntry) IsDir() bool {
+	return de.isSubdirectory
+}
+
+func (de *directoryEntry) Type() iofs.FileMode {
+	if de.isSubdirectory {
+		return iofs.ModeDir
+	}
+	return 0
+}
+
+func (de *directoryEntry) Name() string {
+	if de.filenameLong != "" {
+		return de.filenameLong
+	}
+	return shortNameFromDirEntry(de)
+}
+
 func (de *directoryEntry) toBytes() ([]byte, error) {
 	b := make([]byte, 0, bytesPerSlot)
 

filesystem/fat32/fat32.go

@@ -3,6 +3,7 @@ package fat32
 import (
 	"errors"
 	"fmt"
+	"io"
 	iofs "io/fs"
 	"os"
 	"path"
@@ -509,7 +510,6 @@ func (fs *FileSystem) writeFat() error {
 
 // interface guard
 var _ filesystem.FileSystem = (*FileSystem)(nil)
-var _ iofs.FS = (*FileSystem)(nil)
 
 // Do cleaning job for fat32. Note that fat32 does not have side-effects so we do not do anything.
 func (fs *FileSystem) Close() error {
@@ -598,29 +598,23 @@ func (fs *FileSystem) Chown(_ string, _, _ int) error {
 
 // ReadDir return the contents of a given directory in a given filesystem.
 //
-// Returns a slice of os.FileInfo with all of the entries in the directory.
+// Returns a slice of iofs.DirEntry with all of the entries in the directory.
 //
 // Will return an error if the directory does not exist or is a regular file and not a directory
-func (fs *FileSystem) ReadDir(p string) ([]os.FileInfo, error) {
+func (fs *FileSystem) ReadDir(p string) ([]iofs.DirEntry, error) {
 	_, entries, err := fs.readDirWithMkdir(p, false)
 	if err != nil {
 		return nil, fmt.Errorf("error reading directory %s: %w", p, err)
 	}
 	// once we have made it here, looping is done. We have found the final entry
 	// we need to return all of the file info
 	//nolint:prealloc // because the following loop may omit some entry
-	var ret []os.FileInfo
+	var ret []iofs.DirEntry
 	for _, e := range entries {
 		if e.isVolumeLabel {
 			continue
 		}
-		ret = append(ret, FileInfo{
-			modTime:   e.modifyTime,
-			name:      e.filenameLong,
-			shortName: shortNameFromDirEntry(e),
-			size:      int64(e.fileSize),
-			isDir:     e.isSubdirectory,
-		})
+		ret = append(ret, e)
 	}
 	return ret, nil
 }
@@ -713,6 +707,16 @@ func (fs *FileSystem) OpenFile(p string, flag int) (filesystem.File, error) {
 	}, nil
 }
 
+// ReadFile implements ReadFileFS to read an entire file into memory
+func (fs *FileSystem) ReadFile(name string) ([]byte, error) {
+	f, err := fs.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	return io.ReadAll(f)
+}
+
 // removes the named file or (empty) directory.
 func (fs *FileSystem) Remove(pathname string) error {
 	// get the path
@@ -837,6 +841,30 @@ func (fs *FileSystem) Rename(oldpath, newpath string) error {
 	return nil
 }
 
+// Stat returns a FileInfo describing the file.
+func (fs *FileSystem) Stat(name string) (iofs.FileInfo, error) {
+	dir := path.Dir(name)
+	basename := path.Base(name)
+	des, err := fs.ReadDir(dir)
+	if err != nil {
+		return nil, fmt.Errorf("could not read directory %s: %v", dir, err)
+	}
+	// handle the root case
+	if dir == basename && (basename == "/" || basename == ".") {
+		rootDir, _, err := fs.readDirWithMkdir("/", false)
+		if err != nil {
+			return nil, fmt.Errorf("could not read root directory: %v", err)
+		}
+		return rootDir.Info()
+	}
+	for _, de := range des {
+		if de.Name() == basename {
+			return de.Info()
+		}
+	}
+	return nil, &iofs.PathError{Op: "stat", Path: name, Err: fmt.Errorf("file %s not found in directory %s", basename, dir)}
+}
+
 // Label get the label of the filesystem from the secial file in the root directory.
 // The label stored in the boot sector is ignored to mimic Windows behavior which
 // only stores and reads the label from the special file in the root directory.

filesystem/fat32/fat32_test.go

@@ -367,9 +367,14 @@ func TestFat32SourceDateEpoch(t *testing.T) {
 	expected := time.Unix(epochInt, 0)
 
 	for _, entry := range entries {
+		info, err := entry.Info()
+		if err != nil {
+			t.Errorf("getting info for %s failed: %v", entry.Name(), err)
+			continue
+		}
 		if entry.Name() == "test.txt" || entry.Name() == "testdir" {
-			if entry.ModTime().Unix() != expected.Unix() {
-				t.Errorf("%s: timestamp mismatch, got %v, expected %v", entry.Name(), entry.ModTime().Unix(), expected.Unix())
+			if info.ModTime().Unix() != expected.Unix() {
+				t.Errorf("%s: timestamp mismatch, got %v, expected %v", entry.Name(), info.ModTime().Unix(), expected.Unix())
 			}
 		}
 	}
@@ -687,10 +692,20 @@ func TestFat32ReadDir(t *testing.T) {
 				t.Errorf("readDir(%s): Unexpected nil output", tt.path)
 			case len(output) != tt.count:
 				t.Errorf("readDir(%s): output gave %d entries instead of expected %d", tt.path, len(output), tt.count)
-			case len(output) > 0 && output[0].IsDir() != tt.isDir:
-				t.Errorf("readDir(%s): output gave directory %t expected %t", tt.path, output[0].IsDir(), tt.isDir)
-			case len(output) > 0 && output[0].Name() != tt.name:
-				t.Errorf("readDir(%s): output gave name %s expected %s", tt.path, output[0].Name(), tt.name)
+			case len(output) > 0:
+				if output[0].IsDir() != tt.isDir {
+					t.Errorf("readDir(%s): output gave directory %t expected %t", tt.path, output[0].IsDir(), tt.isDir)
+				}
+				if output[0].Name() != tt.name {
+					t.Errorf("readDir(%s): output gave name %s expected %s", tt.path, output[0].Name(), tt.name)
+				}
+				fi, err := output[0].Info()
+				if err != nil {
+					t.Fatalf("readDir(%s): Info() returned unexpected error: %v", tt.path, err)
+				}
+				if fi.Name() != tt.name {
+					t.Errorf("readDir(%s): Info() returned name %s expected %s", tt.path, fi.Name(), tt.name)
+				}
 			}
 		}
 	}

filesystem/filesystem.go

@@ -17,6 +17,10 @@ var (
 
 // FileSystem is a reference to a single filesystem on a disk
 type FileSystem interface {
+	fs.FS
+	fs.ReadDirFS
+	fs.ReadFileFS
+	fs.StatFS
 	// Type return the type of filesystem
 	Type() Type
 	// Mkdir make a directory
@@ -36,8 +40,6 @@ type FileSystem interface {
 	Chown(name string, uid, gid int) error
 	// Chtimes changes the file creation, access and modification times.
 	Chtimes(pathname string, ctime, atime, mtime time.Time) error
-	// ReadDir read the contents of a directory
-	ReadDir(pathname string) ([]os.FileInfo, error)
 	// Open open a handle to read a file, implements fs.FS
 	Open(pathname string) (fs.File, error)
 	// OpenFile open a handle to read or write to a file

filesystem/iso9660/directoryentry.go

@@ -514,6 +514,16 @@ func (de *directoryEntry) Sys() interface{} {
 	return nil
 }
 
+// Info returns the FileInfo structure, which directoryEntry already implements
+func (de *directoryEntry) Info() (os.FileInfo, error) {
+	return de, nil
+}
+
+// Type returns the type of the directory entry
+func (de *directoryEntry) Type() os.FileMode {
+	return de.Mode()
+}
+
 // utilities
 
 func bytesToTime(b []byte) time.Time {