Go os.ReadDir 在运行时读取已删除的文件

huangapple
go评论108阅读模式
英文:

Go os.ReadDir reading files deleted in run time

问题

我有一个程序，可以在同一个目录下的文件系统中找到最大的文件。如果我调用FileDisplay.Delete函数，然后重新运行GetTopXFiles函数来获取目录中的文件，它会返回已经被删除的文件。在程序仍在运行时，我可以使用ls命令看到文件已经不存在了。有趣的是，如果我使用fallocate -l 251.2M file100命令创建一个新文件，我可以看到这个新创建的文件被认为是最大的文件。然后，如果我使用rm命令或程序将其删除，重新运行GetTopXFiles函数，它仍然会返回该文件。如果我重新启动程序，它会识别到该文件已经不存在。

以上是一个用Go语言编写的程序，用于查找文件并显示文件大小和路径。它包括以下函数：

  • GetTopXFiles函数用于获取指定目录下最大的文件列表。
  • Delete函数用于删除指定文件。
  • Append函数用于向文件列表中添加文件。

请问有什么我可以帮助你的吗？

英文:

I have a program that is finding the larges files on a filesystem within the same directory. If I call FileDisplay.Delete function and then re-run GetTopXFiles on the directory, it returns files that had been deleted. Using ls while the program is still running, I can see that the files is no longer there. Interestingly, if I fallocate -l 251.2M file100 I can see my newly created file as being the largest file. If I then remove it using rm or the program, re-run the GetTopXFiles it still returns. If I restart the program it recognizes the file is gone.

  1. package fileFinder
  3. import (
  4. 	"fmt"
  5. 	"io"
  6. 	"io/fs"
  7. 	"log"
  8. 	"os"
  9. 	"sort"
  10. 	"sync"
  12. 	"github.com/google/fscrypt/filesystem"
  13. 	"github.com/sirupsen/logrus"
  14. )
  16. var device string
  18. type fileDisplay struct {
  19. 	sync.RWMutex
  20. 	Files []FileDisplay
  21. }
  23. var files fileDisplay
  25. type FileDisplay struct {
  26. 	Size int64  `json:"size"`
  27. 	Path string `json:"path"`
  28. }
  29. type bySize []FileDisplay
  31. func (a bySize) Len() int           { return len(a) }
  32. func (a bySize) Less(i, j int) bool { return a[i].Size < a[j].Size }
  33. func (a bySize) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
  35. func GetTopXFiles(mountpoint string, limit int) ([]FileDisplay, error) {
  36. 	log.SetOutput(io.Discard)
  37. 	if mountpoint == "" {
  38. 		return nil, fmt.Errorf("Path cannot be empty")
  39. 	}
  40. 	if limit < 1 {
  41. 		return nil, fmt.Errorf("Limit must be 1 or greater")
  43. 	}
  44. 	if mountpoint[len(mountpoint)-1:] != "/" {
  45. 		mountpoint = mountpoint + "/"
  46. 	}
  47. 	mount, err := filesystem.FindMount(mountpoint)
  48. 	if err != nil {
  49. 		return nil, err
  50. 	}
  51. 	device = mount.Device
  53. 	entries, err := os.ReadDir(mountpoint)
  54. 	if err != nil {
  55. 		return nil, err
  56. 	}
  57. 	var wg sync.WaitGroup
  58. 	getFiles(mountpoint, entries, &wg)
  59. 	wg.Wait()
  60. 	sort.Sort(bySize(files.Files))
  61. 	var shortFiles []FileDisplay
  62. 	if len(files.Files) > limit {
  63. 		shortFiles = files.Files[len(files.Files)-limit:]
  64. 	} else {
  65. 		shortFiles = files.Files
  66. 	}
  68. 	return shortFiles, nil
  70. }
  72. func getFiles(start string, entries []fs.DirEntry, wg *sync.WaitGroup) {
  73. 	for _, entry := range entries {
  74. 		wg.Add(1)
  75. 		go handleEntry(start, entry, wg)
  76. 	}
  78. }
  80. func handleEntry(start string, entry fs.DirEntry, wg *sync.WaitGroup) {
  81. 	defer wg.Done()
  82. 	var file FileDisplay
  83. 	mount, err := filesystem.FindMount(start + entry.Name())
  84. 	if err != nil {
  85. 		logrus.Errorln(err, start+entry.Name())
  86. 		return
  87. 	}
  88. 	if mount.Device == device {
  89. 		if entry.Type().IsRegular() {
  90. 			fileInfo, err := os.Stat(start + entry.Name())
  91. 			if err != nil {
  92. 				logrus.Errorln(err, start+entry.Name())
  93. 				return
  94. 			}
  95. 			file.Path = start + entry.Name()
  96. 			file.Size = fileInfo.Size()
  97. 			files.Append(file)
  98. 		} else if entry.IsDir() {
  99. 			entries, err := os.ReadDir(start + entry.Name())
  100. 			if err != nil {
  101. 				logrus.Errorln(err, start+entry.Name())
  102. 				return
  103. 			}
  104. 			logrus.Info("Searching ", start+entry.Name())
  105. 			getFiles(start+entry.Name()+"/", entries, wg)
  106. 		}
  107. 	}
  109. }
  111. func (f *FileDisplay) DisplaySizeIEC() string {
  112. 	const unit = 1024
  113. 	b := f.Size
  114. 	if b < unit {
  115. 		return fmt.Sprintf("%dB", b)
  116. 	}
  117. 	div, exp := int64(unit), 0
  118. 	for n := b / unit; n >= unit; n /= unit {
  119. 		div *= unit
  120. 		exp++
  121. 	}
  122. 	return fmt.Sprintf("%.2f%ciB",
  123. 		float64(b)/float64(div), "KMGTPE"[exp])
  124. }
  126. func (f *FileDisplay) Delete() error {
  127. 	err := os.Remove(f.Path)
  128. 	if err != nil {
  129. 		return err
  130. 	}
  131. 	return nil
  132. }
  134. func (fd *fileDisplay) Append(item FileDisplay) {
  135. 	fd.Lock()
  136. 	defer fd.Unlock()
  138. 	fd.Files = append(fd.Files, item)
  139. }

答案1

得分: 1

  1. var files fileDisplay

files是一个全局的fileDisplay变量，其中包含一个由GetTopXFiles填充的[]FileDisplay。但是，即使调用了Delete，也没有更新files。因此，在删除后，files中包含的是已被删除的文件。

最简单的解决方案是不使用全局的files，而是在GetTopXFiles内部重新生成一个。

英文: 
  1. var files fileDisplay

files is a global fileDisplay which contains a []FileDisplay that gets filled in by GetTopXFiles. But nothing updates files even if Delete is called. Thus, files is out of date after a delete, containing files that were since deleted.

The easiest solution is to not use a global files but instead regenerate one within GetTopXFiles.

huangapple
  • 本文由 发表于 2022年8月25日 19:37:08
  • 转载请务必保留本文链接：https://go.coder-hub.com/73486783.html
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定