From a3113c609775159976ebbcd8b4edffeb9b1c61f7 Mon Sep 17 00:00:00 2001 From: Michael Eischer Date: Mon, 3 Oct 2022 14:48:14 +0200 Subject: [PATCH] restic: Change FindSnapshot functions to return the snapshot --- cmd/restic/cmd_backup.go | 20 +++---- cmd/restic/cmd_cat.go | 16 ++--- cmd/restic/cmd_diff.go | 4 +- cmd/restic/cmd_dump.go | 7 +-- cmd/restic/cmd_ls.go | 6 +- cmd/restic/cmd_restore.go | 9 +-- internal/archiver/archiver.go | 20 ++----- internal/archiver/archiver_test.go | 14 ++--- internal/archiver/testing.go | 6 +- internal/checker/checker_test.go | 6 +- internal/restic/snapshot_find.go | 78 ++++++++++++------------- internal/restic/snapshot_find_test.go | 12 ++-- internal/restorer/restorer.go | 12 +--- internal/restorer/restorer_test.go | 46 ++++++--------- internal/restorer/restorer_unix_test.go | 7 +-- 15 files changed, 103 insertions(+), 160 deletions(-) diff --git a/cmd/restic/cmd_backup.go b/cmd/restic/cmd_backup.go index f612aa1ba..57f18d057 100644 --- a/cmd/restic/cmd_backup.go +++ b/cmd/restic/cmd_backup.go @@ -504,7 +504,7 @@ func collectTargets(opts BackupOptions, args []string) (targets []string, err er // parent returns the ID of the parent snapshot. If there is none, nil is // returned. -func findParentSnapshot(ctx context.Context, repo restic.Repository, opts BackupOptions, targets []string, timeStampLimit time.Time) (parentID *restic.ID, err error) { +func findParentSnapshot(ctx context.Context, repo restic.Repository, opts BackupOptions, targets []string, timeStampLimit time.Time) (*restic.Snapshot, error) { if opts.Force { return nil, nil } @@ -513,12 +513,12 @@ func findParentSnapshot(ctx context.Context, repo restic.Repository, opts Backup if snName == "" { snName = "latest" } - id, err := restic.FindFilteredSnapshot(ctx, repo.Backend(), repo, []string{opts.Host}, []restic.TagList{}, targets, &timeStampLimit, snName) + sn, err := restic.FindFilteredSnapshot(ctx, repo.Backend(), repo, []string{opts.Host}, []restic.TagList{}, targets, &timeStampLimit, snName) // Snapshot not found is ok if no explicit parent was set if opts.Parent == "" && errors.Is(err, restic.ErrNoSnapshotFound) { err = nil } - return &id, err + return sn, err } func runBackup(ctx context.Context, opts BackupOptions, gopts GlobalOptions, term *termstatus.Terminal, args []string) error { @@ -597,16 +597,16 @@ func runBackup(ctx context.Context, opts BackupOptions, gopts GlobalOptions, ter return err } - var parentSnapshotID *restic.ID + var parentSnapshot *restic.Snapshot if !opts.Stdin { - parentSnapshotID, err = findParentSnapshot(ctx, repo, opts, targets, timeStamp) + parentSnapshot, err = findParentSnapshot(ctx, repo, opts, targets, timeStamp) if err != nil { return err } if !gopts.JSON { - if parentSnapshotID != nil { - progressPrinter.P("using parent snapshot %v\n", parentSnapshotID.Str()) + if parentSnapshot != nil { + progressPrinter.P("using parent snapshot %v\n", parentSnapshot.ID().Str()) } else { progressPrinter.P("no parent snapshot found, will read all files\n") } @@ -706,16 +706,12 @@ func runBackup(ctx context.Context, opts BackupOptions, gopts GlobalOptions, ter arch.ChangeIgnoreFlags |= archiver.ChangeIgnoreCtime } - if parentSnapshotID == nil { - parentSnapshotID = &restic.ID{} - } - snapshotOpts := archiver.SnapshotOptions{ Excludes: opts.Excludes, Tags: opts.Tags.Flatten(), Time: timeStamp, Hostname: opts.Host, - ParentSnapshot: *parentSnapshotID, + ParentSnapshot: parentSnapshot, } if !gopts.JSON { diff --git a/cmd/restic/cmd_cat.go b/cmd/restic/cmd_cat.go index 16fa968a8..ec2da564a 100644 --- a/cmd/restic/cmd_cat.go +++ b/cmd/restic/cmd_cat.go @@ -55,18 +55,10 @@ func runCat(ctx context.Context, gopts GlobalOptions, args []string) error { tpe := args[0] var id restic.ID - if tpe != "masterkey" && tpe != "config" { + if tpe != "masterkey" && tpe != "config" && tpe != "snapshot" { id, err = restic.ParseID(args[1]) if err != nil { - if tpe != "snapshot" { - return errors.Fatalf("unable to parse ID: %v\n", err) - } - - // find snapshot id with prefix - id, err = restic.FindSnapshot(ctx, repo.Backend(), args[1]) - if err != nil { - return errors.Fatalf("could not find snapshot: %v\n", err) - } + return errors.Fatalf("unable to parse ID: %v\n", err) } } @@ -88,9 +80,9 @@ func runCat(ctx context.Context, gopts GlobalOptions, args []string) error { Println(string(buf)) return nil case "snapshot": - sn, err := restic.LoadSnapshot(ctx, repo, id) + sn, err := restic.FindSnapshot(ctx, repo.Backend(), repo, args[1]) if err != nil { - return err + return errors.Fatalf("could not find snapshot: %v\n", err) } buf, err := json.MarshalIndent(sn, "", " ") diff --git a/cmd/restic/cmd_diff.go b/cmd/restic/cmd_diff.go index 2444e677b..10f408ad3 100644 --- a/cmd/restic/cmd_diff.go +++ b/cmd/restic/cmd_diff.go @@ -54,11 +54,11 @@ func init() { } func loadSnapshot(ctx context.Context, be restic.Lister, repo restic.Repository, desc string) (*restic.Snapshot, error) { - id, err := restic.FindSnapshot(ctx, be, desc) + sn, err := restic.FindSnapshot(ctx, be, repo, desc) if err != nil { return nil, errors.Fatal(err.Error()) } - return restic.LoadSnapshot(ctx, repo, id) + return sn, err } // Comparer collects all things needed to compare two snapshots. diff --git a/cmd/restic/cmd_dump.go b/cmd/restic/cmd_dump.go index 6fe531fff..5b5530d69 100644 --- a/cmd/restic/cmd_dump.go +++ b/cmd/restic/cmd_dump.go @@ -139,16 +139,11 @@ func runDump(ctx context.Context, opts DumpOptions, gopts GlobalOptions, args [] } } - id, err := restic.FindFilteredSnapshot(ctx, repo.Backend(), repo, opts.Paths, opts.Tags, opts.Hosts, nil, snapshotIDString) + sn, err := restic.FindFilteredSnapshot(ctx, repo.Backend(), repo, opts.Paths, opts.Tags, opts.Hosts, nil, snapshotIDString) if err != nil { Exitf(1, "failed to find snapshot: %v", err) } - sn, err := restic.LoadSnapshot(ctx, repo, id) - if err != nil { - Exitf(2, "loading snapshot %q failed: %v", snapshotIDString, err) - } - err = repo.LoadIndex(ctx) if err != nil { return err diff --git a/cmd/restic/cmd_ls.go b/cmd/restic/cmd_ls.go index 1cb2cfa66..7dd41ab21 100644 --- a/cmd/restic/cmd_ls.go +++ b/cmd/restic/cmd_ls.go @@ -210,11 +210,7 @@ func runLs(ctx context.Context, opts LsOptions, gopts GlobalOptions, args []stri } } - id, err := restic.FindFilteredSnapshot(ctx, snapshotLister, repo, opts.Hosts, opts.Tags, opts.Paths, nil, args[0]) - if err != nil { - return err - } - sn, err := restic.LoadSnapshot(ctx, repo, id) + sn, err := restic.FindFilteredSnapshot(ctx, snapshotLister, repo, opts.Hosts, opts.Tags, opts.Paths, nil, args[0]) if err != nil { return err } diff --git a/cmd/restic/cmd_restore.go b/cmd/restic/cmd_restore.go index b58ccc061..5ed09e27a 100644 --- a/cmd/restic/cmd_restore.go +++ b/cmd/restic/cmd_restore.go @@ -131,9 +131,9 @@ func runRestore(ctx context.Context, opts RestoreOptions, gopts GlobalOptions, a } } - id, err := restic.FindFilteredSnapshot(ctx, repo.Backend(), repo, opts.Hosts, opts.Tags, opts.Paths, nil, snapshotIDString) + sn, err := restic.FindFilteredSnapshot(ctx, repo.Backend(), repo, opts.Hosts, opts.Tags, opts.Paths, nil, snapshotIDString) if err != nil { - Exitf(1, "failed to find snapshot %q: %v", snapshotIDString, err) + Exitf(1, "failed to find snapshot: %v", err) } err = repo.LoadIndex(ctx) @@ -141,10 +141,7 @@ func runRestore(ctx context.Context, opts RestoreOptions, gopts GlobalOptions, a return err } - res, err := restorer.NewRestorer(ctx, repo, id, opts.Sparse) - if err != nil { - Exitf(2, "creating restorer failed: %v\n", err) - } + res := restorer.NewRestorer(ctx, repo, sn, opts.Sparse) totalErrors := 0 res.Error = func(location string, err error) error { diff --git a/internal/archiver/archiver.go b/internal/archiver/archiver.go index 59392e028..7e5cd5e69 100644 --- a/internal/archiver/archiver.go +++ b/internal/archiver/archiver.go @@ -676,24 +676,17 @@ type SnapshotOptions struct { Hostname string Excludes []string Time time.Time - ParentSnapshot restic.ID + ParentSnapshot *restic.Snapshot } // loadParentTree loads a tree referenced by snapshot id. If id is null, nil is returned. -func (arch *Archiver) loadParentTree(ctx context.Context, snapshotID restic.ID) *restic.Tree { - if snapshotID.IsNull() { - return nil - } - - debug.Log("load parent snapshot %v", snapshotID) - sn, err := restic.LoadSnapshot(ctx, arch.Repo, snapshotID) - if err != nil { - debug.Log("unable to load snapshot %v: %v", snapshotID, err) +func (arch *Archiver) loadParentTree(ctx context.Context, sn *restic.Snapshot) *restic.Tree { + if sn == nil { return nil } if sn.Tree == nil { - debug.Log("snapshot %v has empty tree %v", snapshotID) + debug.Log("snapshot %v has empty tree %v", *sn.ID()) return nil } @@ -801,9 +794,8 @@ func (arch *Archiver) Snapshot(ctx context.Context, targets []string, opts Snaps } sn.Excludes = opts.Excludes - if !opts.ParentSnapshot.IsNull() { - id := opts.ParentSnapshot - sn.Parent = &id + if opts.ParentSnapshot != nil { + sn.Parent = opts.ParentSnapshot.ID() } sn.Tree = &rootTreeID diff --git a/internal/archiver/archiver_test.go b/internal/archiver/archiver_test.go index 9f03514b8..86b5386be 100644 --- a/internal/archiver/archiver_test.go +++ b/internal/archiver/archiver_test.go @@ -1662,7 +1662,7 @@ func TestArchiverParent(t *testing.T) { back := restictest.Chdir(t, tempdir) defer back() - _, firstSnapshotID, err := arch.Snapshot(ctx, []string{"."}, SnapshotOptions{Time: time.Now()}) + firstSnapshot, firstSnapshotID, err := arch.Snapshot(ctx, []string{"."}, SnapshotOptions{Time: time.Now()}) if err != nil { t.Fatal(err) } @@ -1690,7 +1690,7 @@ func TestArchiverParent(t *testing.T) { opts := SnapshotOptions{ Time: time.Now(), - ParentSnapshot: firstSnapshotID, + ParentSnapshot: firstSnapshot, } _, secondSnapshotID, err := arch.Snapshot(ctx, []string{"."}, opts) if err != nil { @@ -2063,7 +2063,7 @@ func TestArchiverAbortEarlyOnError(t *testing.T) { } } -func snapshot(t testing.TB, repo restic.Repository, fs fs.FS, parent restic.ID, filename string) (restic.ID, *restic.Node) { +func snapshot(t testing.TB, repo restic.Repository, fs fs.FS, parent *restic.Snapshot, filename string) (*restic.Snapshot, *restic.Node) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() @@ -2073,7 +2073,7 @@ func snapshot(t testing.TB, repo restic.Repository, fs fs.FS, parent restic.ID, Time: time.Now(), ParentSnapshot: parent, } - snapshot, snapshotID, err := arch.Snapshot(ctx, []string{filename}, sopts) + snapshot, _, err := arch.Snapshot(ctx, []string{filename}, sopts) if err != nil { t.Fatal(err) } @@ -2088,7 +2088,7 @@ func snapshot(t testing.TB, repo restic.Repository, fs fs.FS, parent restic.ID, t.Fatalf("unable to find node for testfile in snapshot") } - return snapshotID, node + return snapshot, node } // StatFS allows overwriting what is returned by the Lstat function. @@ -2170,7 +2170,7 @@ func TestMetadataChanged(t *testing.T) { }, } - snapshotID, node2 := snapshot(t, repo, fs, restic.ID{}, "testfile") + sn, node2 := snapshot(t, repo, fs, nil, "testfile") // set some values so we can then compare the nodes want.Content = node2.Content @@ -2201,7 +2201,7 @@ func TestMetadataChanged(t *testing.T) { want.Group = "" // make another snapshot - _, node3 := snapshot(t, repo, fs, snapshotID, "testfile") + _, node3 := snapshot(t, repo, fs, sn, "testfile") // Override username and group to empty string - in case underlying system has user with UID 51234 // See https://github.com/restic/restic/issues/2372 node3.User = "" diff --git a/internal/archiver/testing.go b/internal/archiver/testing.go index 35a2d2933..234e92057 100644 --- a/internal/archiver/testing.go +++ b/internal/archiver/testing.go @@ -26,7 +26,11 @@ func TestSnapshot(t testing.TB, repo restic.Repository, path string, parent *res Tags: []string{"test"}, } if parent != nil { - opts.ParentSnapshot = *parent + sn, err := restic.LoadSnapshot(context.TODO(), arch.Repo, *parent) + if err != nil { + t.Fatal(err) + } + opts.ParentSnapshot = sn } sn, _, err := arch.Snapshot(context.TODO(), []string{path}, opts) if err != nil { diff --git a/internal/checker/checker_test.go b/internal/checker/checker_test.go index b3a736152..723ff17b3 100644 --- a/internal/checker/checker_test.go +++ b/internal/checker/checker_test.go @@ -592,11 +592,7 @@ func benchmarkSnapshotScaling(t *testing.B, newSnapshots int) { chkr, repo, cleanup := loadBenchRepository(t) defer cleanup() - snID, err := restic.FindSnapshot(context.TODO(), repo.Backend(), "51d249d2") - if err != nil { - t.Fatal(err) - } - + snID := restic.TestParseID("51d249d28815200d59e4be7b3f21a157b864dc343353df9d8e498220c2499b02") sn2, err := restic.LoadSnapshot(context.TODO(), repo, snID) if err != nil { t.Fatal(err) diff --git a/internal/restic/snapshot_find.go b/internal/restic/snapshot_find.go index 2b7e45334..d0d294a40 100644 --- a/internal/restic/snapshot_find.go +++ b/internal/restic/snapshot_find.go @@ -13,8 +13,8 @@ import ( var ErrNoSnapshotFound = errors.New("no snapshot found") // findLatestSnapshot finds latest snapshot with optional target/directory, tags, hostname, and timestamp filters. -func findLatestSnapshot(ctx context.Context, be Lister, loader LoaderUnpacked, - hosts []string, tags []TagList, paths []string, timeStampLimit *time.Time) (ID, error) { +func findLatestSnapshot(ctx context.Context, be Lister, loader LoaderUnpacked, hosts []string, + tags []TagList, paths []string, timeStampLimit *time.Time) (*Snapshot, error) { var err error absTargets := make([]string, 0, len(paths)) @@ -22,17 +22,13 @@ func findLatestSnapshot(ctx context.Context, be Lister, loader LoaderUnpacked, if !filepath.IsAbs(target) { target, err = filepath.Abs(target) if err != nil { - return ID{}, errors.Wrap(err, "Abs") + return nil, errors.Wrap(err, "Abs") } } absTargets = append(absTargets, filepath.Clean(target)) } - var ( - latest time.Time - latestID ID - found bool - ) + var latest *Snapshot err = ForAllSnapshots(ctx, be, loader, nil, func(id ID, snapshot *Snapshot, err error) error { if err != nil { @@ -43,7 +39,7 @@ func findLatestSnapshot(ctx context.Context, be Lister, loader LoaderUnpacked, return nil } - if snapshot.Time.Before(latest) { + if latest != nil && snapshot.Time.Before(latest.Time) { return nil } @@ -59,50 +55,47 @@ func findLatestSnapshot(ctx context.Context, be Lister, loader LoaderUnpacked, return nil } - latest = snapshot.Time - latestID = id - found = true + latest = snapshot return nil }) if err != nil { - return ID{}, err + return nil, err } - if !found { - return ID{}, ErrNoSnapshotFound + if latest == nil { + return nil, ErrNoSnapshotFound } - return latestID, nil + return latest, nil } // FindSnapshot takes a string and tries to find a snapshot whose ID matches // the string as closely as possible. -func FindSnapshot(ctx context.Context, be Lister, s string) (ID, error) { - +func FindSnapshot(ctx context.Context, be Lister, loader LoaderUnpacked, s string) (*Snapshot, error) { // find snapshot id with prefix name, err := Find(ctx, be, SnapshotFile, s) if err != nil { - return ID{}, err + return nil, err } - return ParseID(name) + id, err := ParseID(name) + if err != nil { + return nil, err + } + return LoadSnapshot(ctx, loader, id) } -func FindFilteredSnapshot(ctx context.Context, be Lister, loader LoaderUnpacked, hosts []string, tags []TagList, paths []string, timeStampLimit *time.Time, snapshotID string) (ID, error) { +// FindFilteredSnapshot returns either the latests from a filtered list of all snapshots or a snapshot specified by `snapshotID`. +func FindFilteredSnapshot(ctx context.Context, be Lister, loader LoaderUnpacked, hosts []string, tags []TagList, paths []string, timeStampLimit *time.Time, snapshotID string) (*Snapshot, error) { if snapshotID == "latest" { - id, err := findLatestSnapshot(ctx, be, loader, hosts, tags, paths, timeStampLimit) + sn, err := findLatestSnapshot(ctx, be, loader, hosts, tags, paths, timeStampLimit) if err == ErrNoSnapshotFound { err = fmt.Errorf("snapshot filter (Paths:%v Tags:%v Hosts:%v): %w", paths, tags, hosts, err) } - return id, err - } else { - id, err := FindSnapshot(ctx, be, snapshotID) - if err != nil { - return ID{}, err - } - return id, err + return sn, err } + return FindSnapshot(ctx, be, loader, snapshotID) } type SnapshotFindCb func(string, *Snapshot, error) error @@ -116,7 +109,7 @@ func FindFilteredSnapshots(ctx context.Context, be Lister, loader LoaderUnpacked ids := NewIDSet() // Process all snapshot IDs given as arguments. for _, s := range snapshotIDs { - var id ID + var sn *Snapshot if s == "latest" { if usedFilter { continue @@ -124,23 +117,24 @@ func FindFilteredSnapshots(ctx context.Context, be Lister, loader LoaderUnpacked usedFilter = true - id, err = findLatestSnapshot(ctx, be, loader, hosts, tags, paths, nil) + sn, err = findLatestSnapshot(ctx, be, loader, hosts, tags, paths, nil) if err == ErrNoSnapshotFound { err = errors.Errorf("no snapshot matched given filter (Paths:%v Tags:%v Hosts:%v)", paths, tags, hosts) } + if sn != nil { + ids.Insert(*sn.ID()) + } } else { - id, err = FindSnapshot(ctx, be, s) + sn, err = FindSnapshot(ctx, be, loader, s) + if err == nil { + if ids.Has(*sn.ID()) { + continue + } else { + ids.Insert(*sn.ID()) + s = sn.ID().String() + } + } } - - var sn *Snapshot - if ids.Has(id) { - continue - } else if !id.IsNull() { - ids.Insert(id) - sn, err = LoadSnapshot(ctx, loader, id) - s = id.String() - } - err = fn(s, sn, err) if err != nil { return err diff --git a/internal/restic/snapshot_find_test.go b/internal/restic/snapshot_find_test.go index e43c52c6b..c70c484b7 100644 --- a/internal/restic/snapshot_find_test.go +++ b/internal/restic/snapshot_find_test.go @@ -16,13 +16,13 @@ func TestFindLatestSnapshot(t *testing.T) { restic.TestCreateSnapshot(t, repo, parseTimeUTC("2017-07-07 07:07:07"), 1, 0) latestSnapshot := restic.TestCreateSnapshot(t, repo, parseTimeUTC("2019-09-09 09:09:09"), 1, 0) - id, err := restic.FindFilteredSnapshot(context.TODO(), repo.Backend(), repo, []string{"foo"}, []restic.TagList{}, []string{}, nil, "latest") + sn, err := restic.FindFilteredSnapshot(context.TODO(), repo.Backend(), repo, []string{"foo"}, []restic.TagList{}, []string{}, nil, "latest") if err != nil { t.Fatalf("FindLatestSnapshot returned error: %v", err) } - if id != *latestSnapshot.ID() { - t.Errorf("FindLatestSnapshot returned wrong snapshot ID: %v", id) + if *sn.ID() != *latestSnapshot.ID() { + t.Errorf("FindLatestSnapshot returned wrong snapshot ID: %v", *sn.ID()) } } @@ -36,12 +36,12 @@ func TestFindLatestSnapshotWithMaxTimestamp(t *testing.T) { maxTimestamp := parseTimeUTC("2018-08-08 08:08:08") - id, err := restic.FindFilteredSnapshot(context.TODO(), repo.Backend(), repo, []string{"foo"}, []restic.TagList{}, []string{}, &maxTimestamp, "latest") + sn, err := restic.FindFilteredSnapshot(context.TODO(), repo.Backend(), repo, []string{"foo"}, []restic.TagList{}, []string{}, &maxTimestamp, "latest") if err != nil { t.Fatalf("FindLatestSnapshot returned error: %v", err) } - if id != *desiredSnapshot.ID() { - t.Errorf("FindLatestSnapshot returned wrong snapshot ID: %v", id) + if *sn.ID() != *desiredSnapshot.ID() { + t.Errorf("FindLatestSnapshot returned wrong snapshot ID: %v", *sn.ID()) } } diff --git a/internal/restorer/restorer.go b/internal/restorer/restorer.go index 1b645a6f0..2f2e71e3d 100644 --- a/internal/restorer/restorer.go +++ b/internal/restorer/restorer.go @@ -27,22 +27,16 @@ type Restorer struct { var restorerAbortOnAllErrors = func(location string, err error) error { return err } // NewRestorer creates a restorer preloaded with the content from the snapshot id. -func NewRestorer(ctx context.Context, repo restic.Repository, id restic.ID, sparse bool) (*Restorer, error) { +func NewRestorer(ctx context.Context, repo restic.Repository, sn *restic.Snapshot, sparse bool) *Restorer { r := &Restorer{ repo: repo, sparse: sparse, Error: restorerAbortOnAllErrors, SelectFilter: func(string, string, *restic.Node) (bool, bool) { return true, true }, + sn: sn, } - var err error - - r.sn, err = restic.LoadSnapshot(ctx, repo, id) - if err != nil { - return nil, err - } - - return r, nil + return r } type treeVisitor struct { diff --git a/internal/restorer/restorer_test.go b/internal/restorer/restorer_test.go index f57868b4f..a6c80bda6 100644 --- a/internal/restorer/restorer_test.go +++ b/internal/restorer/restorer_test.go @@ -323,13 +323,10 @@ func TestRestorer(t *testing.T) { t.Run("", func(t *testing.T) { repo, cleanup := repository.TestRepository(t) defer cleanup() - _, id := saveSnapshot(t, repo, test.Snapshot) + sn, id := saveSnapshot(t, repo, test.Snapshot) t.Logf("snapshot saved as %v", id.Str()) - res, err := NewRestorer(context.TODO(), repo, id, false) - if err != nil { - t.Fatal(err) - } + res := NewRestorer(context.TODO(), repo, sn, false) tempdir, cleanup := rtest.TempDir(t) defer cleanup() @@ -366,7 +363,7 @@ func TestRestorer(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - err = res.RestoreTo(ctx, tempdir) + err := res.RestoreTo(ctx, tempdir) if err != nil { t.Fatal(err) } @@ -446,13 +443,10 @@ func TestRestorerRelative(t *testing.T) { repo, cleanup := repository.TestRepository(t) defer cleanup() - _, id := saveSnapshot(t, repo, test.Snapshot) + sn, id := saveSnapshot(t, repo, test.Snapshot) t.Logf("snapshot saved as %v", id.Str()) - res, err := NewRestorer(context.TODO(), repo, id, false) - if err != nil { - t.Fatal(err) - } + res := NewRestorer(context.TODO(), repo, sn, false) tempdir, cleanup := rtest.TempDir(t) defer cleanup() @@ -470,7 +464,7 @@ func TestRestorerRelative(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - err = res.RestoreTo(ctx, "restore") + err := res.RestoreTo(ctx, "restore") if err != nil { t.Fatal(err) } @@ -682,12 +676,9 @@ func TestRestorerTraverseTree(t *testing.T) { t.Run("", func(t *testing.T) { repo, cleanup := repository.TestRepository(t) defer cleanup() - sn, id := saveSnapshot(t, repo, test.Snapshot) + sn, _ := saveSnapshot(t, repo, test.Snapshot) - res, err := NewRestorer(context.TODO(), repo, id, false) - if err != nil { - t.Fatal(err) - } + res := NewRestorer(context.TODO(), repo, sn, false) res.SelectFilter = test.Select @@ -700,7 +691,7 @@ func TestRestorerTraverseTree(t *testing.T) { // make sure we're creating a new subdir of the tempdir target := filepath.Join(tempdir, "target") - _, err = res.traverseTree(ctx, target, string(filepath.Separator), *sn.Tree, test.Visitor(t)) + _, err := res.traverseTree(ctx, target, string(filepath.Separator), *sn.Tree, test.Visitor(t)) if err != nil { t.Fatal(err) } @@ -735,7 +726,7 @@ func TestRestorerConsistentTimestampsAndPermissions(t *testing.T) { repo, cleanup := repository.TestRepository(t) defer cleanup() - _, id := saveSnapshot(t, repo, Snapshot{ + sn, _ := saveSnapshot(t, repo, Snapshot{ Nodes: map[string]Node{ "dir": Dir{ Mode: normalizeFileMode(0750 | os.ModeDir), @@ -766,8 +757,7 @@ func TestRestorerConsistentTimestampsAndPermissions(t *testing.T) { }, }) - res, err := NewRestorer(context.TODO(), repo, id, false) - rtest.OK(t, err) + res := NewRestorer(context.TODO(), repo, sn, false) res.SelectFilter = func(item string, dstpath string, node *restic.Node) (selectedForRestore bool, childMayBeSelected bool) { switch filepath.ToSlash(item) { @@ -792,7 +782,7 @@ func TestRestorerConsistentTimestampsAndPermissions(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - err = res.RestoreTo(ctx, tempdir) + err := res.RestoreTo(ctx, tempdir) rtest.OK(t, err) var testPatterns = []struct { @@ -824,10 +814,9 @@ func TestVerifyCancel(t *testing.T) { repo, cleanup := repository.TestRepository(t) defer cleanup() - _, id := saveSnapshot(t, repo, snapshot) + sn, _ := saveSnapshot(t, repo, snapshot) - res, err := NewRestorer(context.TODO(), repo, id, false) - rtest.OK(t, err) + res := NewRestorer(context.TODO(), repo, sn, false) tempdir, cleanup := rtest.TempDir(t) defer cleanup() @@ -836,7 +825,7 @@ func TestVerifyCancel(t *testing.T) { defer cancel() rtest.OK(t, res.RestoreTo(ctx, tempdir)) - err = ioutil.WriteFile(filepath.Join(tempdir, "foo"), []byte("bar"), 0644) + err := ioutil.WriteFile(filepath.Join(tempdir, "foo"), []byte("bar"), 0644) rtest.OK(t, err) var errs []error @@ -868,12 +857,11 @@ func TestRestorerSparseFiles(t *testing.T) { rtest.OK(t, err) arch := archiver.New(repo, target, archiver.Options{}) - _, id, err := arch.Snapshot(context.Background(), []string{"/zeros"}, + sn, _, err := arch.Snapshot(context.Background(), []string{"/zeros"}, archiver.SnapshotOptions{}) rtest.OK(t, err) - res, err := NewRestorer(context.TODO(), repo, id, true) - rtest.OK(t, err) + res := NewRestorer(context.TODO(), repo, sn, true) tempdir, cleanup := rtest.TempDir(t) defer cleanup() diff --git a/internal/restorer/restorer_unix_test.go b/internal/restorer/restorer_unix_test.go index 76f86c60b..fc9ffe9a6 100644 --- a/internal/restorer/restorer_unix_test.go +++ b/internal/restorer/restorer_unix_test.go @@ -19,7 +19,7 @@ func TestRestorerRestoreEmptyHardlinkedFileds(t *testing.T) { repo, cleanup := repository.TestRepository(t) defer cleanup() - _, id := saveSnapshot(t, repo, Snapshot{ + sn, _ := saveSnapshot(t, repo, Snapshot{ Nodes: map[string]Node{ "dirtest": Dir{ Nodes: map[string]Node{ @@ -30,8 +30,7 @@ func TestRestorerRestoreEmptyHardlinkedFileds(t *testing.T) { }, }) - res, err := NewRestorer(context.TODO(), repo, id, false) - rtest.OK(t, err) + res := NewRestorer(context.TODO(), repo, sn, false) res.SelectFilter = func(item string, dstpath string, node *restic.Node) (selectedForRestore bool, childMayBeSelected bool) { return true, true @@ -43,7 +42,7 @@ func TestRestorerRestoreEmptyHardlinkedFileds(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - err = res.RestoreTo(ctx, tempdir) + err := res.RestoreTo(ctx, tempdir) rtest.OK(t, err) f1, err := os.Stat(filepath.Join(tempdir, "dirtest/file1"))