squashfs: factor read only OpenFile into Open method on directory entry

filesystem/squashfs/const_internal_test.go

@@ -220,14 +220,14 @@ func testGetFilesystemRoot() []*directoryEntry {
 	// data taken from reading the bytes of the file SquashfsUncompressedfile
 	modTime := time.Unix(0x5c20d8d7, 0)
 	return []*directoryEntry{
-		{true, "foo", 9949, modTime, 0o755, nil, 0, 0, map[string]string{}},
-		{true, "zero", 32, modTime, 0o755, nil, 0, 0, map[string]string{}},
-		{true, "random", 32, modTime, 0o755, nil, 0, 0, map[string]string{}},
-		{false, "emptylink", 0, modTime, 0o777, nil, 0, 0, map[string]string{}},
-		{false, "goodlink", 0, modTime, 0o777, nil, 0, 0, map[string]string{}},
-		{false, "hardlink", 7, modTime, 0o644, nil, 1, 2, map[string]string{}},
-		{false, "README.md", 7, modTime, 0o644, nil, 1, 2, map[string]string{}},
-		{false, "attrfile", 5, modTime, 0o644, nil, 0, 0, map[string]string{"abc": "def", "myattr": "hello"}},
+		{isSubdirectory: true, name: "foo", size: 9949, modTime: modTime, mode: 0o755},
+		{isSubdirectory: true, name: "zero", size: 32, modTime: modTime, mode: 0o755},
+		{isSubdirectory: true, name: "random", size: 32, modTime: modTime, mode: 0o755},
+		{isSubdirectory: false, name: "emptylink", size: 0, modTime: modTime, mode: 0o777},
+		{isSubdirectory: false, name: "goodlink", size: 0, modTime: modTime, mode: 0o777},
+		{isSubdirectory: false, name: "hardlink", size: 7, modTime: modTime, mode: 0o644, uid: 1, gid: 2},
+		{isSubdirectory: false, name: "README.md", size: 7, modTime: modTime, mode: 0o644, uid: 1, gid: 2},
+		{isSubdirectory: false, name: "attrfile", size: 5, modTime: modTime, mode: 0o644, xattrs: map[string]string{"abc": "def", "myattr": "hello"}},
 	}
 }
 

filesystem/squashfs/directoryentry.go

@@ -5,6 +5,8 @@ import (
 	"io/fs"
 	"os"
 	"time"
+
+	"github.com/diskfs/go-diskfs/filesystem"
 )
 
 // FileStat is the extended data underlying a single file, similar to https://golang.org/pkg/syscall/#Stat_t
@@ -21,7 +23,7 @@ type FileStat = *directoryEntry
 //	IsDir() bool        // abbreviation for Mode().IsDir()
 //	Sys() interface{}   // underlying data source (can return nil)
 type directoryEntry struct {
-	isSubdirectory bool
+	fs             *FileSystem // the FileSystem this entry is part of
 	name           string
 	size           int64
 	modTime        time.Time
@@ -30,6 +32,7 @@ type directoryEntry struct {
 	uid            uint32
 	gid            uint32
 	xattrs         map[string]string
+	isSubdirectory bool
 }
 
 func (d *directoryEntry) equal(o *directoryEntry) bool {
@@ -158,3 +161,39 @@ func (d *directoryEntry) Readlink() (string, error) {
 	}
 	return target, nil
 }
+
+// Open returns an filesystem.File from which you can read the
+// contents of a file.
+//
+// Calling this on anything but a file will return an error.
+//
+// Calling this Open method is more efficient than calling
+// FileSystem.OpenFile as it doesn't have to find the file by
+// traversing the directory entries first.
+func (d *directoryEntry) Open() (filesystem.File, error) {
+	// get the inode data for this file
+	// now open the file
+	// get the inode for the file
+	var eFile *extendedFile
+	in := d.inode
+	iType := in.inodeType()
+	body := in.getBody()
+	//nolint:exhaustive // all other cases fall under default
+	switch iType {
+	case inodeBasicFile:
+		extFile := body.(*basicFile).toExtended()
+		eFile = &extFile
+	case inodeExtendedFile:
+		eFile, _ = body.(*extendedFile)
+	default:
+		return nil, fmt.Errorf("inode is of type %d, neither basic nor extended file", iType)
+	}
+
+	return &File{
+		extendedFile: eFile,
+		isReadWrite:  false,
+		isAppend:     false,
+		offset:       0,
+		filesystem:   d.fs,
+	}, nil
+}

filesystem/squashfs/squashfs.go

@@ -307,30 +307,9 @@ func (fs *FileSystem) OpenFile(p string, flag int) (filesystem.File, error) {
 		if targetEntry == nil {
 			return nil, fmt.Errorf("target file %s does not exist", p)
 		}
-		// get the inode data for this file
-		// now open the file
-		// get the inode for the file
-		var eFile *extendedFile
-		in := targetEntry.inode
-		iType := in.inodeType()
-		body := in.getBody()
-		//nolint:exhaustive // all other cases fall under default
-		switch iType {
-		case inodeBasicFile:
-			extFile := body.(*basicFile).toExtended()
-			eFile = &extFile
-		case inodeExtendedFile:
-			eFile, _ = body.(*extendedFile)
-		default:
-			return nil, fmt.Errorf("inode is of type %d, neither basic nor extended directory", iType)
-		}
-
-		f = &File{
-			extendedFile: eFile,
-			isReadWrite:  false,
-			isAppend:     false,
-			offset:       0,
-			filesystem:   fs,
+		f, err = targetEntry.Open()
+		if err != nil {
+			return nil, err
 		}
 	} else {
 		f, err = os.OpenFile(path.Join(fs.workspace, p), flag, 0o644)
@@ -440,6 +419,7 @@ func (fs *FileSystem) hydrateDirectoryEntries(entries []*directoryEntryRaw) ([]*
 			}
 		}
 		fullEntries = append(fullEntries, &directoryEntry{
+			fs:             fs,
 			isSubdirectory: e.isSubdirectory,
 			name:           e.name,
 			size:           body.size(),

filesystem/squashfs/squashfs_test.go

@@ -263,6 +263,57 @@ func TestSquashfsOpenFile(t *testing.T) {
 	})
 }
 
+// Test the Open method on the directory entry
+func TestSquashfsOpen(t *testing.T) {
+	fs, err := getValidSquashfsFSReadOnly()
+	if err != nil {
+		t.Errorf("Failed to get read-only squashfs filesystem: %v", err)
+	}
+	fis, err := fs.ReadDir("/")
+	if err != nil {
+		t.Errorf("Failed to list squashfs filesystem: %v", err)
+	}
+	var dir = make(map[string]os.FileInfo, len(fis))
+	for _, fi := range fis {
+		dir[fi.Name()] = fi
+	}
+
+	// Check a file
+	fi := dir["README.md"]
+	fix, ok := fi.Sys().(squashfs.FileStat)
+	if !ok {
+		t.Fatal("Wrong type")
+	}
+	fh, err := fix.Open()
+	if err != nil {
+		t.Errorf("Failed to open file: %v", err)
+	}
+	gotBuf, err := io.ReadAll(fh)
+	if err != nil {
+		t.Errorf("Failed to read file: %v", err)
+	}
+	err = fh.Close()
+	if err != nil {
+		t.Errorf("Failed to close file: %v", err)
+	}
+	wantBuf := "README\n"
+	if string(gotBuf) != wantBuf {
+		t.Errorf("Expecting to read %q from file but read %q", wantBuf, string(gotBuf))
+	}
+
+	// Check a directory
+	fi = dir["foo"]
+	fix, ok = fi.Sys().(squashfs.FileStat)
+	if !ok {
+		t.Fatal("Wrong type")
+	}
+	_, err = fix.Open()
+	wantErr := fmt.Errorf("inode is of type 8, neither basic nor extended file")
+	if err.Error() != wantErr.Error() {
+		t.Errorf("Want error %q but got %q", wantErr, err)
+	}
+}
+
 func TestSquashfsRead(t *testing.T) {
 	tests := []struct {
 		blocksize  int64