This demonstrates how to build a file system in memory. Theread/write logic for the file is provided by the MemRegularFile type.

package mainimport ("context""io/ioutil""log""path/filepath""strings""syscall""github.com/hanwen/go-fuse/v2/fs""github.com/hanwen/go-fuse/v2/fuse")// files contains the files we will expose as a file systemvar files = map[string]string{"file":              "content","subdir/other-file": "other-content",}// inMemoryFS is the root of the treetype inMemoryFS struct {fs.Inode}// Ensure that we implement NodeOnAddervar _ = (fs.NodeOnAdder)((*inMemoryFS)(nil))// OnAdd is called on mounting the file system. Use it to populate// the file system tree.func (root *inMemoryFS) OnAdd(ctx context.Context) {for name, content := range files {dir, base := filepath.Split(name)p := &root.Inode// Add directories leading up to the file.for _, component := range strings.Split(dir, "/") {if len(component) == 0 {continue}ch := p.GetChild(component)if ch == nil {// Create a directorych = p.NewPersistentInode(ctx, &fs.Inode{},fs.StableAttr{Mode: syscall.S_IFDIR})// Add itp.AddChild(component, ch, true)}p = ch}// Make a file out of the content bytes. This type// provides the open/read/flush methods.embedder := &fs.MemRegularFile{Data: []byte(content),}// Create the file. The Inode must be persistent,// because its life time is not under control of the// kernel.child := p.NewPersistentInode(ctx, embedder, fs.StableAttr{})// And add itp.AddChild(base, child, true)}}// This demonstrates how to build a file system in memory. The// read/write logic for the file is provided by the MemRegularFile type.func main() {// This is where we'll mount the FSmntDir, _ := ioutil.TempDir("", "")root := &inMemoryFS{}server, err := fs.Mount(mntDir, root, &fs.Options{MountOptions: fuse.MountOptions{Debug: true},})if err != nil {log.Panic(err)}log.Printf("Mounted on %s", mntDir)log.Printf("Unmount by calling 'fusermount -u %s'", mntDir)// Wait until unmount before exitingserver.Wait()}

ExampleDirectIO shows how to create a file whose contents change onevery read.

package mainimport ("context""fmt""log""syscall""time""github.com/hanwen/go-fuse/v2/fs""github.com/hanwen/go-fuse/v2/fuse")// bytesFileHandle is a file handle that carries separate content for// each Open calltype bytesFileHandle struct {content []byte}// bytesFileHandle allows readsvar _ = (fs.FileReader)((*bytesFileHandle)(nil))func (fh *bytesFileHandle) Read(ctx context.Context, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {end := off + int64(len(dest))if end > int64(len(fh.content)) {end = int64(len(fh.content))}// We could copy to the `dest` buffer, but since we have a// []byte already, return that.return fuse.ReadResultData(fh.content[off:end]), 0}// timeFile is a file that contains the wall clock time as ASCII.type timeFile struct {fs.Inode}// timeFile implements Openvar _ = (fs.NodeOpener)((*timeFile)(nil))func (f *timeFile) Open(ctx context.Context, openFlags uint32) (fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {// disallow writesif fuseFlags&(syscall.O_RDWR|syscall.O_WRONLY) != 0 {return nil, 0, syscall.EROFS}// capture open timenow := time.Now().Format(time.StampNano) + "\n"fh = &bytesFileHandle{content: []byte(now),}// Return FOPEN_DIRECT_IO so content is not cached.return fh, fuse.FOPEN_DIRECT_IO, 0}// ExampleDirectIO shows how to create a file whose contents change on// every read.func main() {mntDir := "/tmp/x"root := &fs.Inode{}// Mount the file systemserver, err := fs.Mount(mntDir, root, &fs.Options{MountOptions: fuse.MountOptions{Debug: false},// Setup the clock file.OnAdd: func(ctx context.Context) {ch := root.NewPersistentInode(ctx,&timeFile{},fs.StableAttr{Mode: syscall.S_IFREG})root.AddChild("clock", ch, true)},})if err != nil {log.Fatal(err)}fmt.Printf("cat %s/clock to see the time\n", mntDir)fmt.Printf("Unmount by calling 'fusermount -u %s'\n", mntDir)// Serve the file system, until unmounted by calling fusermount -userver.Wait()}

ExampleDynamic is a whimsical example of a dynamically discoveredfile system.

package mainimport ("context""log""os""strconv""syscall""github.com/hanwen/go-fuse/v2/fs""github.com/hanwen/go-fuse/v2/fuse")// numberNode is a filesystem node representing an integer. Prime// numbers are regular files, while composite numbers are directories// containing all smaller numbers, eg.////$ ls -F  /tmp/x/6//2  3  4/  5//// the file system nodes are deduplicated using inode numbers. The// number 2 appears in many directories, but it is actually the represented// by the same numberNode{} object, with inode number 2.////$ ls -i1  /tmp/x/2  /tmp/x/8/6/4/2//2 /tmp/x/2//2 /tmp/x/8/6/4/2type numberNode struct {// Must embed an Inode for the struct to work as a node.fs.Inode// num is the integer represented in this file/directorynum int}// isPrime returns whether n is primefunc isPrime(n int) bool {for i := 2; i*i <= n; i++ {if n%i == 0 {return false}}return true}func numberToMode(n int) uint32 {// prime numbers are filesif isPrime(n) {return fuse.S_IFREG}// composite numbers are directoriesreturn fuse.S_IFDIR}// Ensure we are implementing the NodeReaddirer interfacevar _ = (fs.NodeReaddirer)((*numberNode)(nil))// Readdir is part of the NodeReaddirer interfacefunc (n *numberNode) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {r := make([]fuse.DirEntry, 0, n.num)for i := 2; i < n.num; i++ {d := fuse.DirEntry{Name: strconv.Itoa(i),Ino:  uint64(i),Mode: numberToMode(i),}r = append(r, d)}return fs.NewListDirStream(r), 0}// Ensure we are implementing the NodeLookuper interfacevar _ = (fs.NodeLookuper)((*numberNode)(nil))// Lookup is part of the NodeLookuper interfacefunc (n *numberNode) Lookup(ctx context.Context, name string, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {i, err := strconv.Atoi(name)if err != nil {return nil, syscall.ENOENT}if i >= n.num || i <= 1 {return nil, syscall.ENOENT}stable := fs.StableAttr{Mode: numberToMode(i),// The child inode is identified by its Inode number.// If multiple concurrent lookups try to find the same// inode, they are deduplicated on this key.Ino: uint64(i),}operations := &numberNode{num: i}// The NewInode call wraps the `operations` object into an Inode.child := n.NewInode(ctx, operations, stable)// In case of concurrent lookup requests, it can happen that operations !=// child.Operations().return child, 0}// ExampleDynamic is a whimsical example of a dynamically discovered// file system.func main() {// This is where we'll mount the FSmntDir := "/tmp/x"os.Mkdir(mntDir, 0755)root := &numberNode{num: 10}server, err := fs.Mount(mntDir, root, &fs.Options{MountOptions: fuse.MountOptions{// Set to true to see how the file system works.Debug: true,},})if err != nil {log.Panic(err)}log.Printf("Mounted on %s", mntDir)log.Printf("Unmount by calling 'fusermount -u %s'", mntDir)// Wait until unmount before exitingserver.Wait()}

ExampleHandleLess shows how to create a file that can be read or writtenby implementing Read/Write directly on the nodes.

package mainimport ("context""fmt""log""sync""syscall""time""github.com/hanwen/go-fuse/v2/fs""github.com/hanwen/go-fuse/v2/fuse")// bytesNode is a file that can be read and writtentype bytesNode struct {fs.Inode// When file systems are mutable, all access must use// synchronization.mu      sync.Mutexcontent []bytemtime   time.Time}// Implement GetAttr to provide size and mtimevar _ = (fs.NodeGetattrer)((*bytesNode)(nil))func (bn *bytesNode) Getattr(ctx context.Context, fh fs.FileHandle, out *fuse.AttrOut) syscall.Errno {bn.mu.Lock()defer bn.mu.Unlock()bn.getattr(out)return 0}func (bn *bytesNode) getattr(out *fuse.AttrOut) {out.Size = uint64(len(bn.content))out.SetTimes(nil, &bn.mtime, nil)}func (bn *bytesNode) resize(sz uint64) {if sz > uint64(cap(bn.content)) {n := make([]byte, sz)copy(n, bn.content)bn.content = n} else {bn.content = bn.content[:sz]}bn.mtime = time.Now()}// Implement Setattr to support truncationvar _ = (fs.NodeSetattrer)((*bytesNode)(nil))func (bn *bytesNode) Setattr(ctx context.Context, fh fs.FileHandle, in *fuse.SetAttrIn, out *fuse.AttrOut) syscall.Errno {bn.mu.Lock()defer bn.mu.Unlock()if sz, ok := in.GetSize(); ok {bn.resize(sz)}bn.getattr(out)return 0}// Implement handleless read.var _ = (fs.NodeReader)((*bytesNode)(nil))func (bn *bytesNode) Read(ctx context.Context, fh fs.FileHandle, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {bn.mu.Lock()defer bn.mu.Unlock()end := off + int64(len(dest))if end > int64(len(bn.content)) {end = int64(len(bn.content))}// We could copy to the `dest` buffer, but since we have a// []byte already, return that.return fuse.ReadResultData(bn.content[off:end]), 0}// Implement handleless write.var _ = (fs.NodeWriter)((*bytesNode)(nil))func (bn *bytesNode) Write(ctx context.Context, fh fs.FileHandle, buf []byte, off int64) (uint32, syscall.Errno) {bn.mu.Lock()defer bn.mu.Unlock()sz := int64(len(buf))if off+sz > int64(len(bn.content)) {bn.resize(uint64(off + sz))}copy(bn.content[off:], buf)bn.mtime = time.Now()return uint32(sz), 0}// Implement (handleless) Openvar _ = (fs.NodeOpener)((*bytesNode)(nil))func (f *bytesNode) Open(ctx context.Context, openFlags uint32) (fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {return nil, 0, 0}// ExampleHandleLess shows how to create a file that can be read or written// by implementing Read/Write directly on the nodes.func main() {mntDir := "/tmp/x"root := &fs.Inode{}// Mount the file systemserver, err := fs.Mount(mntDir, root, &fs.Options{MountOptions: fuse.MountOptions{Debug: false},// Setup the file.OnAdd: func(ctx context.Context) {ch := root.NewPersistentInode(ctx,&bytesNode{},fs.StableAttr{Mode: syscall.S_IFREG,// Make debug output readable.Ino: 2,})root.AddChild("bytes", ch, true)},})if err != nil {log.Fatal(err)}fmt.Printf(`Try:  cd %s  ls -l bytes  echo hello > bytes  ls -l bytes  cat bytes  cd -`, mntDir)fmt.Printf("Unmount by calling 'fusermount -u %s'\n", mntDir)// Serve the file system, until unmounted by calling fusermount -userver.Wait()}

ExampleMount shows how to create a loopback file system, andmounting it onto a directory

package mainimport ("fmt""io/ioutil""log""os""github.com/hanwen/go-fuse/v2/fs""github.com/hanwen/go-fuse/v2/fuse")func main() {mntDir, _ := ioutil.TempDir("", "")home := os.Getenv("HOME")// Make $HOME available on a mount dir under /tmp/ . Caution:// write operations are also mirrored.root, err := fs.NewLoopbackRoot(home)if err != nil {log.Fatal(err)}// Mount the file systemserver, err := fs.Mount(mntDir, root, &fs.Options{MountOptions: fuse.MountOptions{Debug: true},})if err != nil {log.Fatal(err)}fmt.Printf("Mounted %s as loopback on %s\n", home, mntDir)fmt.Printf("\n\nCAUTION:\nwrite operations on %s will also affect $HOME (%s)\n\n", mntDir, home)fmt.Printf("Unmount by calling 'fusermount -u %s'\n", mntDir)// Serve the file system, until unmounted by calling fusermount -userver.Wait()}

ExampleZipFS shows an in-memory, static file system

package mainimport ("archive/zip""context""flag""fmt""io/ioutil""log""os""path/filepath""strings""sync""syscall""github.com/hanwen/go-fuse/v2/fs""github.com/hanwen/go-fuse/v2/fuse")// zipFile is a file read from a zip archive.type zipFile struct {fs.Inodefile *zip.Filemu   sync.Mutexdata []byte}// We decompress the file on demand in Openvar _ = (fs.NodeOpener)((*zipFile)(nil))// Getattr sets the minimum, which is the size. A more full-featured// FS would also set timestamps and permissions.var _ = (fs.NodeGetattrer)((*zipFile)(nil))func (zf *zipFile) Getattr(ctx context.Context, f fs.FileHandle, out *fuse.AttrOut) syscall.Errno {out.Size = zf.file.UncompressedSize64return 0}// Open lazily unpacks zip datafunc (zf *zipFile) Open(ctx context.Context, flags uint32) (fs.FileHandle, uint32, syscall.Errno) {zf.mu.Lock()defer zf.mu.Unlock()if zf.data == nil {rc, err := zf.file.Open()if err != nil {return nil, 0, syscall.EIO}content, err := ioutil.ReadAll(rc)if err != nil {return nil, 0, syscall.EIO}zf.data = content}// We don't return a filehandle since we don't really need// one.  The file content is immutable, so hint the kernel to// cache the data.return nil, fuse.FOPEN_KEEP_CACHE, fs.OK}// Read simply returns the data that was already unpacked in the Open callfunc (zf *zipFile) Read(ctx context.Context, f fs.FileHandle, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {end := int(off) + len(dest)if end > len(zf.data) {end = len(zf.data)}return fuse.ReadResultData(zf.data[off:end]), fs.OK}// zipRoot is the root of the Zip filesystem. Its only functionality// is populating the filesystem.type zipRoot struct {fs.Inodezr *zip.Reader}// The root populates the tree in its OnAdd methodvar _ = (fs.NodeOnAdder)((*zipRoot)(nil))func (zr *zipRoot) OnAdd(ctx context.Context) {// OnAdd is called once we are attached to an Inode. We can// then construct a tree.  We construct the entire tree, and// we don't want parts of the tree to disappear when the// kernel is short on memory, so we use persistent inodes.for _, f := range zr.zr.File {dir, base := filepath.Split(f.Name)p := &zr.Inodefor _, component := range strings.Split(dir, "/") {if len(component) == 0 {continue}ch := p.GetChild(component)if ch == nil {ch = p.NewPersistentInode(ctx, &fs.Inode{},fs.StableAttr{Mode: fuse.S_IFDIR})p.AddChild(component, ch, true)}p = ch}ch := p.NewPersistentInode(ctx, &zipFile{file: f}, fs.StableAttr{})p.AddChild(base, ch, true)}}// ExampleZipFS shows an in-memory, static file systemfunc main() {flag.Parse()if len(flag.Args()) != 1 {log.Fatal("usage: zipmount ZIP-FILE")}zfile, err := zip.OpenReader(flag.Arg(0))if err != nil {log.Fatal(err)}root := &zipRoot{zr: &zfile.Reader}mnt := "/tmp/x"os.Mkdir(mnt, 0755)server, err := fs.Mount(mnt, root, nil)if err != nil {log.Fatal(err)}fmt.Println("zip file mounted")fmt.Printf("to unmount: fusermount -u %s\n", mnt)server.Wait()}