compressedfs - fs.go

     1  // Package compressedfs offers a fs.FS implementation that allows compressed files to be handled as normal files.
     2  package compressedfs // import "vimagination.zapto.org/compressedfs"
     3  
     4  import (
     5  	"compress/gzip"
     6  	"errors"
     7  	"io"
     8  	"io/fs"
     9  	"path/filepath"
    10  	"strings"
    11  	"time"
    12  )
    13  
    14  const ext = ".gz"
    15  
    16  type compressedfs struct {
    17  	fs fs.FS
    18  }
    19  
    20  // New wraps an existing fs.FS to enable the transparent translation of gzip
    21  // compressed files to their uncompressed counterparts.
    22  //
    23  // Files ending in .gz can be opened without the .gz extension as the uncompressed
    24  // form.
    25  //
    26  // Reading from directories will automatically remove the extension from
    27  // entries if an uncompressed files doesn't already exist.
    28  func New(fs fs.FS) fs.FS {
    29  	return &compressedfs{fs}
    30  }
    31  
    32  func (c *compressedfs) Open(path string) (fs.File, error) {
    33  	f, err := c.fs.Open(path)
    34  	if err == nil {
    35  		return c.openFileOrDir(path, f)
    36  	} else if !errors.Is(err, fs.ErrNotExist) {
    37  		return f, err
    38  	}
    39  
    40  	f, errr := c.fs.Open(path + ext)
    41  	if errr != nil {
    42  		return nil, err
    43  	}
    44  
    45  	f, err = c.openCompressedFile(path, f)
    46  	if err != nil {
    47  		f.Close()
    48  	}
    49  
    50  	return f, err
    51  }
    52  
    53  func (c *compressedfs) openCompressedFile(path string, f fs.File) (fs.File, error) {
    54  	rs, ok := f.(io.ReadSeekCloser)
    55  	if !ok {
    56  		return nil, ErrInvalidSeek
    57  	}
    58  
    59  	size, err := readSize(rs)
    60  	if err != nil {
    61  		return nil, err
    62  	}
    63  
    64  	stat, err := f.Stat()
    65  	if err != nil {
    66  		return nil, err
    67  	}
    68  
    69  	cf, err := gzip.NewReader(rs)
    70  	if err != nil {
    71  		return nil, err
    72  	}
    73  
    74  	return &compressedFile{
    75  		f:       cf,
    76  		file:    rs,
    77  		name:    filepath.Base(path),
    78  		size:    size,
    79  		modtime: stat.ModTime(),
    80  		mode:    stat.Mode(),
    81  	}, nil
    82  }
    83  
    84  func (c *compressedfs) openFileOrDir(path string, f fs.File) (fs.File, error) {
    85  	s, err := f.Stat()
    86  	if err != nil {
    87  		return nil, err
    88  	}
    89  
    90  	if !s.IsDir() {
    91  		return f, nil
    92  	}
    93  
    94  	d, ok := f.(fs.ReadDirFile)
    95  	if !ok {
    96  		return f, nil
    97  	}
    98  
    99  	return &dir{
   100  		c:           c,
   101  		path:        path,
   102  		ReadDirFile: d,
   103  	}, nil
   104  }
   105  
   106  func readSize(rs io.ReadSeeker) (int64, error) {
   107  	if _, err := rs.Seek(-4, io.SeekEnd); err != nil {
   108  		return 0, err
   109  	}
   110  
   111  	var size [4]byte
   112  
   113  	if _, err := io.ReadFull(rs, size[:]); err != nil {
   114  		return 0, err
   115  	}
   116  
   117  	if _, err := rs.Seek(0, io.SeekStart); err != nil {
   118  		return 0, err
   119  	}
   120  
   121  	return int64(size[0]) | int64(size[1])<<8 | int64(size[2])<<16 | int64(size[3])<<24, nil
   122  }
   123  
   124  type compressedFile struct {
   125  	f            *gzip.Reader
   126  	file         io.ReadSeekCloser
   127  	name         string
   128  	size         int64
   129  	modtime      time.Time
   130  	mode         fs.FileMode
   131  	pos, seekPos int64
   132  }
   133  
   134  func (c *compressedFile) Stat() (fs.FileInfo, error) {
   135  	return c, nil
   136  }
   137  
   138  func (c *compressedFile) Read(p []byte) (int, error) {
   139  	if c.f == nil {
   140  		return 0, fs.ErrClosed
   141  	} else if c.pos != c.seekPos {
   142  		if c.pos < c.seekPos {
   143  			if err := c.skip(c.seekPos - c.pos); err != nil {
   144  				return 0, err
   145  			}
   146  		} else if err := c.reset(); err != nil {
   147  			return 0, err
   148  		} else if err := c.skip(c.seekPos); err != nil {
   149  			return 0, err
   150  		}
   151  
   152  		c.pos = c.seekPos
   153  	}
   154  
   155  	n, err := c.f.Read(p)
   156  
   157  	c.pos += int64(n)
   158  	c.seekPos = c.pos
   159  
   160  	return n, err
   161  }
   162  
   163  func (c *compressedFile) reset() error {
   164  	if _, err := c.file.Seek(0, 0); err != nil {
   165  		return err
   166  	}
   167  
   168  	c.pos = 0
   169  	c.f.Reset(c.file)
   170  
   171  	return nil
   172  }
   173  
   174  func (c *compressedFile) skip(count int64) error {
   175  	_, err := io.Copy(io.Discard, io.LimitReader(c.f, count))
   176  
   177  	return err
   178  }
   179  
   180  func (c *compressedFile) Close() error {
   181  	if c.f == nil {
   182  		return fs.ErrClosed
   183  	}
   184  
   185  	c.f = nil
   186  
   187  	return c.file.Close()
   188  }
   189  
   190  func (c *compressedFile) Seek(offset int64, whence int) (int64, error) {
   191  	if c.f == nil {
   192  		return 0, fs.ErrClosed
   193  	}
   194  
   195  	switch whence {
   196  	case io.SeekStart:
   197  		c.seekPos = offset
   198  	case io.SeekCurrent:
   199  		c.seekPos += offset
   200  	case io.SeekEnd:
   201  		c.seekPos = c.size + offset
   202  	default:
   203  		return 0, ErrInvalidSeek
   204  	}
   205  
   206  	return c.seekPos, nil
   207  }
   208  
   209  func (c *compressedFile) Name() string {
   210  	return c.name
   211  }
   212  
   213  func (c *compressedFile) Size() int64 {
   214  	return c.size
   215  }
   216  
   217  func (c *compressedFile) Mode() fs.FileMode {
   218  	return c.mode
   219  }
   220  
   221  func (c *compressedFile) ModTime() time.Time {
   222  	return c.modtime
   223  }
   224  
   225  func (c *compressedFile) IsDir() bool {
   226  	return false
   227  }
   228  
   229  func (c *compressedFile) Sys() any {
   230  	return nil
   231  }
   232  
   233  type dir struct {
   234  	c    *compressedfs
   235  	path string
   236  	fs.ReadDirFile
   237  }
   238  
   239  func (d *dir) ReadDir(n int) ([]fs.DirEntry, error) {
   240  	entries, err := d.ReadDirFile.ReadDir(n)
   241  	if err != nil {
   242  		return nil, err
   243  	}
   244  
   245  	for n, entry := range entries {
   246  		name := entry.Name()
   247  		if !strings.HasSuffix(entry.Name(), ext) {
   248  			continue
   249  		}
   250  
   251  		if _, err := fs.Stat(d.c.fs, filepath.Join(d.path, strings.TrimSuffix(name, ext))); err == nil {
   252  			continue
   253  		}
   254  
   255  		entries[n], err = d.newDirEntry(entry)
   256  		if err != nil {
   257  			return nil, err
   258  		}
   259  	}
   260  
   261  	return entries, nil
   262  }
   263  
   264  func (d *dir) newDirEntry(entry fs.DirEntry) (fs.DirEntry, error) {
   265  	f, err := d.c.fs.Open(filepath.Join(d.path, entry.Name()))
   266  	if err != nil {
   267  		return nil, err
   268  	}
   269  
   270  	rs, ok := f.(io.ReadSeeker)
   271  	if !ok {
   272  		return nil, ErrInvalidSeek
   273  	}
   274  
   275  	size, err := readSize(rs)
   276  	if err != nil {
   277  		return nil, err
   278  	}
   279  
   280  	return &dirEntry{entry, size}, nil
   281  }
   282  
   283  type dirEntry struct {
   284  	fs.DirEntry
   285  	size int64
   286  }
   287  
   288  func (d *dirEntry) Name() string {
   289  	return strings.TrimSuffix(d.DirEntry.Name(), ext)
   290  }
   291  
   292  func (d *dirEntry) Info() (fs.FileInfo, error) {
   293  	i, err := d.DirEntry.Info()
   294  	if err != nil {
   295  		return nil, err
   296  	}
   297  
   298  	return &info{i, d.size}, nil
   299  }
   300  
   301  type info struct {
   302  	fs.FileInfo
   303  	size int64
   304  }
   305  
   306  func (i *info) Name() string {
   307  	return strings.TrimSuffix(i.FileInfo.Name(), ext)
   308  }
   309  
   310  func (i *info) Size() int64 {
   311  	return i.size
   312  }
   313  
   314  var ErrInvalidSeek = errors.New("cannot seek")
   315