Add more error handling

helpers/prepare-release/main.go

@@ -237,7 +237,9 @@ func preCheckChangelogVersion() {
 	if err != nil {
 		die("unable to open CHANGELOG.md: %v", err)
 	}
-	defer f.Close()
+	defer func() {
+		_ = f.Close()
+	}()
 
 	sc := bufio.NewScanner(f)
 	for sc.Scan() {

internal/backend/backend_retry_test.go

@@ -62,11 +62,11 @@ func TestBackendListRetry(t *testing.T) {
 			// fail during first retry, succeed during second
 			retry++
 			if retry == 1 {
-				fn(restic.FileInfo{Name: ID1})
+				_ = fn(restic.FileInfo{Name: ID1})
 				return errors.New("test list error")
 			}
-			fn(restic.FileInfo{Name: ID1})
+			_ = fn(restic.FileInfo{Name: ID1})
-			fn(restic.FileInfo{Name: ID2})
+			_ = fn(restic.FileInfo{Name: ID2})
 			return nil
 		},
 	}

internal/backend/local/local.go

@@ -265,9 +265,15 @@ func visitDirs(ctx context.Context, dir string, fn func(restic.FileInfo) error)
 	if err != nil {
 		return err
 	}
-	defer d.Close()
 
 	sub, err := d.Readdirnames(-1)
+	if err != nil {
+		// ignore subsequent errors
+		_ = d.Close()
+		return err
+	}
+
+	err = d.Close()
 	if err != nil {
 		return err
 	}
@@ -286,9 +292,15 @@ func visitFiles(ctx context.Context, dir string, fn func(restic.FileInfo) error)
 	if err != nil {
 		return err
 	}
-	defer d.Close()
 
 	sub, err := d.Readdir(-1)
+	if err != nil {
+		// ignore subsequent errors
+		_ = d.Close()
+		return err
+	}
+
+	err = d.Close()
 	if err != nil {
 		return err
 	}

internal/backend/local/local_internal_test.go

@@ -30,7 +30,9 @@ func TestNoSpacePermanent(t *testing.T) {
 
 	be, err := Open(context.Background(), Config{Path: dir})
 	rtest.OK(t, err)
-	defer be.Close()
+	defer func() {
+		rtest.OK(t, be.Close())
+	}()
 
 	h := restic.Handle{Type: restic.ConfigFile}
 	err = be.Save(context.Background(), h, nil)

internal/backend/utils.go

@@ -52,7 +52,7 @@ func DefaultLoad(ctx context.Context, h restic.Handle, length int, offset int64,
 	}
 	err = fn(rd)
 	if err != nil {
-		rd.Close() // ignore secondary errors closing the reader
+		_ = rd.Close() // ignore secondary errors closing the reader
 		return err
 	}
 	return rd.Close()

internal/cache/backend.go

@@ -166,7 +166,7 @@ func (b *Backend) Load(ctx context.Context, h restic.Handle, length int, offset
 		if err == nil {
 			err = consumer(rd)
 			if err != nil {
-				rd.Close() // ignore secondary errors
+				_ = rd.Close() // ignore secondary errors
 				return err
 			}
 			return rd.Close()

internal/cache/dir_test.go

@@ -17,7 +17,12 @@ func TestCacheDirEnv(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		defer os.Unsetenv("RESTIC_CACHE_DIR")
+		defer func() {
+			err := os.Unsetenv("RESTIC_CACHE_DIR")
+			if err != nil {
+				t.Fatal(err)
+			}
+		}()
 	}
 
 	dir, err := DefaultDir()

internal/dump/acl.go

@@ -101,12 +101,23 @@ func (a *acl) decode(xattr []byte) {
 func (a *acl) encode() []byte {
 	buf := new(bytes.Buffer)
 	ae := new(aclElem)
-	binary.Write(buf, binary.LittleEndian, &a.Version)
+
+	err := binary.Write(buf, binary.LittleEndian, &a.Version)
+	// write to a bytes.Buffer always returns a nil error
+	if err != nil {
+		panic(err)
+	}
+
 	for _, elem := range a.List {
 		ae.Tag = uint16(elem.getType())
 		ae.Perm = elem.Perm
 		ae.ID = elem.getID()
-		binary.Write(buf, binary.LittleEndian, ae)
+
+		err := binary.Write(buf, binary.LittleEndian, ae)
+		// write to a bytes.Buffer always returns a nil error
+		if err != nil {
+			panic(err)
+		}
 	}
 	return buf.Bytes()
 }

internal/dump/common.go

@@ -25,7 +25,8 @@ func writeDump(ctx context.Context, repo restic.Repository, tree *restic.Tree, r
 		rootNode.Path = rootPath
 		err := dumpTree(ctx, repo, rootNode, rootPath, dmp)
 		if err != nil {
-			dmp.Close()
+			// ignore subsequent errors
+			_ = dmp.Close()
 
 			return err
 		}

internal/dump/zip_test.go

@@ -23,10 +23,16 @@ func readZipFile(f *zip.File) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer rc.Close()
 
 	b := &bytes.Buffer{}
 	_, err = b.ReadFrom(rc)
+	if err != nil {
+		// ignore subsequent errors
+		_ = rc.Close()
+		return nil, err
+	}
+
+	err = rc.Close()
 	if err != nil {
 		return nil, err
 	}

internal/fs/fs_local_vss.go

@@ -50,7 +50,7 @@ func (fs *LocalVss) DeleteSnapshots() {
 
 	for volumeName, snapshot := range fs.snapshots {
 		if err := snapshot.Delete(); err != nil {
-			fs.msgError(volumeName, errors.Errorf("failed to delete VSS snapshot: %s", err))
+			_ = fs.msgError(volumeName, errors.Errorf("failed to delete VSS snapshot: %s", err))
 			activeSnapshots[volumeName] = snapshot
 		}
 	}
@@ -117,7 +117,7 @@ func (fs *LocalVss) snapshotPath(path string) string {
 			fs.msgMessage("creating VSS snapshot for [%s]\n", vssVolume)
 
 			if snapshot, err := NewVssSnapshot(vssVolume, 120, fs.msgError); err != nil {
-				fs.msgError(vssVolume, errors.Errorf("failed to create snapshot for [%s]: %s\n",
+				_ = fs.msgError(vssVolume, errors.Errorf("failed to create snapshot for [%s]: %s\n",
 					vssVolume, err))
 				fs.failedSnapshots[volumeNameLower] = struct{}{}
 			} else {

internal/mock/backend.go

@@ -73,7 +73,7 @@ func (m *Backend) Load(ctx context.Context, h restic.Handle, length int, offset
 	}
 	err = fn(rd)
 	if err != nil {
-		rd.Close() // ignore secondary errors closing the reader
+		_ = rd.Close() // ignore secondary errors closing the reader
 		return err
 	}
 	return rd.Close()

internal/pack/pack_internal_test.go

@@ -61,9 +61,9 @@ func TestReadHeaderEagerLoad(t *testing.T) {
 		expectedHeader := rtest.Random(0, entryCount*int(EntrySize)+crypto.Extension)
 
 		buf := &bytes.Buffer{}
-		buf.Write(rtest.Random(0, dataSize))                                // pack blobs data
+		buf.Write(rtest.Random(0, dataSize))                                             // pack blobs data
-		buf.Write(expectedHeader)                                           // pack header
+		buf.Write(expectedHeader)                                                        // pack header
-		binary.Write(buf, binary.LittleEndian, uint32(len(expectedHeader))) // pack header length
+		rtest.OK(t, binary.Write(buf, binary.LittleEndian, uint32(len(expectedHeader)))) // pack header length
 
 		rd := &countingReaderAt{delegate: bytes.NewReader(buf.Bytes())}
 
@@ -104,9 +104,9 @@ func TestReadRecords(t *testing.T) {
 		expectedHeader := totalHeader[off:]
 
 		buf := &bytes.Buffer{}
-		buf.Write(rtest.Random(0, dataSize))                             // pack blobs data
+		buf.Write(rtest.Random(0, dataSize))                                          // pack blobs data
-		buf.Write(totalHeader)                                           // pack header
+		buf.Write(totalHeader)                                                        // pack header
-		binary.Write(buf, binary.LittleEndian, uint32(len(totalHeader))) // pack header length
+		rtest.OK(t, binary.Write(buf, binary.LittleEndian, uint32(len(totalHeader)))) // pack header length
 
 		rd := bytes.NewReader(buf.Bytes())
 

internal/pack/pack_test.go

@@ -39,7 +39,8 @@ func newPack(t testing.TB, k *crypto.Key, lengths []int) ([]Buf, []byte, uint) {
 	var buf bytes.Buffer
 	p := pack.NewPacker(k, &buf)
 	for _, b := range bufs {
-		p.Add(restic.TreeBlob, b.id, b.data)
+		_, err := p.Add(restic.TreeBlob, b.id, b.data)
+		rtest.OK(t, err)
 	}
 
 	_, err := p.Finalize()

internal/restic/lock_unix.go

@@ -38,7 +38,9 @@ func (l Lock) processExists() bool {
 		debug.Log("error searching for process %d: %v\n", l.PID, err)
 		return false
 	}
-	defer proc.Release()
+	defer func() {
+		_ = proc.Release()
+	}()
 
 	debug.Log("sending SIGHUP to process %d\n", l.PID)
 	err = proc.Signal(syscall.SIGHUP)

internal/restic/node_linux.go

@@ -15,7 +15,6 @@ func (node Node) restoreSymlinkTimestamps(path string, utimes [2]syscall.Timespe
 	if err != nil {
 		return errors.Wrap(err, "Open")
 	}
-	defer dir.Close()
 
 	times := []unix.Timespec{
 		{Sec: utimes[0].Sec, Nsec: utimes[0].Nsec},
@@ -25,10 +24,12 @@ func (node Node) restoreSymlinkTimestamps(path string, utimes [2]syscall.Timespe
 	err = unix.UtimesNanoAt(int(dir.Fd()), filepath.Base(path), times, unix.AT_SYMLINK_NOFOLLOW)
 
 	if err != nil {
+		// ignore subsequent errors
+		_ = dir.Close()
 		return errors.Wrap(err, "UtimesNanoAt")
 	}
 
-	return nil
+	return dir.Close()
 }
 
 func (node Node) device() int {

internal/restic/node_test.go

@@ -29,7 +29,8 @@ func BenchmarkNodeFillUser(t *testing.B) {
 	t.ResetTimer()
 
 	for i := 0; i < t.N; i++ {
-		restic.NodeFromFileInfo(path, fi)
+		_, err := restic.NodeFromFileInfo(path, fi)
+		rtest.OK(t, err)
 	}
 
 	rtest.OK(t, tempfile.Close())

internal/restorer/fileswriter.go

@@ -97,7 +97,8 @@ func (w *filesWriter) writeToFile(path string, blob []byte, offset int64, create
 	_, err = wr.WriteAt(blob, offset)
 
 	if err != nil {
-		releaseWriter(wr)
+		// ignore subsequent errors
+		_ = releaseWriter(wr)
 		return err
 	}
 

internal/restorer/preallocate_test.go

@@ -19,7 +19,9 @@ func TestPreallocate(t *testing.T) {
 			flags := os.O_CREATE | os.O_TRUNC | os.O_WRONLY
 			wr, err := os.OpenFile(path.Join(dirpath, "test"), flags, 0600)
 			test.OK(t, err)
-			defer wr.Close()
+			defer func() {
+				test.OK(t, wr.Close())
+			}()
 
 			err = preallocateFile(wr, i)
 			test.OK(t, err)

internal/restorer/restorer_test.go

@@ -74,7 +74,7 @@ func saveDir(t testing.TB, repo restic.Repository, nodes map[string]Node, inode
 			if mode == 0 {
 				mode = 0644
 			}
-			tree.Insert(&restic.Node{
+			err := tree.Insert(&restic.Node{
 				Type:    "file",
 				Mode:    mode,
 				ModTime: node.ModTime,
@@ -86,6 +86,7 @@ func saveDir(t testing.TB, repo restic.Repository, nodes map[string]Node, inode
 				Inode:   fi,
 				Links:   lc,
 			})
+			rtest.OK(t, err)
 		case Dir:
 			id := saveDir(t, repo, node.Nodes, inode)
 
@@ -94,7 +95,7 @@ func saveDir(t testing.TB, repo restic.Repository, nodes map[string]Node, inode
 				mode = 0755
 			}
 
-			tree.Insert(&restic.Node{
+			err := tree.Insert(&restic.Node{
 				Type:    "dir",
 				Mode:    mode,
 				ModTime: node.ModTime,
@@ -103,6 +104,7 @@ func saveDir(t testing.TB, repo restic.Repository, nodes map[string]Node, inode
 				GID:     uint32(os.Getgid()),
 				Subtree: &id,
 			})
+			rtest.OK(t, err)
 		default:
 			t.Fatalf("unknown node type %T", node)
 		}

internal/test/helpers.go

@@ -95,7 +95,9 @@ func Random(seed, count int) []byte {
 func SetupTarTestFixture(t testing.TB, outputDir, tarFile string) {
 	input, err := os.Open(tarFile)
 	OK(t, err)
-	defer input.Close()
+	defer func() {
+		OK(t, input.Close())
+	}()
 
 	var rd io.Reader
 	switch filepath.Ext(tarFile) {
@@ -103,7 +105,9 @@ func SetupTarTestFixture(t testing.TB, outputDir, tarFile string) {
 		r, err := gzip.NewReader(input)
 		OK(t, err)
 
-		defer r.Close()
+		defer func() {
+			OK(t, r.Close())
+		}()
 		rd = r
 	case ".bzip2":
 		rd = bzip2.NewReader(input)

internal/textfile/read_test.go

@@ -25,7 +25,8 @@ func writeTempfile(t testing.TB, data []byte) (string, func()) {
 			err = closeErr
 		}
 		if err != nil {
-			os.Remove(name)
+			// ignore subsequent errors
+			_ = os.Remove(name)
 			t.Fatal(err)
 		}
 	}()

internal/ui/termstatus/background_linux_test.go

@@ -12,8 +12,9 @@ func TestIsProcessBackground(t *testing.T) {
 	if err != nil {
 		t.Skipf("can't open terminal: %v", err)
 	}
-	defer tty.Close()
 
 	_, err = isProcessBackground(tty.Fd())
 	rtest.OK(t, err)
+
+	_ = tty.Close()
 }