lib9p

fs.go (5381B)

---

 package testfs
 
 import (
 	"bytes"
 	"fmt"
 	"io/fs"
 	"strings"
 
 	"git.mtkn.jp/lib9p"
 )
 
 type File struct {
 	// Fsys is the FS this File belongs to.
 	Fsys *FS
 	// Parent is the parent directory this File located at.
 	Parent *File
 	// Children is the child files this File has.
 	// It is nil if this File is not a directory
 	Children []*File
 	// Content is the content of this File.
 	// It is nil if this File is a directory
 	Content []byte
 	// Reader is used if this File is not a directory and
 	// when this File is read.
 	// It contains Content.
 	Reader *bytes.Reader
 	// St is the Stat of this File.
 	St lib9p.Stat
 }
 
 func (f *File) Stat() (*lib9p.FileInfo, error) {
 	return &lib9p.FileInfo{Stat: f.St}, nil
 }
 
 func (f *File) Close() error {
 	f.Reader = nil
 	return nil
 }
 
 func (f *File) Read(b []byte) (int, error) {
 	if f.Fsys.Slow {
 		f.Fsys.Waitc <- struct{}{}
 		<-f.Fsys.Waitc
 	}
 	return f.Reader.Read(b)
 }
 
 func (f *File) ReadAt(b []byte, off int64) (n int, err error) {
 	if f.Fsys.Slow {
 		f.Fsys.Waitc <- struct{}{}
 		<-f.Fsys.Waitc
 	}
 	return f.Reader.ReadAt(b, off)
 }
 
 func (f *File) ReadDir(n int) ([]fs.DirEntry, error) {
 	de := make([]fs.DirEntry, len(f.Children))
 	for i, c := range f.Children {
 		info, _ := c.Stat()
 		de[i] = info
 	}
 	return de, nil
 }
 
 func (f *File) WriteAt(p []byte, off int64) (int, error) {
 	if f.Fsys.Slow {
 		f.Fsys.Waitc <- struct{}{}
 	}
 	if f.Reader == nil {
 		return 0, fmt.Errorf("not open")
 	}
 	if off < 0 || off > int64(len(f.Content)) {
 		return 0, fmt.Errorf("bad offset")
 	}
 	if off+int64(len(p)) > int64(len(f.Content)) {
 		newcon := make([]byte, off+int64(len(p)))
 		copy(newcon, f.Content)
 		f.Content = newcon
 	}
 	copy(f.Content[off:], p)
 	f.Reader.Reset(f.Content)
 	if f.Fsys.Slow {
 		<-f.Fsys.Waitc
 	}
 	return len(p), nil
 }
 
 type FS struct {
 	// Root is the root File of this file system.
 	Root *File
 	// If Slow is true, each function on files of this FS waits for
 	// something arrives on Waitc.
 	Slow bool
 	// Waitc is used to wait some timing to emulate slow response.
 	Waitc chan struct{}
 	// groups holds the information of groups and it leader and members.
 	groups map[string]group
 }
 
 type group struct {
 	leader  string
 	members map[string]bool
 }
 
 func (fs *FS) OpenFile(path string, omode lib9p.OpenMode) (lib9p.File, error) {
 	wnames := strings.Split(path, "/")
 	f, err := fs.Walk(wnames)
 	if err != nil {
 		return nil, fmt.Errorf("walk: %v", err)
 	}
 	f.Reader = bytes.NewReader(f.Content)
 	return f, nil
 }
 
 func (fs *FS) IsGroupLeader(gid, uid string) bool {
 	g, ok := fs.groups[gid]
 	if !ok {
 		return false
 	}
 	return g.leader == uid
 }
 
 func (fs *FS) IsGroupMember(gid, uid string) bool {
 	g, ok := fs.groups[gid]
 	if !ok {
 		return false
 	}
 	return g.members[uid]
 }
 
 func (fs *FS) Walk(wnames []string) (*File, error) {
 	if len(wnames) == 1 && (wnames[0] == "." || wnames[0] == "") {
 		return fs.Root, nil
 	}
 	cwd := fs.Root
 L:
 	for i, name := range wnames {
 		for _, child := range cwd.Children {
 			if child.St.Name == name {
 				cwd = child
 				continue L
 			}
 		}
 		return nil, fmt.Errorf("%s not found", strings.Join(wnames[:i+1], "/"))
 	}
 	return cwd, nil
 }
 
 func (fs *FS) WalkPath(pathname string) (*File, error) {
 	wnames := strings.Split(pathname, "/")
 	return fs.Walk(wnames)
 }
 
 var Fsys *FS
 
 func init() {
 	Fsys = &FS{
 		Root: &File{
 			St: lib9p.Stat{
 				Qid:  lib9p.Qid{Path: 0, Type: lib9p.QTDIR},
 				Mode: lib9p.FileMode(fs.ModeDir | 0755),
 				Name: "root",
 				Uid:  "glenda",
 				Gid:  "glenda",
 				Muid: "glenda",
 			},
 			Children: []*File{
 				&File{
 					Content: []byte("a\n"),
 					St: lib9p.Stat{
 						Qid:  lib9p.Qid{Path: 1, Type: lib9p.QTFILE},
 						Mode: lib9p.FileMode(0644),
 						Name: "a",
 						Uid:  "glenda",
 						Gid:  "glenda",
 						Muid: "glenda",
 					},
 				},
 				&File{
 					Content: []byte("b\n"),
 					St: lib9p.Stat{
 						Qid:  lib9p.Qid{Path: 2, Type: lib9p.QTFILE},
 						Mode: lib9p.FileMode(0600),
 						Name: "b",
 						Uid:  "ken",
 						Gid:  "ken",
 						Muid: "ken",
 					},
 				},
 				&File{
 					St: lib9p.Stat{
 						Qid:  lib9p.Qid{Path: 3, Type: lib9p.QTDIR},
 						Mode: lib9p.FileMode(fs.ModeDir | 0755),
 						Name: "dir",
 						Uid:  "rob",
 						Gid:  "rob",
 						Muid: "rob",
 					},
 					Children: []*File{
 						&File{
 							Content: []byte("unko\n"),
 							St: lib9p.Stat{
 								Qid:  lib9p.Qid{Path: 4, Type: lib9p.QTFILE},
 								Mode: lib9p.FileMode(0666),
 								Name: "file",
 								Uid:  "brian",
 								Gid:  "brian",
 								Muid: "dennis",
 							},
 						},
 					},
 				},
 			},
 		},
 		Waitc: make(chan struct{}),
 		groups: map[string]group{
 			"bell": group{
 				leader: "glenda",
 				members: map[string]bool{
 					"glenda": true,
 					"ken":    true,
 					"dennis": true,
 					"brian":  true,
 					"rob":    true,
 				},
 			},
 			"kessoku": group{
 				leader: "ijichi",
 				members: map[string]bool{
 					"ijichi": true,
 					"yamada": true,
 					"gotoh":  true,
 					"kita":   true,
 				},
 			},
 		},
 	}
 	SetFsysAndParent(Fsys, nil)
 }
 
 // SetFsysAndParent sets file.fsys and file.parent for every file in the fsys.
 // Pass nil as file to setup entire file system.
 func SetFsysAndParent(fsys *FS, file *File) {
 	if file == nil {
 		file = fsys.Root
 		file.Parent = fsys.Root
 		file.Fsys = fsys
 	}
 	for _, child := range file.Children {
 		child.Parent = file
 		child.Fsys = fsys
 		SetFsysAndParent(fsys, child)
 	}
 }