Close shared readers when storage is closed

Author: anacrolix

justfile

@@ -8,8 +8,8 @@ act:
 
 export GOPPROF := env("GOPPROF", "http")
 
-test-short: build-possum
-    GOPPROF='{{GOPPROF}}' go test -race -failfast -short ./...
+test-short *args: build-possum
+    GOPPROF='{{GOPPROF}}' go test -race -failfast -short {{ args }} ./...
 
 test *args: build-possum
     go test -race {{ args }} ./...

storage/file-io-classic.go

@@ -7,6 +7,11 @@ import (
 
 type classicFileIo struct{}
 
+// Lifetimes of files are scoped to their use, so let's hope everyone is being a good citizen.
+func (me classicFileIo) Close() error {
+	return nil
+}
+
 func (me classicFileIo) rename(from, to string) error {
 	return os.Rename(from, to)
 }

storage/file-io.go

@@ -22,6 +22,7 @@ var defaultFileIo = func() fileIo {
 }
 
 type fileIo interface {
+	Close() error
 
 	openForSharedRead(name string) (sharableReader, error)
 	openForRead(name string) (fileReader, error)

storage/file-torrent.go

@@ -26,38 +26,38 @@ type fileTorrentImpl struct {
 	client *fileClientImpl
 }
 
-func (fts *fileTorrentImpl) logger() *slog.Logger {
-	return fts.client.opts.Logger
+func (me *fileTorrentImpl) logger() *slog.Logger {
+	return me.client.opts.Logger
 }
 
-func (fts *fileTorrentImpl) pieceCompletion() PieceCompletion {
-	return fts.client.opts.PieceCompletion
+func (me *fileTorrentImpl) pieceCompletion() PieceCompletion {
+	return me.client.opts.PieceCompletion
 }
 
-func (fts *fileTorrentImpl) pieceCompletionKey(p int) metainfo.PieceKey {
+func (me *fileTorrentImpl) pieceCompletionKey(p int) metainfo.PieceKey {
 	return metainfo.PieceKey{
-		InfoHash: fts.infoHash,
+		InfoHash: me.infoHash,
 		Index:    p,
 	}
 }
 
-func (fts *fileTorrentImpl) setPieceCompletion(p int, complete bool) error {
-	return fts.pieceCompletion().Set(fts.pieceCompletionKey(p), complete)
+func (me *fileTorrentImpl) setPieceCompletion(p int, complete bool) error {
+	return me.pieceCompletion().Set(me.pieceCompletionKey(p), complete)
 }
 
 // Set piece completions based on whether all files in each piece are not .part files.
-func (fts *fileTorrentImpl) setCompletionFromPartFiles() error {
-	notComplete := make([]bool, fts.info.NumPieces())
-	for fileIndex := range fts.files {
-		f := fts.file(fileIndex)
+func (me *fileTorrentImpl) setCompletionFromPartFiles() error {
+	notComplete := make([]bool, me.info.NumPieces())
+	for fileIndex := range me.files {
+		f := me.file(fileIndex)
 		fi, err := os.Stat(f.safeOsPath)
 		if err == nil {
 			if fi.Size() == f.length() {
 				continue
 			}
-			fts.logger().Warn("file has unexpected size", "file", f.safeOsPath, "size", fi.Size(), "expected", f.length())
+			me.logger().Warn("file has unexpected size", "file", f.safeOsPath, "size", fi.Size(), "expected", f.length())
 		} else if !errors.Is(err, fs.ErrNotExist) {
-			fts.logger().Warn("error checking file size", "err", err)
+			me.logger().Warn("error checking file size", "err", err)
 		}
 		// Ensure all pieces associated with a file are not marked as complete (at most unknown).
 		for pieceIndex := f.beginPieceIndex(); pieceIndex < f.endPieceIndex(); pieceIndex++ {
@@ -66,14 +66,14 @@ func (fts *fileTorrentImpl) setCompletionFromPartFiles() error {
 	}
 	for i, nc := range notComplete {
 		if nc {
-			c := fts.getCompletion(i)
+			c := me.getCompletion(i)
 			if c.Complete {
 				// TODO: We need to set unknown so that verification of the data we do have could
 				// occur naturally but that'll be a big change.
-				panicif.Err(fts.setPieceCompletion(i, false))
+				panicif.Err(me.setPieceCompletion(i, false))
 			}
 		} else {
-			err := fts.setPieceCompletion(i, true)
+			err := me.setPieceCompletion(i, true)
 			if err != nil {
 				return fmt.Errorf("setting piece %v completion: %w", i, err)
 			}
@@ -82,44 +82,44 @@ func (fts *fileTorrentImpl) setCompletionFromPartFiles() error {
 	return nil
 }
 
-func (fts *fileTorrentImpl) partFiles() bool {
-	return fts.client.opts.partFiles()
+func (me *fileTorrentImpl) partFiles() bool {
+	return me.client.opts.partFiles()
 }
 
-func (fts *fileTorrentImpl) pathForWrite(f *file) string {
-	if fts.partFiles() {
+func (me *fileTorrentImpl) pathForWrite(f *file) string {
+	if me.partFiles() {
 		return f.partFilePath()
 	}
 	return f.safeOsPath
 }
 
-func (fts *fileTorrentImpl) getCompletion(piece int) Completion {
-	cmpl, err := fts.pieceCompletion().Get(metainfo.PieceKey{fts.infoHash, piece})
+func (me *fileTorrentImpl) getCompletion(piece int) Completion {
+	cmpl, err := me.pieceCompletion().Get(metainfo.PieceKey{me.infoHash, piece})
 	cmpl.Err = errors.Join(cmpl.Err, err)
 	return cmpl
 }
 
-func (fts *fileTorrentImpl) Piece(p metainfo.Piece) PieceImpl {
+func (me *fileTorrentImpl) Piece(p metainfo.Piece) PieceImpl {
 	// Create a view onto the file-based torrent storage.
-	_io := fileTorrentImplIO{fts}
+	_io := fileTorrentImplIO{me}
 	// Return the appropriate segments of this.
 	return &filePieceImpl{
-		fts,
+		me,
 		p,
 		missinggo.NewSectionWriter(_io, p.Offset(), p.Length()),
 		io.NewSectionReader(_io, p.Offset(), p.Length()),
 	}
 }
 
-func (fs *fileTorrentImpl) Close() error {
-	return nil
+func (me *fileTorrentImpl) Close() error {
+	return me.io.Close()
 }
 
-func (fts *fileTorrentImpl) file(index int) file {
+func (me *fileTorrentImpl) file(index int) file {
 	return file{
-		Info:      fts.info,
-		FileInfo:  &fts.metainfoFileInfos[index],
-		fileExtra: &fts.files[index],
+		Info:      me.info,
+		FileInfo:  &me.metainfoFileInfos[index],
+		fileExtra: &me.files[index],
 	}
 }
 
@@ -153,8 +153,8 @@ func (me *fileTorrentImpl) openFile(file file) (f fileReader, err error) {
 	return
 }
 
-func (fst *fileTorrentImpl) openForWrite(file file) (_ fileWriter, err error) {
+func (me *fileTorrentImpl) openForWrite(file file) (_ fileWriter, err error) {
 	// It might be possible to have a writable handle shared files cache if we need it.
-	fst.logger().Debug("openForWrite", "file.safeOsPath", file.safeOsPath)
-	return fst.io.openForWrite(fst.pathForWrite(&file), file.FileInfo.Length)
+	me.logger().Debug("openForWrite", "file.safeOsPath", file.safeOsPath)
+	return me.io.openForWrite(me.pathForWrite(&file), file.FileInfo.Length)
 }