1 // Copyright © 2014 Steve Francia <spf@spf13.com>.
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 // http://www.apache.org/licenses/LICENSE-2.0
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
25 "github.com/spf13/afero/mem"
28 type MemMapFs struct {
30 data map[string]*mem.FileData
34 func NewMemMapFs() Fs {
38 func (m *MemMapFs) getData() map[string]*mem.FileData {
40 m.data = make(map[string]*mem.FileData)
41 // Root should always exist, right?
42 // TODO: what about windows?
43 m.data[FilePathSeparator] = mem.CreateDir(FilePathSeparator)
48 func (*MemMapFs) Name() string { return "MemMapFS" }
50 func (m *MemMapFs) Create(name string) (File, error) {
51 name = normalizePath(name)
53 file := mem.CreateFile(name)
54 m.getData()[name] = file
55 m.registerWithParent(file)
57 return mem.NewFileHandle(file), nil
60 func (m *MemMapFs) unRegisterWithParent(fileName string) error {
61 f, err := m.lockfreeOpen(fileName)
65 parent := m.findParent(f)
67 log.Panic("parent of ", f.Name(), " is nil")
71 mem.RemoveFromMemDir(parent, f)
76 func (m *MemMapFs) findParent(f *mem.FileData) *mem.FileData {
77 pdir, _ := filepath.Split(f.Name())
78 pdir = filepath.Clean(pdir)
79 pfile, err := m.lockfreeOpen(pdir)
86 func (m *MemMapFs) registerWithParent(f *mem.FileData) {
90 parent := m.findParent(f)
92 pdir := filepath.Dir(filepath.Clean(f.Name()))
93 err := m.lockfreeMkdir(pdir, 0777)
95 //log.Println("Mkdir error:", err)
98 parent, err = m.lockfreeOpen(pdir)
100 //log.Println("Open after Mkdir error:", err)
106 mem.InitializeDir(parent)
107 mem.AddToMemDir(parent, f)
111 func (m *MemMapFs) lockfreeMkdir(name string, perm os.FileMode) error {
112 name = normalizePath(name)
113 x, ok := m.getData()[name]
115 // Only return ErrFileExists if it's a file, not a directory.
116 i := mem.FileInfo{FileData: x}
121 item := mem.CreateDir(name)
122 m.getData()[name] = item
123 m.registerWithParent(item)
128 func (m *MemMapFs) Mkdir(name string, perm os.FileMode) error {
129 name = normalizePath(name)
132 _, ok := m.getData()[name]
135 return &os.PathError{Op: "mkdir", Path: name, Err: ErrFileExists}
139 item := mem.CreateDir(name)
140 m.getData()[name] = item
141 m.registerWithParent(item)
144 m.Chmod(name, perm|os.ModeDir)
149 func (m *MemMapFs) MkdirAll(path string, perm os.FileMode) error {
150 err := m.Mkdir(path, perm)
152 if err.(*os.PathError).Err == ErrFileExists {
160 // Handle some relative paths
161 func normalizePath(path string) string {
162 path = filepath.Clean(path)
166 return FilePathSeparator
168 return FilePathSeparator
174 func (m *MemMapFs) Open(name string) (File, error) {
175 f, err := m.open(name)
177 return mem.NewReadOnlyFileHandle(f), err
182 func (m *MemMapFs) openWrite(name string) (File, error) {
183 f, err := m.open(name)
185 return mem.NewFileHandle(f), err
190 func (m *MemMapFs) open(name string) (*mem.FileData, error) {
191 name = normalizePath(name)
194 f, ok := m.getData()[name]
197 return nil, &os.PathError{Op: "open", Path: name, Err: ErrFileNotFound}
202 func (m *MemMapFs) lockfreeOpen(name string) (*mem.FileData, error) {
203 name = normalizePath(name)
204 f, ok := m.getData()[name]
208 return nil, ErrFileNotFound
212 func (m *MemMapFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
214 file, err := m.openWrite(name)
215 if os.IsNotExist(err) && (flag&os.O_CREATE > 0) {
216 file, err = m.Create(name)
222 if flag == os.O_RDONLY {
223 file = mem.NewReadOnlyFileHandle(file.(*mem.File).Data())
225 if flag&os.O_APPEND > 0 {
226 _, err = file.Seek(0, os.SEEK_END)
232 if flag&os.O_TRUNC > 0 && flag&(os.O_RDWR|os.O_WRONLY) > 0 {
233 err = file.Truncate(0)
245 func (m *MemMapFs) Remove(name string) error {
246 name = normalizePath(name)
251 if _, ok := m.getData()[name]; ok {
252 err := m.unRegisterWithParent(name)
254 return &os.PathError{Op: "remove", Path: name, Err: err}
256 delete(m.getData(), name)
258 return &os.PathError{Op: "remove", Path: name, Err: os.ErrNotExist}
263 func (m *MemMapFs) RemoveAll(path string) error {
264 path = normalizePath(path)
266 m.unRegisterWithParent(path)
272 for p, _ := range m.getData() {
273 if strings.HasPrefix(p, path) {
276 delete(m.getData(), p)
284 func (m *MemMapFs) Rename(oldname, newname string) error {
285 oldname = normalizePath(oldname)
286 newname = normalizePath(newname)
288 if oldname == newname {
294 if _, ok := m.getData()[oldname]; ok {
297 m.unRegisterWithParent(oldname)
298 fileData := m.getData()[oldname]
299 delete(m.getData(), oldname)
300 mem.ChangeFileName(fileData, newname)
301 m.getData()[newname] = fileData
302 m.registerWithParent(fileData)
306 return &os.PathError{Op: "rename", Path: oldname, Err: ErrFileNotFound}
311 func (m *MemMapFs) Stat(name string) (os.FileInfo, error) {
312 f, err := m.Open(name)
316 fi := mem.GetFileInfo(f.(*mem.File).Data())
320 func (m *MemMapFs) Chmod(name string, mode os.FileMode) error {
321 name = normalizePath(name)
324 f, ok := m.getData()[name]
327 return &os.PathError{Op: "chmod", Path: name, Err: ErrFileNotFound}
337 func (m *MemMapFs) Chtimes(name string, atime time.Time, mtime time.Time) error {
338 name = normalizePath(name)
341 f, ok := m.getData()[name]
344 return &os.PathError{Op: "chtimes", Path: name, Err: ErrFileNotFound}
348 mem.SetModTime(f, mtime)
354 func (m *MemMapFs) List() {
355 for _, x := range m.data {
356 y := mem.FileInfo{FileData: x}
357 fmt.Println(x.Name(), y.Size())
361 // func debugMemMapList(fs Fs) {
362 // if x, ok := fs.(*MemMapFs); ok {