spf13/afero
Afero
Afero is a Go library that provides a unified filesystem abstraction, allowing applications to interact with local disk, in-memory storage, cloud services, archives, and remote systems through a single, consistent interface. At its core, it defines a standard interface that all filesystem backends implement, enabling developers to swap storage implementations without changing application code.
The library distinguishes itself through its composable architecture, which includes layered filesystem composition for creating cached, sandboxed, or restricted storage views. It offers a copy-on-write overlay that layers writable in-memory storage over a read-only base, a base path restriction layer that limits operations to a specified subdirectory, and the ability to mount any filesystem backend as a real operating system directory via FUSE. Afero also supports reading compressed archives like ZIP and TAR as navigable filesystems without extraction, accessing cloud storage backends such as S3, GCS, and MinIO, and connecting to remote systems over SFTP.
Additional capabilities include an in-memory filesystem for fast, isolated unit testing without disk I/O, embedded asset management for reading files compiled into Go binaries using Go 1.16+, and read caching that stores data from slow backends into a fast memory layer. The library also provides HTTP file serving from any underlying filesystem backend.
Features
- Filesystem Abstractions - Provides a unified interface for local, memory, cloud, and archive filesystems behind a single Go API.
- In-Memory Filesystem Test Runners - Runs fast, isolated unit tests using a concurrent-safe in-memory filesystem that avoids physical disk access.
- In-Memory Filesystems - Provides a fully functional filesystem stored entirely in RAM with concurrent access support.
- Multi-Backend Storage Management - Provides a common API for disk, S3, SFTP, ZIP, and in-memory storage backends through a unified adapter.
- Archive-as-Filesystem Readers - Exposes compressed archive contents as navigable filesystems without requiring extraction to disk.
- Layered Filesystems - Stacks multiple filesystem implementations on top of each other to create combined behaviors like caching or sandboxing.
- Composable Layer Stacks - Provides a composable architecture for stacking filesystem layers to create cached, sandboxed, or restricted storage views.
- Zip Archive Access - Opens ZIP or TAR archives and reads their contents directly without extracting them to disk.
- In-Memory Overlay Filesystems - Combines a writable in-memory layer over a read-only base filesystem to isolate modifications.
- Filesystem Root Restrictions - Wraps any filesystem to transparently prefix all paths, preventing access outside a specified root.
- Unified Filesystem Interfaces - Uses a single API to interact with local disk, memory, archives, and network storage.
- Filesystem Backend Swappers - Ships an abstraction layer that lets Go applications swap filesystem backends without changing application code.
- Concurrent-Safe Filesystem Simulators - Provides a concurrent-safe in-memory filesystem for fast, isolated unit tests that avoid physical disk access.
- Filesystem-Backed - Serves files from any filesystem backend through a standard HTTP file server.
- Read-Through Memory Caches - Implements read caching that stores data from slow remote or network filesystems into a fast memory layer on first read.
- Embedded Asset Readers - Read embedded files from a Go binary using the same interface as any other filesystem.
- SFTP Client Libraries - Interacts with remote filesystems over the SFTP protocol using the same API as local storage.
- Cloud Storage Connectors - Connects to cloud storage services like S3, GCS, or MinIO through a single filesystem interface.
- Filesystem Protocol Remote Access - Interacts with remote systems over SFTP or other network protocols using the same API as local storage.
- FUSE-Based Filesystem Mounts - Exposes any filesystem backend as a real mounted directory on the operating system via FUSE.
- FUSE Filesystem Exporters - Makes any filesystem backend available as a real mounted directory on the operating system via FUSE.
- In-Memory Overlay Layers - Layers a writable in-memory overlay over a read-only base so modifications are isolated from the original filesystem.
- Binary Asset Embedding - Reads embedded files from a Go binary using the same interface as any other filesystem.
- Path Access Restrictions - Limits all filesystem operations to a specific subdirectory, preventing access to parent directories.
- File Handling - FileSystem abstraction system for Go.
- File Management - Abstraction layer for file systems.
- File Storage Systems - File system abstraction layer.
- File Systems - File system abstraction library for Go applications.
- File Processing - File system abstraction framework.
Star history
How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.
