// Copyright © 2014 Steve Francia <spf@spf13.com>. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package afero import ( "fmt" "log" "os" "path/filepath" "strings" "sync" "time" "github.com/spf13/afero/mem" ) type MemMapFs struct { mu sync.RWMutex data map[string]*mem.FileData init sync.Once } func NewMemMapFs() Fs { return &MemMapFs{} } func (m *MemMapFs) getData() map[string]*mem.FileData { m.init.Do(func() { m.data = make(map[string]*mem.FileData) // Root should always exist, right? // TODO: what about windows? m.data[FilePathSeparator] = mem.CreateDir(FilePathSeparator) }) return m.data } func (*MemMapFs) Name() string { return "MemMapFS" } func (m *MemMapFs) Create(name string) (File, error) { name = normalizePath(name) m.mu.Lock() file := mem.CreateFile(name) m.getData()[name] = file m.registerWithParent(file) m.mu.Unlock() return mem.NewFileHandle(file), nil } func (m *MemMapFs) unRegisterWithParent(fileName string) error { f, err := m.lockfreeOpen(fileName) if err != nil { return err } parent := m.findParent(f) if parent == nil { log.Panic("parent of ", f.Name(), " is nil") } parent.Lock() mem.RemoveFromMemDir(parent, f) parent.Unlock() return nil } func (m *MemMapFs) findParent(f *mem.FileData) *mem.FileData { pdir, _ := filepath.Split(f.Name()) pdir = filepath.Clean(pdir) pfile, err := m.lockfreeOpen(pdir) if err != nil { return nil } return pfile } func (m *MemMapFs) registerWithParent(f *mem.FileData) { if f == nil { return } parent := m.findParent(f) if parent == nil { pdir := filepath.Dir(filepath.Clean(f.Name())) err := m.lockfreeMkdir(pdir, 0777) if err != nil { //log.Println("Mkdir error:", err) return } parent, err = m.lockfreeOpen(pdir) if err != nil { //log.Println("Open after Mkdir error:", err) return } } parent.Lock() mem.InitializeDir(parent) mem.AddToMemDir(parent, f) parent.Unlock() } func (m *MemMapFs) lockfreeMkdir(name string, perm os.FileMode) error { name = normalizePath(name) x, ok := m.getData()[name] if ok { // Only return ErrFileExists if it's a file, not a directory. i := mem.FileInfo{FileData: x} if !i.IsDir() { return ErrFileExists } } else { item := mem.CreateDir(name) m.getData()[name] = item m.registerWithParent(item) } return nil } func (m *MemMapFs) Mkdir(name string, perm os.FileMode) error { name = normalizePath(name) m.mu.RLock() _, ok := m.getData()[name] m.mu.RUnlock() if ok { return &os.PathError{Op: "mkdir", Path: name, Err: ErrFileExists} } m.mu.Lock() item := mem.CreateDir(name) m.getData()[name] = item m.registerWithParent(item) m.mu.Unlock() m.Chmod(name, perm|os.ModeDir) return nil } func (m *MemMapFs) MkdirAll(path string, perm os.FileMode) error { err := m.Mkdir(path, perm) if err != nil { if err.(*os.PathError).Err == ErrFileExists { return nil } return err } return nil } // Handle some relative paths func normalizePath(path string) string { path = filepath.Clean(path) switch path { case ".": return FilePathSeparator case "..": return FilePathSeparator default: return path } } func (m *MemMapFs) Open(name string) (File, error) { f, err := m.open(name) if f != nil { return mem.NewReadOnlyFileHandle(f), err } return nil, err } func (m *MemMapFs) openWrite(name string) (File, error) { f, err := m.open(name) if f != nil { return mem.NewFileHandle(f), err } return nil, err } func (m *MemMapFs) open(name string) (*mem.FileData, error) { name = normalizePath(name) m.mu.RLock() f, ok := m.getData()[name] m.mu.RUnlock() if !ok { return nil, &os.PathError{Op: "open", Path: name, Err: ErrFileNotFound} } return f, nil } func (m *MemMapFs) lockfreeOpen(name string) (*mem.FileData, error) { name = normalizePath(name) f, ok := m.getData()[name] if ok { return f, nil } else { return nil, ErrFileNotFound } } func (m *MemMapFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) { chmod := false file, err := m.openWrite(name) if os.IsNotExist(err) && (flag&os.O_CREATE > 0) { file, err = m.Create(name) chmod = true } if err != nil { return nil, err } if flag == os.O_RDONLY { file = mem.NewReadOnlyFileHandle(file.(*mem.File).Data()) } if flag&os.O_APPEND > 0 { _, err = file.Seek(0, os.SEEK_END) if err != nil { file.Close() return nil, err } } if flag&os.O_TRUNC > 0 && flag&(os.O_RDWR|os.O_WRONLY) > 0 { err = file.Truncate(0) if err != nil { file.Close() return nil, err } } if chmod { m.Chmod(name, perm) } return file, nil } func (m *MemMapFs) Remove(name string) error { name = normalizePath(name) m.mu.Lock() defer m.mu.Unlock() if _, ok := m.getData()[name]; ok { err := m.unRegisterWithParent(name) if err != nil { return &os.PathError{Op: "remove", Path: name, Err: err} } delete(m.getData(), name) } else { return &os.PathError{Op: "remove", Path: name, Err: os.ErrNotExist} } return nil } func (m *MemMapFs) RemoveAll(path string) error { path = normalizePath(path) m.mu.Lock() m.unRegisterWithParent(path) m.mu.Unlock() m.mu.RLock() defer m.mu.RUnlock() for p, _ := range m.getData() { if strings.HasPrefix(p, path) { m.mu.RUnlock() m.mu.Lock() delete(m.getData(), p) m.mu.Unlock() m.mu.RLock() } } return nil } func (m *MemMapFs) Rename(oldname, newname string) error { oldname = normalizePath(oldname) newname = normalizePath(newname) if oldname == newname { return nil } m.mu.RLock() defer m.mu.RUnlock() if _, ok := m.getData()[oldname]; ok { m.mu.RUnlock() m.mu.Lock() m.unRegisterWithParent(oldname) fileData := m.getData()[oldname] delete(m.getData(), oldname) mem.ChangeFileName(fileData, newname) m.getData()[newname] = fileData m.registerWithParent(fileData) m.mu.Unlock() m.mu.RLock() } else { return &os.PathError{Op: "rename", Path: oldname, Err: ErrFileNotFound} } return nil } func (m *MemMapFs) Stat(name string) (os.FileInfo, error) { f, err := m.Open(name) if err != nil { return nil, err } fi := mem.GetFileInfo(f.(*mem.File).Data()) return fi, nil } func (m *MemMapFs) Chmod(name string, mode os.FileMode) error { name = normalizePath(name) m.mu.RLock() f, ok := m.getData()[name] m.mu.RUnlock() if !ok { return &os.PathError{Op: "chmod", Path: name, Err: ErrFileNotFound} } m.mu.Lock() mem.SetMode(f, mode) m.mu.Unlock() return nil } func (m *MemMapFs) Chtimes(name string, atime time.Time, mtime time.Time) error { name = normalizePath(name) m.mu.RLock() f, ok := m.getData()[name] m.mu.RUnlock() if !ok { return &os.PathError{Op: "chtimes", Path: name, Err: ErrFileNotFound} } m.mu.Lock() mem.SetModTime(f, mtime) m.mu.Unlock() return nil } func (m *MemMapFs) List() { for _, x := range m.data { y := mem.FileInfo{FileData: x} fmt.Println(x.Name(), y.Size()) } } // func debugMemMapList(fs Fs) { // if x, ok := fs.(*MemMapFs); ok { // x.List() // } // }