Update dependencies (#1521)

vendor/github.com/spf13/afero/.travis.yml

@@ -1,9 +1,13 @@
 sudo: false
 language: go
+arch:
+ - amd64
+ - ppc64e
 
 go:
-  - "1.13"
   - "1.14"
+  - "1.15"
+  - "1.16"
   - tip
 
 os:
@@ -19,4 +23,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

vendor/github.com/spf13/afero/README.md

@@ -33,7 +33,7 @@ filesystem for full interoperability.
 * Support for compositional (union) file systems by combining multiple file systems acting as one
 * Specialized backends which modify existing filesystems (Read Only, Regexp filtered)
 * A set of utility functions ported from io, ioutil & hugo to be afero aware
-
+* Wrapper for go 1.16 filesystem abstraction `io/fs.FS`
 
 # Using Afero
 
@@ -94,6 +94,7 @@ AppFs.Open('/tmp/foo')
 File System Methods Available:
 ```go
 Chmod(name string, mode os.FileMode) : error
+Chown(name string, uid, gid int) : error
 Chtimes(name string, atime time.Time, mtime time.Time) : error
 Create(name string) : File, error
 Mkdir(name string, perm os.FileMode) : error
@@ -227,7 +228,7 @@ operation and a mock filesystem during testing or as needed.
 
 ```go
 appfs := afero.NewOsFs()
-appfs.MkdirAll("src/a", 0755))
+appfs.MkdirAll("src/a", 0755)
 ```
 
 ## Memory Backed Storage
@@ -241,7 +242,7 @@ safely.
 
 ```go
 mm := afero.NewMemMapFs()
-mm.MkdirAll("src/a", 0755))
+mm.MkdirAll("src/a", 0755)
 ```
 
 #### InMemoryFile
@@ -306,7 +307,7 @@ Any Afero FileSystem can be used as an httpFs.
 
 ```go
 httpFs := afero.NewHttpFs(<ExistingFS>)
-fileserver := http.FileServer(httpFs.Dir(<PATH>)))
+fileserver := http.FileServer(httpFs.Dir(<PATH>))
 http.Handle("/", fileserver)
 ```
 
@@ -380,7 +381,6 @@ The following is a short list of possible backends we hope someone will
 implement:
 
 * SSH
-* TAR
 * S3
 
 # About the project

vendor/github.com/spf13/afero/afero.go

@@ -91,9 +91,12 @@ type Fs interface {
 	// The name of this FileSystem
 	Name() string
 
-	//Chmod changes the mode of the named file to mode.
+	// Chmod changes the mode of the named file to mode.
 	Chmod(name string, mode os.FileMode) error
 
+	// Chown changes the uid and gid of the named file.
+	Chown(name string, uid, gid int) error
+
 	//Chtimes changes the access and modification times of the named file
 	Chtimes(name string, atime time.Time, mtime time.Time) error
 }

vendor/github.com/spf13/afero/basepath.go

@@ -83,6 +83,13 @@ func (b *BasePathFs) Chmod(name string, mode os.FileMode) (err error) {
 	return b.source.Chmod(name, mode)
 }
 
+func (b *BasePathFs) Chown(name string, uid, gid int) (err error) {
+	if name, err = b.RealPath(name); err != nil {
+		return &os.PathError{Op: "chown", Path: name, Err: err}
+	}
+	return b.source.Chown(name, uid, gid)
+}
+
 func (b *BasePathFs) Name() string {
 	return "BasePathFs"
 }
@@ -202,5 +209,3 @@ func (b *BasePathFs) ReadlinkIfPossible(name string) (string, error) {
 	}
 	return "", &os.PathError{Op: "readlink", Path: name, Err: ErrNoReadlink}
 }
-
-// vim: ts=4 sw=4 noexpandtab nolist syn=go

vendor/github.com/spf13/afero/cacheOnReadFs.go

@@ -117,6 +117,27 @@ func (u *CacheOnReadFs) Chmod(name string, mode os.FileMode) error {
 	return u.layer.Chmod(name, mode)
 }
 
+func (u *CacheOnReadFs) Chown(name string, uid, gid int) error {
+	st, _, err := u.cacheStatus(name)
+	if err != nil {
+		return err
+	}
+	switch st {
+	case cacheLocal:
+	case cacheHit:
+		err = u.base.Chown(name, uid, gid)
+	case cacheStale, cacheMiss:
+		if err := u.copyToLayer(name); err != nil {
+			return err
+		}
+		err = u.base.Chown(name, uid, gid)
+	}
+	if err != nil {
+		return err
+	}
+	return u.layer.Chown(name, uid, gid)
+}
+
 func (u *CacheOnReadFs) Stat(name string) (os.FileInfo, error) {
 	st, fi, err := u.cacheStatus(name)
 	if err != nil {

vendor/github.com/spf13/afero/copyOnWriteFs.go

@@ -14,7 +14,7 @@ var _ Lstater = (*CopyOnWriteFs)(nil)
 // a possibly writeable layer on top. Changes to the file system will only
 // be made in the overlay: Changing an existing file in the base layer which
 // is not present in the overlay will copy the file to the overlay ("changing"
-// includes also calls to e.g. Chtimes() and Chmod()).
+// includes also calls to e.g. Chtimes(), Chmod() and Chown()).
 //
 // Reading directories is currently only supported via Open(), not OpenFile().
 type CopyOnWriteFs struct {
@@ -75,6 +75,19 @@ func (u *CopyOnWriteFs) Chmod(name string, mode os.FileMode) error {
 	return u.layer.Chmod(name, mode)
 }
 
+func (u *CopyOnWriteFs) Chown(name string, uid, gid int) error {
+	b, err := u.isBaseFile(name)
+	if err != nil {
+		return err
+	}
+	if b {
+		if err := u.copyToLayer(name); err != nil {
+			return err
+		}
+	}
+	return u.layer.Chown(name, uid, gid)
+}
+
 func (u *CopyOnWriteFs) Stat(name string) (os.FileInfo, error) {
 	fi, err := u.layer.Stat(name)
 	if err != nil {

vendor/github.com/spf13/afero/httpFs.go

@@ -67,6 +67,10 @@ func (h HttpFs) Chmod(name string, mode os.FileMode) error {
 	return h.source.Chmod(name, mode)
 }
 
+func (h HttpFs) Chown(name string, uid, gid int) error {
+	return h.source.Chown(name, uid, gid)
+}
+
 func (h HttpFs) Chtimes(name string, atime time.Time, mtime time.Time) error {
 	return h.source.Chtimes(name, atime, mtime)
 }

vendor/github.com/spf13/afero/iofs.go

@@ -0,0 +1,288 @@
+// +build go1.16
+
+package afero
+
+import (
+	"io"
+	"io/fs"
+	"os"
+	"path"
+	"time"
+)
+
+// IOFS adopts afero.Fs to stdlib io/fs.FS
+type IOFS struct {
+	Fs
+}
+
+func NewIOFS(fs Fs) IOFS {
+	return IOFS{Fs: fs}
+}
+
+var (
+	_ fs.FS         = IOFS{}
+	_ fs.GlobFS     = IOFS{}
+	_ fs.ReadDirFS  = IOFS{}
+	_ fs.ReadFileFS = IOFS{}
+	_ fs.StatFS     = IOFS{}
+	_ fs.SubFS      = IOFS{}
+)
+
+func (iofs IOFS) Open(name string) (fs.File, error) {
+	const op = "open"
+
+	// by convention for fs.FS implementations we should perform this check
+	if !fs.ValidPath(name) {
+		return nil, iofs.wrapError(op, name, fs.ErrInvalid)
+	}
+
+	file, err := iofs.Fs.Open(name)
+	if err != nil {
+		return nil, iofs.wrapError(op, name, err)
+	}
+
+	// file should implement fs.ReadDirFile
+	if _, ok := file.(fs.ReadDirFile); !ok {
+		file = readDirFile{file}
+	}
+
+	return file, nil
+}
+
+func (iofs IOFS) Glob(pattern string) ([]string, error) {
+	const op = "glob"
+
+	// afero.Glob does not perform this check but it's required for implementations
+	if _, err := path.Match(pattern, ""); err != nil {
+		return nil, iofs.wrapError(op, pattern, err)
+	}
+
+	items, err := Glob(iofs.Fs, pattern)
+	if err != nil {
+		return nil, iofs.wrapError(op, pattern, err)
+	}
+
+	return items, nil
+}
+
+func (iofs IOFS) ReadDir(name string) ([]fs.DirEntry, error) {
+	items, err := ReadDir(iofs.Fs, name)
+	if err != nil {
+		return nil, iofs.wrapError("readdir", name, err)
+	}
+
+	ret := make([]fs.DirEntry, len(items))
+	for i := range items {
+		ret[i] = dirEntry{items[i]}
+	}
+
+	return ret, nil
+}
+
+func (iofs IOFS) ReadFile(name string) ([]byte, error) {
+	const op = "readfile"
+
+	if !fs.ValidPath(name) {
+		return nil, iofs.wrapError(op, name, fs.ErrInvalid)
+	}
+
+	bytes, err := ReadFile(iofs.Fs, name)
+	if err != nil {
+		return nil, iofs.wrapError(op, name, err)
+	}
+
+	return bytes, nil
+}
+
+func (iofs IOFS) Sub(dir string) (fs.FS, error) { return IOFS{NewBasePathFs(iofs.Fs, dir)}, nil }
+
+func (IOFS) wrapError(op, path string, err error) error {
+	if _, ok := err.(*fs.PathError); ok {
+		return err // don't need to wrap again
+	}
+
+	return &fs.PathError{
+		Op:   op,
+		Path: path,
+		Err:  err,
+	}
+}
+
+// dirEntry provides adapter from os.FileInfo to fs.DirEntry
+type dirEntry struct {
+	fs.FileInfo
+}
+
+var _ fs.DirEntry = dirEntry{}
+
+func (d dirEntry) Type() fs.FileMode { return d.FileInfo.Mode().Type() }
+
+func (d dirEntry) Info() (fs.FileInfo, error) { return d.FileInfo, nil }
+
+// readDirFile provides adapter from afero.File to fs.ReadDirFile needed for correct Open
+type readDirFile struct {
+	File
+}
+
+var _ fs.ReadDirFile = readDirFile{}
+
+func (r readDirFile) ReadDir(n int) ([]fs.DirEntry, error) {
+	items, err := r.File.Readdir(n)
+	if err != nil {
+		return nil, err
+	}
+
+	ret := make([]fs.DirEntry, len(items))
+	for i := range items {
+		ret[i] = dirEntry{items[i]}
+	}
+
+	return ret, nil
+}
+
+// FromIOFS adopts io/fs.FS to use it as afero.Fs
+// Note that io/fs.FS is read-only so all mutating methods will return fs.PathError with fs.ErrPermission
+// To store modifications you may use afero.CopyOnWriteFs
+type FromIOFS struct {
+	fs.FS
+}
+
+var _ Fs = FromIOFS{}
+
+func (f FromIOFS) Create(name string) (File, error) { return nil, notImplemented("create", name) }
+
+func (f FromIOFS) Mkdir(name string, perm os.FileMode) error { return notImplemented("mkdir", name) }
+
+func (f FromIOFS) MkdirAll(path string, perm os.FileMode) error {
+	return notImplemented("mkdirall", path)
+}
+
+func (f FromIOFS) Open(name string) (File, error) {
+	file, err := f.FS.Open(name)
+	if err != nil {
+		return nil, err
+	}
+
+	return fromIOFSFile{File: file, name: name}, nil
+}
+
+func (f FromIOFS) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
+	return f.Open(name)
+}
+
+func (f FromIOFS) Remove(name string) error {
+	return notImplemented("remove", name)
+}
+
+func (f FromIOFS) RemoveAll(path string) error {
+	return notImplemented("removeall", path)
+}
+
+func (f FromIOFS) Rename(oldname, newname string) error {
+	return notImplemented("rename", oldname)
+}
+
+func (f FromIOFS) Stat(name string) (os.FileInfo, error) { return fs.Stat(f.FS, name) }
+
+func (f FromIOFS) Name() string { return "fromiofs" }
+
+func (f FromIOFS) Chmod(name string, mode os.FileMode) error {
+	return notImplemented("chmod", name)
+}
+
+func (f FromIOFS) Chown(name string, uid, gid int) error {
+	return notImplemented("chown", name)
+}
+
+func (f FromIOFS) Chtimes(name string, atime time.Time, mtime time.Time) error {
+	return notImplemented("chtimes", name)
+}
+
+type fromIOFSFile struct {
+	fs.File
+	name string
+}
+
+func (f fromIOFSFile) ReadAt(p []byte, off int64) (n int, err error) {
+	readerAt, ok := f.File.(io.ReaderAt)
+	if !ok {
+		return -1, notImplemented("readat", f.name)
+	}
+
+	return readerAt.ReadAt(p, off)
+}
+
+func (f fromIOFSFile) Seek(offset int64, whence int) (int64, error) {
+	seeker, ok := f.File.(io.Seeker)
+	if !ok {
+		return -1, notImplemented("seek", f.name)
+	}
+
+	return seeker.Seek(offset, whence)
+}
+
+func (f fromIOFSFile) Write(p []byte) (n int, err error) {
+	return -1, notImplemented("write", f.name)
+}
+
+func (f fromIOFSFile) WriteAt(p []byte, off int64) (n int, err error) {
+	return -1, notImplemented("writeat", f.name)
+}
+
+func (f fromIOFSFile) Name() string { return f.name }
+
+func (f fromIOFSFile) Readdir(count int) ([]os.FileInfo, error) {
+	rdfile, ok := f.File.(fs.ReadDirFile)
+	if !ok {
+		return nil, notImplemented("readdir", f.name)
+	}
+
+	entries, err := rdfile.ReadDir(count)
+	if err != nil {
+		return nil, err
+	}
+
+	ret := make([]os.FileInfo, len(entries))
+	for i := range entries {
+		ret[i], err = entries[i].Info()
+
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return ret, nil
+}
+
+func (f fromIOFSFile) Readdirnames(n int) ([]string, error) {
+	rdfile, ok := f.File.(fs.ReadDirFile)
+	if !ok {
+		return nil, notImplemented("readdir", f.name)
+	}
+
+	entries, err := rdfile.ReadDir(n)
+	if err != nil {
+		return nil, err
+	}
+
+	ret := make([]string, len(entries))
+	for i := range entries {
+		ret[i] = entries[i].Name()
+	}
+
+	return ret, nil
+}
+
+func (f fromIOFSFile) Sync() error { return nil }
+
+func (f fromIOFSFile) Truncate(size int64) error {
+	return notImplemented("truncate", f.name)
+}
+
+func (f fromIOFSFile) WriteString(s string) (ret int, err error) {
+	return -1, notImplemented("writestring", f.name)
+}
+
+func notImplemented(op, path string) error {
+	return &fs.PathError{Op: op, Path: path, Err: fs.ErrPermission}
+}

vendor/github.com/spf13/afero/mem/file.go

@@ -22,10 +22,9 @@ import (
 	"path/filepath"
 	"sync"
 	"sync/atomic"
+	"time"
 )
 
-import "time"
-
 const FilePathSeparator = string(filepath.Separator)
 
 type File struct {
@@ -57,6 +56,8 @@ type FileData struct {
 	dir     bool
 	mode    os.FileMode
 	modtime time.Time
+	uid     int
+	gid     int
 }
 
 func (d *FileData) Name() string {
@@ -95,6 +96,18 @@ func setModTime(f *FileData, mtime time.Time) {
 	f.modtime = mtime
 }
 
+func SetUID(f *FileData, uid int) {
+	f.Lock()
+	f.uid = uid
+	f.Unlock()
+}
+
+func SetGID(f *FileData, gid int) {
+	f.Lock()
+	f.gid = gid
+	f.Unlock()
+}
+
 func GetFileInfo(f *FileData) *FileInfo {
 	return &FileInfo{f}
 }
@@ -210,6 +223,8 @@ func (f *File) Truncate(size int64) error {
 	if size < 0 {
 		return ErrOutOfRange
 	}
+	f.fileData.Lock()
+	defer f.fileData.Unlock()
 	if size > int64(len(f.fileData.data)) {
 		diff := size - int64(len(f.fileData.data))
 		f.fileData.data = append(f.fileData.data, bytes.Repeat([]byte{00}, int(diff))...)
@@ -225,11 +240,11 @@ func (f *File) Seek(offset int64, whence int) (int64, error) {
 		return 0, ErrFileClosed
 	}
 	switch whence {
-	case 0:
+	case io.SeekStart:
 		atomic.StoreInt64(&f.at, offset)
-	case 1:
-		atomic.AddInt64(&f.at, int64(offset))
-	case 2:
+	case io.SeekCurrent:
+		atomic.AddInt64(&f.at, offset)
+	case io.SeekEnd:
 		atomic.StoreInt64(&f.at, int64(len(f.fileData.data))+offset)
 	}
 	return f.at, nil
@@ -252,7 +267,7 @@ func (f *File) Write(b []byte) (n int, err error) {
 		tail = f.fileData.data[n+int(cur):]
 	}
 	if diff > 0 {
-		f.fileData.data = append(bytes.Repeat([]byte{00}, int(diff)), b...)
+		f.fileData.data = append(f.fileData.data, append(bytes.Repeat([]byte{00}, int(diff)), b...)...)
 		f.fileData.data = append(f.fileData.data, tail...)
 	} else {
 		f.fileData.data = append(f.fileData.data[:cur], b...)
@@ -260,7 +275,7 @@ func (f *File) Write(b []byte) (n int, err error) {
 	}
 	setModTime(f.fileData, time.Now())
 
-	atomic.StoreInt64(&f.at, int64(len(f.fileData.data)))
+	atomic.AddInt64(&f.at, int64(n))
 	return
 }
 

vendor/github.com/spf13/afero/memmap.go

@@ -317,6 +317,11 @@ func (m *MemMapFs) Rename(oldname, newname string) error {
 	return nil
 }
 
+func (m *MemMapFs) LstatIfPossible(name string) (os.FileInfo, bool, error) {
+	fileInfo, err := m.Stat(name)
+	return fileInfo, false, err
+}
+
 func (m *MemMapFs) Stat(name string) (os.FileInfo, error) {
 	f, err := m.Open(name)
 	if err != nil {
@@ -358,6 +363,22 @@ func (m *MemMapFs) setFileMode(name string, mode os.FileMode) error {
 	return nil
 }
 
+func (m *MemMapFs) Chown(name string, uid, gid int) error {
+	name = normalizePath(name)
+
+	m.mu.RLock()
+	f, ok := m.getData()[name]
+	m.mu.RUnlock()
+	if !ok {
+		return &os.PathError{Op: "chown", Path: name, Err: ErrFileNotFound}
+	}
+
+	mem.SetUID(f, uid)
+	mem.SetGID(f, gid)
+
+	return nil
+}
+
 func (m *MemMapFs) Chtimes(name string, atime time.Time, mtime time.Time) error {
 	name = normalizePath(name)
 
@@ -381,9 +402,3 @@ func (m *MemMapFs) List() {
 		fmt.Println(x.Name(), y.Size())
 	}
 }
-
-// func debugMemMapList(fs Fs) {
-// 	if x, ok := fs.(*MemMapFs); ok {
-// 		x.List()
-// 	}
-// }

vendor/github.com/spf13/afero/os.go

@@ -91,6 +91,10 @@ func (OsFs) Chmod(name string, mode os.FileMode) error {
 	return os.Chmod(name, mode)
 }
 
+func (OsFs) Chown(name string, uid, gid int) error {
+	return os.Chown(name, uid, gid)
+}
+
 func (OsFs) Chtimes(name string, atime time.Time, mtime time.Time) error {
 	return os.Chtimes(name, atime, mtime)
 }

vendor/github.com/spf13/afero/readonlyfs.go

@@ -28,6 +28,10 @@ func (r *ReadOnlyFs) Chmod(n string, m os.FileMode) error {
 	return syscall.EPERM
 }
 
+func (r *ReadOnlyFs) Chown(n string, uid, gid int) error {
+	return syscall.EPERM
+}
+
 func (r *ReadOnlyFs) Name() string {
 	return "ReadOnlyFilter"
 }

vendor/github.com/spf13/afero/regexpfs.go

@@ -60,6 +60,13 @@ func (r *RegexpFs) Chmod(name string, mode os.FileMode) error {
 	return r.source.Chmod(name, mode)
 }
 
+func (r *RegexpFs) Chown(name string, uid, gid int) error {
+	if err := r.dirOrMatches(name); err != nil {
+		return err
+	}
+	return r.source.Chown(name, uid, gid)
+}
+
 func (r *RegexpFs) Name() string {
 	return "RegexpFs"
 }

vendor/github.com/spf13/afero/unionFile.go

@@ -186,25 +186,22 @@ func (f *UnionFile) Readdir(c int) (ofi []os.FileInfo, err error) {
 		}
 		f.files = append(f.files, merged...)
 	}
+	files := f.files[f.off:]
 
-	if c <= 0 && len(f.files) == 0 {
-		return f.files, nil
+	if c <= 0 {
+		return files, nil
 	}
 
-	if f.off >= len(f.files) {
+	if len(files) == 0 {
 		return nil, io.EOF
 	}
 
-	if c <= 0 {
-		return f.files[f.off:], nil
-	}
-
-	if c > len(f.files) {
-		c = len(f.files)
+	if c > len(files) {
+		c = len(files)
 	}
 
 	defer func() { f.off += c }()
-	return f.files[f.off:c], nil
+	return files[:c], nil
 }
 
 func (f *UnionFile) Readdirnames(c int) ([]string, error) {