Method run

cli/command_restore.go:408–462

(ctx context.Context, rep repo.Repository)

}

func (c *commandRestore) run(ctx context.Context, rep repo.Repository) error {
	output, oerr := c.restoreOutput(ctx, rep)
	if oerr != nil {
		return errors.Wrap(oerr, "unable to initialize output")
	}

	for _, rstp := range c.restores {
		var rootEntry fs.Entry

		if rstp.isplaceholder {
			re, err := c.setupPlaceholderExpansion(ctx, rep, rstp, output)
			if err != nil {
				return errors.Wrap(err, "placeholder can't be reified")
			}

			rootEntry = re
		} else {
			source, err := c.tryToConvertPathToID(ctx, rep, rstp.source)
			if err != nil {
				return err
			}

			re, err := snapshotfs.FilesystemEntryFromIDWithPath(ctx, rep, source, c.restoreConsistentAttributes)
			if err != nil {
				return errors.Wrap(err, "unable to get filesystem entry")
			}

			rootEntry = re
		}

		restoreProgress := c.getRestoreProgress()
		progressCallback := func(_ context.Context, stats restore.Stats) {
			restoreProgress.SetCounters(stats)
		}

		st, err := restore.Entry(ctx, rep, output, rootEntry, restore.Options{
			Parallel:               c.restoreParallel,
			Incremental:            c.restoreIncremental,
			DeleteExtra:            c.restoreDeleteExtra,
			IgnoreErrors:           c.restoreIgnoreErrors,
			RestoreDirEntryAtDepth: c.restoreShallowAtDepth,
			MinSizeForPlaceholder:  c.minSizeForPlaceholder,
			ProgressCallback:       progressCallback,
		})
		if err != nil {
			return errors.Wrap(err, "error restoring")
		}

		progressCallback(ctx, st)
		restoreProgress.Flush() // Force last progress values to be printed
		printRestoreStats(ctx, &st)
	}

	return nil
}

// tryToConvertPathToID checks if the source is a path and in this case returns the ID of the snapshot
// containing the latest version available.