Afero: The Universal Filesystem Abstraction for Go

Afero is a powerful and extensible filesystem abstraction system for Go. It provides a single, unified API for interacting with diverse filesystems—including the local disk, memory, archives, and network storage.

Afero acts as a drop-in replacement for the standardos package, enabling you to write modular code that is agnostic to the underlying storage, dramatically simplifies testing, and allows for sophisticated architectural patterns through filesystem composition.

Why Afero?

Afero elevates filesystem interaction beyond simple file reading and writing, offering solutions for testability, flexibility, and advanced architecture.

🔑Key Features:

• Universal API: Write your code once. Run it against the local OS, in-memory storage, ZIP/TAR archives, or remote systems (SFTP, GCS).
• Ultimate Testability: UtilizeMemMapFs, a fully concurrent-safe, read/write in-memory filesystem. Write fast, isolated, and reliable unit tests without touching the physical disk or worrying about cleanup.
• Powerful Composition: Afero's hidden superpower. Layer filesystems on top of each other to create sophisticated behaviors:
  • Sandboxing: UseCopyOnWriteFs to create temporary scratch spaces that isolate changes from the base filesystem.
  • Caching: UseCacheOnReadFs to automatically layer a fast cache (like memory) over a slow backend (like a network drive).
  • Security Jails: UseBasePathFs to restrict application access to a specific subdirectory (chroot).
• os Package Compatibility: Afero mirrors the functions in the standardos package, making adoption and refactoring seamless.
• io/fs Compatibility: Fully compatible with the Go standard library'sio/fs interfaces.

Installation

go get github.com/spf13/afero

import "github.com/spf13/afero"

Quick Start: The Power of Abstraction

The core of Afero is theafero.Fs interface. By designing your functions to accept this interface rather than callingos.* functions directly, your code instantly becomes more flexible and testable.

1. Refactor Your Code

Change functions that rely on theos package to acceptafero.Fs.

// Before: Coupled to the OS and difficult to test// func ProcessConfiguration(path string) error {//     data, err := os.ReadFile(path)//     ...// }import "github.com/spf13/afero"// After: Decoupled, flexible, and testablefunc ProcessConfiguration(fs afero.Fs, path string) error {    // Use Afero utility functions which mirror os/ioutil    data, err := afero.ReadFile(fs, path)    // ... process the data    return err}

2. Usage in Production

In your production environment, inject theOsFs backend, which wraps the standard operating system calls.

func main() {    // Use the real OS filesystem    AppFs := afero.NewOsFs()    ProcessConfiguration(AppFs, "/etc/myapp.conf")}

3. Usage in Testing

In your tests, injectMemMapFs. This provides a blazing-fast, isolated, in-memory filesystem that requires no disk I/O and no cleanup.

func TestProcessConfiguration(t *testing.T) {    // Use the in-memory filesystem    AppFs := afero.NewMemMapFs()        // Pre-populate the memory filesystem for the test    configPath := "/test/config.json"    afero.WriteFile(AppFs, configPath, []byte(`{"feature": true}`), 0644)    // Run the test entirely in memory    err := ProcessConfiguration(AppFs, configPath)    if err != nil {        t.Fatal(err)    }}

Afero's Superpower: Composition

Afero's most unique feature is its ability to combine filesystems. This allows you to build complex behaviors out of simple components, keeping your application logic clean.

Example 1: Sandboxing with Copy-on-Write

Create a temporary environment where an application can "modify" system files without affecting the actual disk.

// 1. The base layer is the real OS, made read-only for safety.baseFs := afero.NewReadOnlyFs(afero.NewOsFs())// 2. The overlay layer is a temporary in-memory filesystem for changes.overlayFs := afero.NewMemMapFs()// 3. Combine them. Reads fall through to the base; writes only hit the overlay.sandboxFs := afero.NewCopyOnWriteFs(baseFs, overlayFs)// The application can now "modify" /etc/hosts, but the changes are isolated in memory.afero.WriteFile(sandboxFs, "/etc/hosts", []byte("127.0.0.1 sandboxed-app"), 0644)// The real /etc/hosts on disk is untouched.

Example 2: Caching a Slow Filesystem

Improve performance by layering a fast cache (like memory) over a slow backend (like a network drive or cloud storage).

import "time"// Assume 'remoteFs' is a slow backend (e.g., SFTP or GCS)var remoteFs afero.Fs // 'cacheFs' is a fast in-memory backendcacheFs := afero.NewMemMapFs()// Create the caching layer. Cache items for 5 minutes upon first read.cachedFs := afero.NewCacheOnReadFs(remoteFs, cacheFs, 5*time.Minute)// The first read is slow (fetches from remote, then caches)data1, _ := afero.ReadFile(cachedFs, "data.json")// The second read is instant (serves from memory cache)data2, _ := afero.ReadFile(cachedFs, "data.json")

Example 3: Security Jails (chroot)

Restrict an application component's access to a specific subdirectory.

osFs := afero.NewOsFs()// Create a filesystem rooted at /home/user/public// The application cannot access anything above this directory.jailedFs := afero.NewBasePathFs(osFs, "/home/user/public")// To the application, this is reading "/"// In reality, it's reading "/home/user/public/"dirInfo, err := afero.ReadDir(jailedFs, "/")// Attempts to access parent directories fail_, err = jailedFs.Open("../secrets.txt") // Returns an error

Real-World Use Cases

Build Cloud-Agnostic Applications

Write applications that seamlessly work with different storage backends:

type DocumentProcessor struct {    fs afero.Fs}func NewDocumentProcessor(fs afero.Fs) *DocumentProcessor {    return &DocumentProcessor{fs: fs}}func (p *DocumentProcessor) Process(inputPath, outputPath string) error {    // This code works whether fs is local disk, cloud storage, or memory    content, err := afero.ReadFile(p.fs, inputPath)    if err != nil {        return err    }        processed := processContent(content)    return afero.WriteFile(p.fs, outputPath, processed, 0644)}// Use with local filesystemprocessor := NewDocumentProcessor(afero.NewOsFs())// Use with Google Cloud Storageprocessor := NewDocumentProcessor(gcsFS)// Use with in-memory filesystem for testingprocessor := NewDocumentProcessor(afero.NewMemMapFs())

Treating Archives as Filesystems

Read files directly from.zip or.tar archives without unpacking them to disk first.

import (    "archive/zip"    "github.com/spf13/afero/zipfs")// Assume 'zipReader' is a *zip.Reader initialized from a file or memoryvar zipReader *zip.Reader // Create a read-only ZipFsarchiveFS := zipfs.New(zipReader)// Read a file from within the archive using the standard Afero APIcontent, err := afero.ReadFile(archiveFS, "/docs/readme.md")

Serving Any Filesystem over HTTP

UseHttpFs to expose any Afero filesystem—even one created dynamically in memory—through a standard Go web server.

import (    "net/http"    "github.com/spf13/afero")func main() {    memFS := afero.NewMemMapFs()    afero.WriteFile(memFS, "index.html", []byte("<h1>Hello from Memory!</h1>"), 0644)    // Wrap the memory filesystem to make it compatible with http.FileServer.    httpFS := afero.NewHttpFs(memFS)    http.Handle("/", http.FileServer(httpFS.Dir("/")))    http.ListenAndServe(":8080", nil)}

Testing Made Simple

One of Afero's greatest strengths is making filesystem-dependent code easily testable:

func SaveUserData(fs afero.Fs, userID string, data []byte) error {    filename := fmt.Sprintf("users/%s.json", userID)    return afero.WriteFile(fs, filename, data, 0644)}func TestSaveUserData(t *testing.T) {    // Create a clean, fast, in-memory filesystem for testing    testFS := afero.NewMemMapFs()        userData := []byte(`{"name": "John", "email": "john@example.com"}`)    err := SaveUserData(testFS, "123", userData)        if err != nil {        t.Fatalf("SaveUserData failed: %v", err)    }        // Verify the file was saved correctly    saved, err := afero.ReadFile(testFS, "users/123.json")    if err != nil {        t.Fatalf("Failed to read saved file: %v", err)    }        if string(saved) != string(userData) {        t.Errorf("Data mismatch: got %s, want %s", saved, userData)    }}

Benefits of testing with Afero:

• ⚡Fast - No disk I/O, tests run in memory
• 🔄Reliable - Each test starts with a clean slate
• 🧹No cleanup - Memory is automatically freed
• 🔒Safe - Can't accidentally modify real files
• 🏃Parallel - Tests can run concurrently without conflicts

Backend Reference

Afero vs.io/fs (Go 1.16+)

Go 1.16 introduced theio/fs package, which provides a standard abstraction forread-only filesystems.

Afero complementsio/fs by focusing on different needs:

• Useio/fs when: You only need to read files and want to conform strictly to the standard library interfaces.
• Use Afero when:
  • Your application needs tocreate, write, modify, or delete files.
  • You need to test complex read/write interactions (e.g., renaming, concurrent writes).
  • You need advanced compositional features (Copy-on-Write, Caching, etc.).

Afero is fully compatible withio/fs. You can wrap any Afero filesystem to satisfy thefs.FS interface usingafero.NewIOFS:

import "io/fs"// Create an Afero filesystem (writable)var myAferoFs afero.Fs = afero.NewMemMapFs()// Convert it to a standard library fs.FS (read-only view)var myIoFs fs.FS = afero.NewIOFS(myAferoFs)

Third-Party Backends & Ecosystem

The Afero community has developed numerous backends and tools that extend the library's capabilities. Below are curated, well-maintained options organized by maturity and reliability.

Featured Community Backends

These are mature, reliable backends that we can confidently recommend for production use:

Amazon S3 -fclairamb/afero-s3

Production-ready S3 backend built on the official AWS SDK for Go.

import "github.com/fclairamb/afero-s3"s3fs := s3.NewFs(bucket, session)

MinIO -cpyun/afero-minio

MinIO object storage backend providing S3-compatible object storage with deduplication and optimization features.

import "github.com/cpyun/afero-minio"minioFs := miniofs.NewMinioFs(ctx, "minio://endpoint/bucket")

Community & Specialized Backends

Cloud Storage

• Google Drive -fclairamb/afero-gdrive
  Streaming support; no write-seeking or POSIX permissions; no files listing cache

• Dropbox -fclairamb/afero-dropbox
  Streaming support; no write-seeking or POSIX permissions

Version Control Systems

• Git Repositories -tobiash/go-gitfs
  Read-only filesystem abstraction for Git repositories. Works with bare repositories and provides filesystem view of any git reference. Uses go-git for repository access.

Container and Remote Systems

• Docker Containers -unmango/aferox
  Access Docker container filesystems as if they were local filesystems

• GitHub API -unmango/aferox
  Turn GitHub repositories, releases, and assets into browsable filesystems

FUSE Integration

• Generic FUSE -JakWai01/sile-fystem
  Mount any Afero filesystem as a FUSE filesystem, allowing any Afero backend to be used as a real mounted filesystem

Specialized Filesystems

• FAT32 Support -aligator/GoFAT
  Pure Go FAT filesystem implementation (currently read-only)

Interface Adapters & Utilities

Cross-Interface Compatibility:

• jfontan/go-billy-desfacer - Adapter between Afero and go-billy interfaces (for go-git compatibility)
• Maldris/go-billy-afero - Alternative wrapper for using Afero with go-billy
• c4milo/afero2billy - Another Afero to billy filesystem adapter

Working Directory Management:

• carolynvs/aferox - Working directory-aware filesystem wrapper

Advanced Filtering:

• unmango/aferox includes multiple specialized filesystems:
  • FilterFs - Predicate-based file filtering
  • IgnoreFs - .gitignore-aware filtering
  • WriterFs - Dump writes to io.Writer for debugging

Developer Tools & Utilities

nhatthm Utility Suite - Essential tools for Afero development:

• nhatthm/aferocopy - Copy files between any Afero filesystems
• nhatthm/aferomock - Mocking toolkit for testing
• nhatthm/aferoassert - Assertion helpers for filesystem testing

Ecosystem Showcase

Windows Virtual Drives -balazsgrill/potatodrive
Mount any Afero filesystem as a Windows drive letter. Brilliant demonstration of Afero's power!

Modern Asset Embedding (Go 1.16+)

Instead of third-party tools, use Go's native//go:embed with Afero:

import (    "embed"    "github.com/spf13/afero")//go:embed assets/*var assetsFS embed.FSfunc main() {    // Convert embedded files to Afero filesystem    fs := afero.FromIOFS(assetsFS)        // Use like any other Afero filesystem    content, _ := afero.ReadFile(fs, "assets/config.json")}

Contributing

We welcome contributions! The project is mature, but we are actively looking for contributors to help implement and stabilize network/cloud backends.

• 🔥Microsoft Azure Blob Storage
• 🔒Modern Encryption Backend - Built on secure, contemporary crypto (not legacy EncFS)
• 🐙Canonical go-git Adapter - Unified solution for Git integration
• 📡SSH/SCP Backend - Secure remote file operations
• Stabilization of existing experimental backends (GCS, SFTP)

To contribute:

1. Fork the repository
2. Create your feature branch (git checkout -b my-new-feature)
3. Commit your changes (git commit -am 'Add some feature')
4. Push to the branch (git push origin my-new-feature)
5. Create a new Pull Request

📄 License

Afero is released under the Apache 2.0 license. SeeLICENSE.txt for details.

🔗 Additional Resources

• 📖 Full API Documentation
• 🎯 Examples Repository
• 📋 Release Notes
• ❓ GitHub Discussions

Afero comes from the Latin roots Ad-Facere, meaning "to make" or "to do" - fitting for a library that empowers you to make and do amazing things with filesystems.

Constants¶

const BADFD =syscall.EBADFD

const FilePathSeparator =string(filepath.Separator)

Variables¶

var (ErrFileClosed        =errors.New("File is closed")ErrOutOfRange        =errors.New("out of range")ErrTooLarge          =errors.New("too large")ErrFileNotFound      =os.ErrNotExistErrFileExists        =os.ErrExistErrDestinationExists =os.ErrExist)

var ErrNoReadlink =errors.New("readlink not supported")

var ErrNoSymlink =errors.New("symlink not supported")

Functions¶

func DirExists(fsFs, pathstring) (bool,error)

func Exists(fsFs, pathstring) (bool,error)

func FileContainsAnyBytes(fsFs, filenamestring, subslices [][]byte) (bool,error)

func FileContainsBytes(fsFs, filenamestring, subslice []byte) (bool,error)

func FullBaseFsPath(basePathFs *BasePathFs, relativePathstring)string

func GetTempDir(fsFs, subPathstring)string

func Glob(fsFs, patternstring) (matches []string, errerror)

func IsDir(fsFs, pathstring) (bool,error)

func IsEmpty(fsFs, pathstring) (bool,error)

func NeuterAccents(sstring)string

func ReadAll(rio.Reader) ([]byte,error)

func ReadDir(fsFs, dirnamestring) ([]os.FileInfo,error)

func ReadFile(fsFs, filenamestring) ([]byte,error)

func SafeWriteReader(fsFs, pathstring, rio.Reader) (errerror)

func TempDir(fsFs, dir, prefixstring) (namestring, errerror)

func UnicodeSanitize(sstring)string

func Walk(fsFs, rootstring, walkFnfilepath.WalkFunc)error

func WriteFile(fsFs, filenamestring, data []byte, permos.FileMode)error

func WriteReader(fsFs, pathstring, rio.Reader) (errerror)

Types¶

type Afero struct {Fs}

func (aAfero) DirExists(pathstring) (bool,error)

func (aAfero) Exists(pathstring) (bool,error)

func (aAfero) FileContainsAnyBytes(filenamestring, subslices [][]byte) (bool,error)

func (aAfero) FileContainsBytes(filenamestring, subslice []byte) (bool,error)

func (aAfero) GetTempDir(subPathstring)string

func (aAfero) IsDir(pathstring) (bool,error)

func (aAfero) IsEmpty(pathstring) (bool,error)

func (aAfero) ReadDir(dirnamestring) ([]os.FileInfo,error)

func (aAfero) ReadFile(filenamestring) ([]byte,error)

func (aAfero) SafeWriteReader(pathstring, rio.Reader) (errerror)

func (aAfero) TempDir(dir, prefixstring) (namestring, errerror)

func (aAfero) TempFile(dir, patternstring) (fFile, errerror)

func (aAfero) Walk(rootstring, walkFnfilepath.WalkFunc)error

func (aAfero) WriteFile(filenamestring, data []byte, permos.FileMode)error

func (aAfero) WriteReader(pathstring, rio.Reader) (errerror)

type BasePathFile struct {File// contains filtered or unexported fields}

func (f *BasePathFile) Name()string

func (f *BasePathFile) ReadDir(nint) ([]fs.DirEntry,error)

type BasePathFs struct {// contains filtered or unexported fields}

func (b *BasePathFs) Chmod(namestring, modeos.FileMode) (errerror)

func (b *BasePathFs) Chown(namestring, uid, gidint) (errerror)

func (b *BasePathFs) Chtimes(namestring, atime, mtimetime.Time) (errerror)

func (b *BasePathFs) Create(namestring) (fFile, errerror)

func (b *BasePathFs) LstatIfPossible(namestring) (os.FileInfo,bool,error)

func (b *BasePathFs) Mkdir(namestring, modeos.FileMode) (errerror)

func (b *BasePathFs) MkdirAll(namestring, modeos.FileMode) (errerror)

func (b *BasePathFs) Name()string

func (b *BasePathFs) Open(namestring) (fFile, errerror)

func (b *BasePathFs) OpenFile(namestring, flagint, modeos.FileMode) (fFile, errerror)

func (b *BasePathFs) ReadlinkIfPossible(namestring) (string,error)

func (b *BasePathFs) RealPath(namestring) (pathstring, errerror)

func (b *BasePathFs) Remove(namestring) (errerror)

func (b *BasePathFs) RemoveAll(namestring) (errerror)

func (b *BasePathFs) Rename(oldname, newnamestring) (errerror)

func (b *BasePathFs) Stat(namestring) (fios.FileInfo, errerror)

func (b *BasePathFs) SymlinkIfPossible(oldname, newnamestring)error

type CacheOnReadFs struct {// contains filtered or unexported fields}

func (u *CacheOnReadFs) Chmod(namestring, modeos.FileMode)error

func (u *CacheOnReadFs) Chown(namestring, uid, gidint)error

func (u *CacheOnReadFs) Chtimes(namestring, atime, mtimetime.Time)error

func (u *CacheOnReadFs) Create(namestring) (File,error)

func (u *CacheOnReadFs) Mkdir(namestring, permos.FileMode)error

func (u *CacheOnReadFs) MkdirAll(namestring, permos.FileMode)error

func (u *CacheOnReadFs) Name()string

func (u *CacheOnReadFs) Open(namestring) (File,error)

func (u *CacheOnReadFs) OpenFile(namestring, flagint, permos.FileMode) (File,error)

func (u *CacheOnReadFs) Remove(namestring)error

func (u *CacheOnReadFs) RemoveAll(namestring)error

func (u *CacheOnReadFs) Rename(oldname, newnamestring)error

func (u *CacheOnReadFs) Stat(namestring) (os.FileInfo,error)

type CopyOnWriteFs struct {// contains filtered or unexported fields}

func (u *CopyOnWriteFs) Chmod(namestring, modeos.FileMode)error

func (u *CopyOnWriteFs) Chown(namestring, uid, gidint)error

func (u *CopyOnWriteFs) Chtimes(namestring, atime, mtimetime.Time)error

func (u *CopyOnWriteFs) Create(namestring) (File,error)

func (u *CopyOnWriteFs) LstatIfPossible(namestring) (os.FileInfo,bool,error)

func (u *CopyOnWriteFs) Mkdir(namestring, permos.FileMode)error

func (u *CopyOnWriteFs) MkdirAll(namestring, permos.FileMode)error

func (u *CopyOnWriteFs) Name()string

func (u *CopyOnWriteFs) Open(namestring) (File,error)

layer: doesn't exist, exists as a file, and exists as a directorybase:  doesn't exist, exists as a file, and exists as a directory

func (u *CopyOnWriteFs) OpenFile(namestring, flagint, permos.FileMode) (File,error)

func (u *CopyOnWriteFs) ReadlinkIfPossible(namestring) (string,error)

func (u *CopyOnWriteFs) Remove(namestring)error

func (u *CopyOnWriteFs) RemoveAll(namestring)error

func (u *CopyOnWriteFs) Rename(oldname, newnamestring)error

func (u *CopyOnWriteFs) Stat(namestring) (os.FileInfo,error)

func (u *CopyOnWriteFs) SymlinkIfPossible(oldname, newnamestring)error

type DirsMerger func(lofi, bofi []os.FileInfo) ([]os.FileInfo,error)

type File interface {io.Closerio.Readerio.ReaderAtio.Seekerio.Writerio.WriterAtName()stringReaddir(countint) ([]os.FileInfo,error)Readdirnames(nint) ([]string,error)Stat() (os.FileInfo,error)Sync()errorTruncate(sizeint64)errorWriteString(sstring) (retint, errerror)}

func TempFile(fsFs, dir, patternstring) (fFile, errerror)

type FromIOFS struct {fs.FS}

func (fFromIOFS) Chmod(namestring, modeos.FileMode)error

func (fFromIOFS) Chown(namestring, uid, gidint)error

func (fFromIOFS) Chtimes(namestring, atimetime.Time, mtimetime.Time)error

func (fFromIOFS) Create(namestring) (File,error)

func (fFromIOFS) Mkdir(namestring,permos.FileMode,)error

func (fFromIOFS) MkdirAll(pathstring, permos.FileMode)error

func (fFromIOFS) Name()string

func (fFromIOFS) Open(namestring) (File,error)

func (fFromIOFS) OpenFile(namestring, flagint, permos.FileMode) (File,error)

func (fFromIOFS) Remove(namestring)error

func (fFromIOFS) RemoveAll(pathstring)error

func (fFromIOFS) Rename(oldname, newnamestring)error

func (fFromIOFS) Stat(namestring) (os.FileInfo,error)

type Fs interface {// Create creates a file in the filesystem, returning the file and an// error, if any happens.Create(namestring) (File,error)// Mkdir creates a directory in the filesystem, return an error if any// happens.Mkdir(namestring, permos.FileMode)error// MkdirAll creates a directory path and all parents that does not exist// yet.MkdirAll(pathstring, permos.FileMode)error// Open opens a file, returning it or an error, if any happens.Open(namestring) (File,error)// OpenFile opens a file using the given flags and the given mode.OpenFile(namestring, flagint, permos.FileMode) (File,error)// Remove removes a file identified by name, returning an error, if any// happens.Remove(namestring)error// RemoveAll removes a directory path and any children it contains. It// does not fail if the path does not exist (return nil).RemoveAll(pathstring)error// Rename renames a file.Rename(oldname, newnamestring)error// Stat returns a FileInfo describing the named file, or an error, if any// happens.Stat(namestring) (os.FileInfo,error)// The name of this FileSystemName()string// Chmod changes the mode of the named file to mode.Chmod(namestring, modeos.FileMode)error// Chown changes the uid and gid of the named file.Chown(namestring, uid, gidint)error// Chtimes changes the access and modification times of the named fileChtimes(namestring, atimetime.Time, mtimetime.Time)error}

func NewBasePathFs(sourceFs, pathstring)Fs

func NewCacheOnReadFs(baseFs, layerFs, cacheTimetime.Duration)Fs

func NewCopyOnWriteFs(baseFs, layerFs)Fs

func NewMemMapFs()Fs

func NewOsFs()Fs

func NewReadOnlyFs(sourceFs)Fs

func NewRegexpFs(sourceFs, re *regexp.Regexp)Fs

type HttpFs struct {// contains filtered or unexported fields}

func NewHttpFs(sourceFs) *HttpFs

func (hHttpFs) Chmod(namestring, modeos.FileMode)error

func (hHttpFs) Chown(namestring, uid, gidint)error

func (hHttpFs) Chtimes(namestring, atimetime.Time, mtimetime.Time)error

func (hHttpFs) Create(namestring) (File,error)

func (hHttpFs) Dir(sstring) *httpDir

func (hHttpFs) Mkdir(namestring, permos.FileMode)error

func (hHttpFs) MkdirAll(pathstring, permos.FileMode)error

func (hHttpFs) Name()string

func (hHttpFs) Open(namestring) (http.File,error)

func (hHttpFs) OpenFile(namestring, flagint, permos.FileMode) (File,error)

func (hHttpFs) Remove(namestring)error

func (hHttpFs) RemoveAll(pathstring)error

func (hHttpFs) Rename(oldname, newnamestring)error

func (hHttpFs) Stat(namestring) (os.FileInfo,error)

type IOFS struct {Fs}

func NewIOFS(fsFs)IOFS

func (iofsIOFS) Glob(patternstring) ([]string,error)

func (iofsIOFS) Open(namestring) (fs.File,error)

func (iofsIOFS) ReadDir(namestring) ([]fs.DirEntry,error)

func (iofsIOFS) ReadFile(namestring) ([]byte,error)

func (iofsIOFS) Sub(dirstring) (fs.FS,error)

type LinkReader interface {ReadlinkIfPossible(namestring) (string,error)}

type Linker interface {SymlinkIfPossible(oldname, newnamestring)error}

type Lstater interface {LstatIfPossible(namestring) (os.FileInfo,bool,error)}

type MemMapFs struct {// contains filtered or unexported fields}

func (m *MemMapFs) Chmod(namestring, modeos.FileMode)error

func (m *MemMapFs) Chown(namestring, uid, gidint)error

func (m *MemMapFs) Chtimes(namestring, atimetime.Time, mtimetime.Time)error

func (m *MemMapFs) Create(namestring) (File,error)

func (m *MemMapFs) List()

func (m *MemMapFs) LstatIfPossible(namestring) (os.FileInfo,bool,error)

func (m *MemMapFs) Mkdir(namestring, permos.FileMode)error

func (m *MemMapFs) MkdirAll(pathstring, permos.FileMode)error

func (*MemMapFs) Name()string

func (m *MemMapFs) Open(namestring) (File,error)

func (m *MemMapFs) OpenFile(namestring, flagint, permos.FileMode) (File,error)

func (m *MemMapFs) Remove(namestring)error

func (m *MemMapFs) RemoveAll(pathstring)error

func (m *MemMapFs) Rename(oldname, newnamestring)error

func (m *MemMapFs) Stat(namestring) (os.FileInfo,error)

type OsFs struct{}

func (OsFs) Chmod(namestring, modeos.FileMode)error

func (OsFs) Chown(namestring, uid, gidint)error

func (OsFs) Chtimes(namestring, atimetime.Time, mtimetime.Time)error

func (OsFs) Create(namestring) (File,error)

func (OsFs) LstatIfPossible(namestring) (os.FileInfo,bool,error)

func (OsFs) Mkdir(namestring, permos.FileMode)error

func (OsFs) MkdirAll(pathstring, permos.FileMode)error

func (OsFs) Name()string

func (OsFs) Open(namestring) (File,error)

func (OsFs) OpenFile(namestring, flagint, permos.FileMode) (File,error)

func (OsFs) ReadlinkIfPossible(namestring) (string,error)

func (OsFs) Remove(namestring)error

func (OsFs) RemoveAll(pathstring)error

func (OsFs) Rename(oldname, newnamestring)error

func (OsFs) Stat(namestring) (os.FileInfo,error)

func (OsFs) SymlinkIfPossible(oldname, newnamestring)error

type ReadOnlyFs struct {// contains filtered or unexported fields}

func (r *ReadOnlyFs) Chmod(nstring, mos.FileMode)error

func (r *ReadOnlyFs) Chown(nstring, uid, gidint)error

func (r *ReadOnlyFs) Chtimes(nstring, a, mtime.Time)error

func (r *ReadOnlyFs) Create(nstring) (File,error)

func (r *ReadOnlyFs) LstatIfPossible(namestring) (os.FileInfo,bool,error)

func (r *ReadOnlyFs) Mkdir(nstring, pos.FileMode)error

func (r *ReadOnlyFs) MkdirAll(nstring, pos.FileMode)error

func (r *ReadOnlyFs) Name()string

func (r *ReadOnlyFs) Open(nstring) (File,error)

func (r *ReadOnlyFs) OpenFile(namestring, flagint, permos.FileMode) (File,error)

func (r *ReadOnlyFs) ReadDir(namestring) ([]os.FileInfo,error)

func (r *ReadOnlyFs) ReadlinkIfPossible(namestring) (string,error)

func (r *ReadOnlyFs) Remove(nstring)error

func (r *ReadOnlyFs) RemoveAll(pstring)error

func (r *ReadOnlyFs) Rename(o, nstring)error

func (r *ReadOnlyFs) Stat(namestring) (os.FileInfo,error)

func (r *ReadOnlyFs) SymlinkIfPossible(oldname, newnamestring)error

type RegexpFile struct {// contains filtered or unexported fields}

func (f *RegexpFile) Close()error

func (f *RegexpFile) Name()string

func (f *RegexpFile) Read(s []byte) (int,error)

func (f *RegexpFile) ReadAt(s []byte, oint64) (int,error)

func (f *RegexpFile) Readdir(cint) (fi []os.FileInfo, errerror)

func (f *RegexpFile) Readdirnames(cint) (n []string, errerror)

func (f *RegexpFile) Seek(oint64, wint) (int64,error)

func (f *RegexpFile) Stat() (os.FileInfo,error)

func (f *RegexpFile) Sync()error

func (f *RegexpFile) Truncate(sint64)error

func (f *RegexpFile) Write(s []byte) (int,error)

func (f *RegexpFile) WriteAt(s []byte, oint64) (int,error)

func (f *RegexpFile) WriteString(sstring) (int,error)

type RegexpFs struct {// contains filtered or unexported fields}

func (r *RegexpFs) Chmod(namestring, modeos.FileMode)error

func (r *RegexpFs) Chown(namestring, uid, gidint)error

func (r *RegexpFs) Chtimes(namestring, a, mtime.Time)error

func (r *RegexpFs) Create(namestring) (File,error)

func (r *RegexpFs) Mkdir(nstring, pos.FileMode)error

func (r *RegexpFs) MkdirAll(nstring, pos.FileMode)error

func (r *RegexpFs) Name()string

func (r *RegexpFs) Open(namestring) (File,error)

func (r *RegexpFs) OpenFile(namestring, flagint, permos.FileMode) (File,error)

func (r *RegexpFs) Remove(namestring)error

func (r *RegexpFs) RemoveAll(pstring)error

func (r *RegexpFs) Rename(oldname, newnamestring)error

func (r *RegexpFs) Stat(namestring) (os.FileInfo,error)

type Symlinker interface {LstaterLinkerLinkReader}

type UnionFile struct {BaseFileLayerFileMergerDirsMerger// contains filtered or unexported fields}

func (f *UnionFile) Close()error

func (f *UnionFile) Name()string

func (f *UnionFile) Read(s []byte) (int,error)

func (f *UnionFile) ReadAt(s []byte, oint64) (int,error)

func (f *UnionFile) Readdir(cint) (ofi []os.FileInfo, errerror)

func (f *UnionFile) Readdirnames(cint) ([]string,error)

func (f *UnionFile) Seek(oint64, wint) (posint64, errerror)

func (f *UnionFile) Stat() (os.FileInfo,error)

func (f *UnionFile) Sync() (errerror)

func (f *UnionFile) Truncate(sint64) (errerror)

func (f *UnionFile) Write(s []byte) (nint, errerror)

func (f *UnionFile) WriteAt(s []byte, oint64) (nint, errerror)

func (f *UnionFile) WriteString(sstring) (nint, errerror)