Allow standard copy in addition to the "special case"

resticprofile implements a "special case" for the copy command, which
does not use the "from-"-prefix and reverses the copy direction. With this
change the standard direction is used when the "from" prefix is explicitly
used.

Author: hgraeber

config/profile.go

@@ -349,71 +349,102 @@ type CopySection struct {
 	GenericSectionWithSchedule  `mapstructure:",squash"`
 	Initialize                  bool              `mapstructure:"initialize" description:"Initialize the secondary repository if missing"`
 	InitializeCopyChunkerParams maybe.Bool        `mapstructure:"initialize-copy-chunker-params" default:"true" description:"Copy chunker parameters when initializing the secondary repository"`
-	Repository                  ConfidentialValue `mapstructure:"repository" description:"Destination repository to copy snapshots to"`
-	RepositoryFile              string            `mapstructure:"repository-file" description:"File from which to read the destination repository location to copy snapshots to"`
-	PasswordFile                string            `mapstructure:"password-file" description:"File to read the destination repository password from"`
-	PasswordCommand             string            `mapstructure:"password-command" description:"Shell command to obtain the destination repository password from"`
-	KeyHint                     string            `mapstructure:"key-hint" description:"Key ID of key to try decrypting the destination repository first"`
+	FromPasswordFile            string            `mapstructure:"from-password-file" description:"File to read the source repository password from"`
+	FromPasswordCommand         string            `mapstructure:"from-password-command" description:"Shell command to obtain the source repository password from"`
+	FromRepository              ConfidentialValue `mapstructure:"from-repository" description:"Source repository to copy snapshots to"`
+	FromRepositoryFile          string            `mapstructure:"from-repository-file" description:"File from which to read the source repository location to copy snapshots to"`
+	FromKeyHint                 string            `mapstructure:"from-key-hint" description:"Key ID of key to try decrypting the source repository first"`
+	ToPasswordFile              string            `mapstructure:"password-file" description:"File to read the destination repository password from"`
+	ToPasswordCommand           string            `mapstructure:"password-command" description:"Shell command to obtain the destination repository password from"`
+	ToRepository                ConfidentialValue `mapstructure:"repository" description:"Destination repository to copy snapshots to"`
+	ToRepositoryFile            string            `mapstructure:"repository-file" description:"File from which to read the destination repository location to copy snapshots to"`
+	ToKeyHint                   string            `mapstructure:"key-hint" description:"Key ID of key to try decrypting the destination repository first"`
 	Snapshots                   []string          `mapstructure:"snapshot" description:"Snapshot IDs to copy (if empty, all snapshots are copied)"`
 }
 
 func (s *CopySection) IsEmpty() bool { return s == nil }
 
+func (s *CopySection) IsCopyTo() bool {
+	return (s.ToRepository.HasValue() || s.ToRepositoryFile != "") &&
+		!(s.FromRepository.HasValue() || s.FromRepositoryFile != "")
+}
+
 func (c *CopySection) resolve(p *Profile) {
 	c.ScheduleBaseSection.resolve(p)
 
-	c.Repository.setValue(fixPath(c.Repository.Value(), expandEnv, expandUserHome))
+	c.ToRepository.setValue(fixPath(c.ToRepository.Value(), expandEnv, expandUserHome))
 }
 
 func (c *CopySection) setRootPath(p *Profile, rootPath string) {
 	c.GenericSectionWithSchedule.setRootPath(p, rootPath)
 
-	c.PasswordFile = fixPath(c.PasswordFile, expandEnv, expandUserHome, absolutePrefix(rootPath))
-	c.RepositoryFile = fixPath(c.RepositoryFile, expandEnv, expandUserHome, absolutePrefix(rootPath))
+	c.ToPasswordFile = fixPath(c.ToPasswordFile, expandEnv, expandUserHome, absolutePrefix(rootPath))
+	c.ToRepositoryFile = fixPath(c.ToRepositoryFile, expandEnv, expandUserHome, absolutePrefix(rootPath))
+	c.FromPasswordFile = fixPath(c.FromPasswordFile, expandEnv, expandUserHome, absolutePrefix(rootPath))
+	c.FromRepositoryFile = fixPath(c.FromRepositoryFile, expandEnv, expandUserHome, absolutePrefix(rootPath))
 }
 
 func (s *CopySection) getInitFlags(profile *Profile) *shell.Args {
 	var init *InitSection
 
 	if s.InitializeCopyChunkerParams.IsTrueOrUndefined() {
-		// Source repo for CopyChunkerParams
-		init = &InitSection{
-			CopyChunkerParams:   true,
-			FromKeyHint:         profile.KeyHint,
-			FromRepository:      profile.Repository,
-			FromRepositoryFile:  profile.RepositoryFile,
-			FromPasswordFile:    profile.PasswordFile,
-			FromPasswordCommand: profile.PasswordCommand,
-		}
-		init.OtherFlags = profile.OtherFlags
+		if s.IsCopyTo() {
+			// Source repo for CopyChunkerParams
+			init = &InitSection{
+				CopyChunkerParams:   true,
+				FromKeyHint:         profile.KeyHint,
+				FromRepository:      profile.Repository,
+				FromRepositoryFile:  profile.RepositoryFile,
+				FromPasswordFile:    profile.PasswordFile,
+				FromPasswordCommand: profile.PasswordCommand,
+			}
+			init.OtherFlags = profile.OtherFlags
+		} else {
+			init = &InitSection{
+				CopyChunkerParams:   true,
+				FromKeyHint:         s.FromKeyHint,
+				FromRepository:      s.FromRepository,
+				FromRepositoryFile:  s.FromRepositoryFile,
+				FromPasswordFile:    s.FromPasswordFile,
+				FromPasswordCommand: s.FromPasswordCommand,
+			}
+		}
 	} else {
 		init = new(InitSection)
 	}
 
-	// Repo that should be initialized
 	ip := *profile
-	ip.KeyHint = s.KeyHint
-	ip.Repository = s.Repository
-	ip.RepositoryFile = s.RepositoryFile
-	ip.PasswordFile = s.PasswordFile
-	ip.PasswordCommand = s.PasswordCommand
-	ip.OtherFlags = s.OtherFlags
-
+	if s.IsCopyTo() {
+		// Repo that should be initialized
+		ip.KeyHint = s.ToKeyHint
+		ip.Repository = s.ToRepository
+		ip.RepositoryFile = s.ToRepositoryFile
+		ip.PasswordFile = s.ToPasswordFile
+		ip.PasswordCommand = s.ToPasswordCommand
+		ip.OtherFlags = s.OtherFlags
+	}
 	return init.getCommandFlags(&ip)
 }
 
 func (s *CopySection) getCommandFlags(profile *Profile) (flags *shell.Args) {
 	repositoryArgs := map[string]string{
-		constants.ParameterRepository:      s.Repository.Value(),
-		constants.ParameterRepositoryFile:  s.RepositoryFile,
-		constants.ParameterPasswordFile:    s.PasswordFile,
-		constants.ParameterPasswordCommand: s.PasswordCommand,
-		constants.ParameterKeyHint:         s.KeyHint,
+		constants.ParameterRepository:          s.ToRepository.Value(),
+		constants.ParameterRepositoryFile:      s.ToRepositoryFile,
+		constants.ParameterPasswordFile:        s.ToPasswordFile,
+		constants.ParameterPasswordCommand:     s.ToPasswordCommand,
+		constants.ParameterKeyHint:             s.ToKeyHint,
+		constants.ParameterFromRepository:      s.FromRepository.Value(),
+		constants.ParameterFromRepositoryFile:  s.FromRepositoryFile,
+		constants.ParameterFromPasswordFile:    s.FromPasswordFile,
+		constants.ParameterFromPasswordCommand: s.FromPasswordCommand,
+		constants.ParameterFromKeyHint:         s.FromKeyHint,
 	}
 
 	// Handle confidential repo in flags
-	restore := profile.replaceWithRepositoryFile(&s.Repository, &s.RepositoryFile, "-to")
-	defer restore()
+	restore1 := profile.replaceWithRepositoryFile(&s.ToRepository, &s.ToRepositoryFile, "-to")
+	defer restore1()
+	restore2 := profile.replaceWithRepositoryFile(&s.FromRepository, &s.FromRepositoryFile, "-from")
+	defer restore2()
 
 	flags = profile.GetCommonFlags()
 	addArgsFromStruct(flags, s)
@@ -427,9 +458,11 @@ func (s *CopySection) getCommandFlags(profile *Profile) (flags *shell.Args) {
 			}
 		}
 	} else {
-		// restic >= 0.14: from-repo, from-password-file, etc. is the source, repo, password-file, etc. the destination
-		for name := range maps.Keys(repositoryArgs) {
-			flags.Rename(name, fmt.Sprintf("from-%s", name))
+		if s.IsCopyTo() {
+			// restic >= 0.14: from-repo, from-password-file, etc. is the source, repo, password-file, etc. the destination
+			for name := range maps.Keys(repositoryArgs) {
+				flags.Rename(name, fmt.Sprintf("from-%s", name))
+			}
 		}
 		for name, value := range repositoryArgs {
 			if len(value) > 0 {

config/profile_test.go

@@ -313,7 +313,7 @@ func TestEnvironmentInProfileRepo(t *testing.T) {
 		profile.ResolveConfiguration()
 		assert.Equal(t, repoPath, filepath.ToSlash(profile.Repository.Value()))
 		assert.Equal(t, repoPath, filepath.ToSlash(profile.Init.FromRepository.Value()))
-		assert.Equal(t, repoPath, filepath.ToSlash(profile.Copy.Repository.Value()))
+		assert.Equal(t, repoPath, filepath.ToSlash(profile.Copy.ToRepository.Value()))
 
 		profile.SetRootPath("any")
 		assert.Equal(t, repoPath+".key", filepath.ToSlash(profile.PasswordFile))
@@ -433,7 +433,7 @@ from-password-file = "key"
 		assert.ElementsMatch(t, []string{"/wd/include-verbatim"}, profile.Backup.FilesFromVerbatim)
 		assert.ElementsMatch(t, []string{"exclude"}, profile.Backup.Exclude)
 		assert.ElementsMatch(t, []string{"iexclude"}, profile.Backup.Iexclude)
-		assert.Equal(t, "/wd/key", profile.Copy.PasswordFile)
+		assert.Equal(t, "/wd/key", profile.Copy.ToPasswordFile)
 		assert.Equal(t, []string{"/wd/key"}, profile.OtherSections[constants.CommandDump].OtherFlags["password-file"])
 		assert.Equal(t, "/wd/key", profile.Init.FromPasswordFile)
 		assert.Equal(t, "/wd/key", profile.Init.FromRepositoryFile)
@@ -1503,11 +1503,11 @@ func TestGetInitStructFields(t *testing.T) {
 
 func TestGetCopyStructFields(t *testing.T) {
 	copySection := &CopySection{
-		Repository:      NewConfidentialValue("dest-repo"),
-		RepositoryFile:  "dest-repo-file",
-		PasswordFile:    "dest-pw-file",
-		PasswordCommand: "dest-pw-command",
-		KeyHint:         "dest-key-hint",
+		ToRepository:      NewConfidentialValue("dest-repo"),
+		ToRepositoryFile:  "dest-repo-file",
+		ToPasswordFile:    "dest-pw-file",
+		ToPasswordCommand: "dest-pw-command",
+		ToKeyHint:         "dest-key-hint",
 	}
 
 	copySection.OtherFlags = map[string]any{"option": "opt=dest"}

constants/parameter.go

@@ -2,27 +2,32 @@ package constants
 
 // Parameter
 const (
-	ParameterIONice          = "ionice"
-	ParameterIONiceClass     = "ionice-class"
-	ParameterIONiceLevel     = "ionice-level"
-	ParameterNice            = "nice"
-	ParameterPriority        = "priority"
-	ParameterDefaultCommand  = "default-command"
-	ParameterInitialize      = "initialize"
-	ParameterResticBinary    = "restic-binary"
-	ParameterInherit         = "inherit"
-	ParameterHost            = "host"
-	ParameterPath            = "path"
-	ParameterTag             = "tag"
-	ParameterKeepTag         = "keep-tag"
-	ParameterGroupBy         = "group-by"
-	ParameterVerbose         = "verbose"
-	ParameterDescription     = "description"
-	ParameterVersion         = "version"
-	ParameterRetryLock       = "retry-lock"
-	ParameterRepository      = "repo"
-	ParameterRepositoryFile  = "repository-file"
-	ParameterPasswordFile    = "password-file"
-	ParameterPasswordCommand = "password-command"
-	ParameterKeyHint         = "key-hint"
+	ParameterIONice              = "ionice"
+	ParameterIONiceClass         = "ionice-class"
+	ParameterIONiceLevel         = "ionice-level"
+	ParameterNice                = "nice"
+	ParameterPriority            = "priority"
+	ParameterDefaultCommand      = "default-command"
+	ParameterInitialize          = "initialize"
+	ParameterResticBinary        = "restic-binary"
+	ParameterInherit             = "inherit"
+	ParameterHost                = "host"
+	ParameterPath                = "path"
+	ParameterTag                 = "tag"
+	ParameterKeepTag             = "keep-tag"
+	ParameterGroupBy             = "group-by"
+	ParameterVerbose             = "verbose"
+	ParameterDescription         = "description"
+	ParameterVersion             = "version"
+	ParameterRetryLock           = "retry-lock"
+	ParameterRepository          = "repo"
+	ParameterRepositoryFile      = "repository-file"
+	ParameterPasswordFile        = "password-file"
+	ParameterPasswordCommand     = "password-command"
+	ParameterKeyHint             = "key-hint"
+	ParameterFromRepository      = "from-repo"
+	ParameterFromRepositoryFile  = "from-repository-file"
+	ParameterFromPasswordFile    = "from-password-file"
+	ParameterFromPasswordCommand = "from-password-command"
+	ParameterFromKeyHint         = "from-key-hint"
 )

wrapper_test.go

@@ -1630,8 +1630,8 @@ func TestRunInitCopyCommand(t *testing.T) {
 			PasswordFile: "password_origin",
 			Copy: &config.CopySection{
 				InitializeCopyChunkerParams: copyChunkerParams,
-				Repository:                  config.NewConfidentialValue("repo_copy"),
-				PasswordFile:                "password_copy",
+				ToRepository:                config.NewConfidentialValue("repo_copy"),
+				ToPasswordFile:              "password_copy",
 			},
 		}
 		require.NoError(t, p.SetResticVersion(resticVersion))