Add tarfs implementation

.travis.yml

@@ -19,4 +19,4 @@ script:
   - go build -v ./...
   - go test -count=1 -cover -race -v ./...
   - go vet ./...
-  - FILES=$(gofmt -s -l . zipfs sftpfs mem); if [[ -n "${FILES}" ]]; then  echo "You have go format errors; gofmt your changes"; exit 1; fi
+  - FILES=$(gofmt -s -l . zipfs sftpfs mem tarfs); if [[ -n "${FILES}" ]]; then  echo "You have go format errors; gofmt your changes"; exit 1; fi

README.md

@@ -380,7 +380,6 @@ The following is a short list of possible backends we hope someone will
 implement:
 
 * SSH
-* TAR
 * S3
 
 # About the project

tarfs/file.go

@@ -0,0 +1,143 @@
+package tarfs
+
+import (
+	"archive/tar"
+	"bytes"
+	"os"
+	"sort"
+	"syscall"
+
+	"github.com/spf13/afero"
+)
+
+type File struct {
+	h      *tar.Header
+	data   *bytes.Reader
+	closed bool
+	fs     *Fs
+}
+
+func (f *File) Close() error {
+	if f.closed {
+		return afero.ErrFileClosed
+	}
+
+	f.closed = true
+	f.h = nil
+	f.data = nil
+	f.fs = nil
+
+	return nil
+}
+
+func (f *File) Read(p []byte) (n int, err error) {
+	if f.closed {
+		return 0, afero.ErrFileClosed
+	}
+
+	if f.h.Typeflag == tar.TypeDir {
+		return 0, syscall.EISDIR
+	}
+
+	return f.data.Read(p)
+}
+
+func (f *File) ReadAt(p []byte, off int64) (n int, err error) {
+	if f.closed {
+		return 0, afero.ErrFileClosed
+	}
+
+	if f.h.Typeflag == tar.TypeDir {
+		return 0, syscall.EISDIR
+	}
+
+	return f.data.ReadAt(p, off)
+}
+
+func (f *File) Seek(offset int64, whence int) (int64, error) {
+	if f.closed {
+		return 0, afero.ErrFileClosed
+	}
+
+	if f.h.Typeflag == tar.TypeDir {
+		return 0, syscall.EISDIR
+	}
+
+	return f.data.Seek(offset, whence)
+}
+
+func (f *File) Write(p []byte) (n int, err error) { return 0, syscall.EROFS }
+
+func (f *File) WriteAt(p []byte, off int64) (n int, err error) { return 0, syscall.EROFS }
+
+func (f *File) Name() string {
+	return f.h.Name
+}
+
+func (f *File) getDirectoryNames() ([]string, error) {
+	d, ok := f.fs.files[f.Name()]
+	if !ok {
+		return nil, &os.PathError{Op: "readdir", Path: f.Name(), Err: syscall.ENOENT}
+	}
+
+	var names []string
+	for n := range d {
+		names = append(names, n)
+	}
+	sort.Strings(names)
+
+	return names, nil
+}
+
+func (f *File) Readdir(count int) ([]os.FileInfo, error) {
+	if f.closed {
+		return nil, afero.ErrFileClosed
+	}
+
+	if !f.h.FileInfo().IsDir() {
+		return nil, syscall.ENOTDIR
+	}
+
+	names, err := f.getDirectoryNames()
+	if err != nil {
+		return nil, err
+	}
+
+	d := f.fs.files[f.Name()]
+	var fi []os.FileInfo
+	for _, n := range names {
+		if n == "" {
+			continue
+		}
+
+		f := d[n]
+		fi = append(fi, f.h.FileInfo())
+		if count > 0 && len(fi) >= count {
+			break
+		}
+	}
+
+	return fi, nil
+}
+
+func (f *File) Readdirnames(n int) ([]string, error) {
+	fi, err := f.Readdir(n)
+	if err != nil {
+		return nil, err
+	}
+
+	var names []string
+	for _, f := range fi {
+		names = append(names, f.Name())
+	}
+
+	return names, nil
+}
+
+func (f *File) Stat() (os.FileInfo, error) { return f.h.FileInfo(), nil }
+
+func (f *File) Sync() error { return nil }
+
+func (f *File) Truncate(size int64) error { return syscall.EROFS }
+
+func (f *File) WriteString(s string) (ret int, err error) { return 0, syscall.EROFS }

tarfs/fs.go

@@ -0,0 +1,136 @@
+// package tarfs implements a read-only in-memory representation of a tar archive
+package tarfs
+
+import (
+	"archive/tar"
+	"bytes"
+	"io"
+	"os"
+	"path/filepath"
+	"syscall"
+	"time"
+
+	"github.com/spf13/afero"
+)
+
+type Fs struct {
+	files map[string]map[string]*File
+}
+
+func splitpath(name string) (dir, file string) {
+	name = filepath.ToSlash(name)
+	if len(name) == 0 || name[0] != '/' {
+		name = "/" + name
+	}
+	name = filepath.Clean(name)
+	dir, file = filepath.Split(name)
+	dir = filepath.Clean(dir)
+	return
+}
+
+func New(t *tar.Reader) *Fs {
+	fs := &Fs{files: make(map[string]map[string]*File)}
+	for {
+		hdr, err := t.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return nil
+		}
+
+		d, f := splitpath(hdr.Name)
+		if _, ok := fs.files[d]; !ok {
+			fs.files[d] = make(map[string]*File)
+		}
+
+		var buf bytes.Buffer
+		size, err := buf.ReadFrom(t)
+		if err != nil {
+			panic("tarfs: reading from tar:" + err.Error())
+		}
+
+		if size != hdr.Size {
+			panic("tarfs: size mismatch")
+		}
+
+		file := &File{
+			h:    hdr,
+			data: bytes.NewReader(buf.Bytes()),
+			fs:   fs,
+		}
+		file.h.Name = filepath.Join(d, f)
+
+		fs.files[d][f] = file
+
+	}
+
+	// Add a pseudoroot
+	fs.files["/"][""] = &File{
+		h: &tar.Header{
+			Name:     "/",
+			Typeflag: tar.TypeDir,
+			Size:     0,
+		},
+		data: bytes.NewReader(nil),
+		fs:   fs,
+	}
+
+	return fs
+}
+
+func (fs *Fs) Open(name string) (afero.File, error) {
+	d, f := splitpath(name)
+	if _, ok := fs.files[d]; !ok {
+		return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOENT}
+	}
+
+	file, ok := fs.files[d][f]
+	if !ok {
+		return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOENT}
+	}
+
+	nf := *file
+
+	return &nf, nil
+}
+
+func (fs *Fs) Name() string { return "tarfs" }
+
+func (fs *Fs) Create(name string) (afero.File, error) { return nil, syscall.EROFS }
+
+func (fs *Fs) Mkdir(name string, perm os.FileMode) error { return syscall.EROFS }
+
+func (fs *Fs) MkdirAll(path string, perm os.FileMode) error { return syscall.EROFS }
+
+func (fs *Fs) OpenFile(name string, flag int, perm os.FileMode) (afero.File, error) {
+	if flag != os.O_RDONLY {
+		return nil, &os.PathError{Op: "open", Path: name, Err: syscall.EPERM}
+	}
+
+	return fs.Open(name)
+}
+
+func (fs *Fs) Remove(name string) error { return syscall.EROFS }
+
+func (fs *Fs) RemoveAll(path string) error { return syscall.EROFS }
+
+func (fs *Fs) Rename(oldname string, newname string) error { return syscall.EROFS }
+
+func (fs *Fs) Stat(name string) (os.FileInfo, error) {
+	d, f := splitpath(name)
+	if _, ok := fs.files[d]; !ok {
+		return nil, &os.PathError{Op: "stat", Path: name, Err: syscall.ENOENT}
+	}
+
+	file, ok := fs.files[d][f]
+	if !ok {
+		return nil, &os.PathError{Op: "stat", Path: name, Err: syscall.ENOENT}
+	}
+
+	return file.h.FileInfo(), nil
+}
+
+func (fs *Fs) Chmod(name string, mode os.FileMode) error { return syscall.EROFS }
+
+func (fs *Fs) Chtimes(name string, atime time.Time, mtime time.Time) error { return syscall.EROFS }