golang/mikael/madonctl: comparison vendor/github.com/spf13/afero/memmap.go

equal deleted inserted replaced

-:4f153a23adab
+:6d9efbef00a9
 	"time"
 	"github.com/spf13/afero/mem"
 )
+const chmodBits = os.ModePerm | os.ModeSetuid | os.ModeSetgid | os.ModeSticky // Only a subset of bits are allowed to be changed. Documented under os.Chmod()
 type MemMapFs struct {
 	mu   sync.RWMutex
 	data map[string]*mem.FileData
 	init sync.Once
 }
 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)
+		root := mem.CreateDir(FilePathSeparator)
+		mem.SetMode(root, os.ModeDir|0755)
+		m.data[FilePathSeparator] = root
 	})
 	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.registerWithParent(file, 0)
 	m.mu.Unlock()
 	return mem.NewFileHandle(file), nil
 }
 func (m *MemMapFs) unRegisterWithParent(fileName string) error {
 		return nil
 	}
 	return pfile
 }
-func (m *MemMapFs) registerWithParent(f *mem.FileData) {
+func (m *MemMapFs) registerWithParent(f *mem.FileData, perm os.FileMode) {
 	if f == nil {
 		return
 	}
 	parent := m.findParent(f)
 	if parent == nil {
 		pdir := filepath.Dir(filepath.Clean(f.Name()))
-		err := m.lockfreeMkdir(pdir, 0777)
+		err := m.lockfreeMkdir(pdir, perm)
 		if err != nil {
 			//log.Println("Mkdir error:", err)
 			return
 		}
 		parent, err = m.lockfreeOpen(pdir)
 		if !i.IsDir() {
 			return ErrFileExists
 		}
 	} else {
 		item := mem.CreateDir(name)
+		mem.SetMode(item, os.ModeDir|perm)
 		m.getData()[name] = item
-		m.registerWithParent(item)
+		m.registerWithParent(item, perm)
 	}
 	return nil
 }
 func (m *MemMapFs) Mkdir(name string, perm os.FileMode) error {
+	perm &= chmodBits
 	name = normalizePath(name)
 	m.mu.RLock()
 	_, ok := m.getData()[name]
 	m.mu.RUnlock()
 		return &os.PathError{Op: "mkdir", Path: name, Err: ErrFileExists}
 	}
 	m.mu.Lock()
 	item := mem.CreateDir(name)
+	mem.SetMode(item, os.ModeDir|perm)
 	m.getData()[name] = item
-	m.registerWithParent(item)
+	m.registerWithParent(item, perm)
 	m.mu.Unlock()
-	m.Chmod(name, perm|os.ModeDir)
+	return m.setFileMode(name, perm|os.ModeDir)
-	return nil
 }
 func (m *MemMapFs) MkdirAll(path string, perm os.FileMode) error {
 	err := m.Mkdir(path, perm)
 	if err != nil {
 		return nil, ErrFileNotFound
 	}
 }
 func (m *MemMapFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
+	perm &= chmodBits
 	chmod := false
 	file, err := m.openWrite(name)
+	if err == nil && (flag&os.O_EXCL > 0) {
+		return nil, &os.PathError{Op: "open", Path: name, Err: ErrFileExists}
+	}
 	if os.IsNotExist(err) && (flag&os.O_CREATE > 0) {
 		file, err = m.Create(name)
 		chmod = true
 	}
 	if err != nil {
 			file.Close()
 			return nil, err
 		}
 	}
 	if chmod {
-		m.Chmod(name, perm)
+		return file, m.setFileMode(name, perm)
 	}
 	return file, nil
 }
 func (m *MemMapFs) Remove(name string) error {
 	m.mu.Unlock()
 	m.mu.RLock()
 	defer m.mu.RUnlock()
-	for p, _ := range m.getData() {
+	for p := range m.getData() {
 		if strings.HasPrefix(p, path) {
 			m.mu.RUnlock()
 			m.mu.Lock()
 			delete(m.getData(), p)
 			m.mu.Unlock()
 		m.unRegisterWithParent(oldname)
 		fileData := m.getData()[oldname]
 		delete(m.getData(), oldname)
 		mem.ChangeFileName(fileData, newname)
 		m.getData()[newname] = fileData
-		m.registerWithParent(fileData)
+		m.registerWithParent(fileData, 0)
 		m.mu.Unlock()
 		m.mu.RLock()
 	} else {
 		return &os.PathError{Op: "rename", Path: oldname, Err: ErrFileNotFound}
 	}
 	return nil
 }
+func (m *MemMapFs) LstatIfPossible(name string) (os.FileInfo, bool, error) {
+	fileInfo, err := m.Stat(name)
+	return fileInfo, false, err
+}
 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)
+	mode &= chmodBits
 	m.mu.RLock()
 	f, ok := m.getData()[name]
 	m.mu.RUnlock()
 	if !ok {
 		return &os.PathError{Op: "chmod", Path: name, Err: ErrFileNotFound}
 	}
+	prevOtherBits := mem.GetFileInfo(f).Mode() & ^chmodBits
+	mode = prevOtherBits | mode
+	return m.setFileMode(name, mode)
+}
+func (m *MemMapFs) setFileMode(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) Chown(name string, uid, gid int) error {
+	name = normalizePath(name)
+	m.mu.RLock()
+	f, ok := m.getData()[name]
+	m.mu.RUnlock()
+	if !ok {
+		return &os.PathError{Op: "chown", Path: name, Err: ErrFileNotFound}
+	}
+	mem.SetUID(f, uid)
+	mem.SetGID(f, gid)
 	return nil
 }
 func (m *MemMapFs) Chtimes(name string, atime time.Time, mtime time.Time) error {
 	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()
-// 	}
-// }

changeset 256	6d9efbef00a9
parent 242	2a9ec03fe5a1
child 260	445e01aede7e