Merge branch run-after-fail

Author: creativeprojects

Makefile

@@ -72,6 +72,7 @@ coverage:
 clean:
 		$(GOCLEAN)
 		rm -rf $(BINARY) $(BINARY_DARWIN) $(BINARY_LINUX) $(BINARY_PI) $(BINARY_WINDOWS) $(COVERAGE_FILE) restic_*_linux_amd64* ${BUILD}restic* dist/*
+		restic cache --cleanup
 
 test-docker:
 		docker run --rm -v "${GOPATH}":/go -w /go/src/creativeprojects/resticprofile golang:${GO_VERSION} $(GOTEST) -v $(TESTS)

README.md

@@ -48,6 +48,8 @@ For the rest of the documentation, I'll be mostly showing examples using the TOM
     * [Other unixes (Linux and BSD)](#other-unixes-linux-and-bsd)
     * [Windows](#windows)
   * [Path resolution in configuration](#path-resolution-in-configuration)
+  * [Run commands before, after success or after failure](#run-commands-before-after-success-or-after-failure)
+    * [run before and after order during a backup](#run-before-and-after-order-during-a-backup)
   * [Using resticprofile](#using-resticprofile)
   * [Command line reference](#command-line-reference)
   * [Minimum memory required](#minimum-memory-required)
@@ -72,8 +74,6 @@ For the rest of the documentation, I'll be mostly showing examples using the TOM
       * [Special case of schedule\-permission=user with sudo](#special-case-of-schedule-permissionuser-with-sudo)
     * [Daemon](#daemon)
 
-
-
 ## Requirements
 
 Since version 0.6.0, resticprofile no longer needs python installed on your machine. It is distributed as an executable (same as restic).
@@ -458,6 +458,44 @@ resticprofile will search for your configuration file in these folders:
 
 All files path in the configuration are resolved from the configuration path. The big **exception** being `source` in `backup` section where it's resolved from the current path where you started resticprofile.
 
+## Run commands before, after success or after failure
+
+resticprofile has 2 places where you can run commands around restic:
+
+- commands that will run before and after every restic command (snapshots, backup, check, forget, prune, mount, etc.). These are placed at the root of each profile.
+- commands that will only run before and after a backup: these are placed in the backup section of your profiles.
+
+Here's an example of all the external commands that you can run during the execution of a profile:
+
+```yaml
+documents:
+    inherit: default
+    run-before: "echo == run-before profile $PROFILE_NAME command $PROFILE_COMMAND"
+    run-after: "echo == run-after profile $PROFILE_NAME command $PROFILE_COMMAND"
+    run-after-fail: "echo == Error in profile $PROFILE_NAME command $PROFILE_COMMAND: $ERROR"
+    backup:
+        run-before: "echo === run-before backup profile $PROFILE_NAME command $PROFILE_COMMAND"
+        run-after: "echo === run-after backup profile $PROFILE_NAME command $PROFILE_COMMAND"
+        source: ~/Documents
+```
+
+`run-before`, `run-after` and `run-after-fail` can be a string, or an array of strings if you need to run more than one command
+
+A few environment variables will be set before running these commands:
+- `PROFILE_NAME`
+- `PROFILE_COMMAND`: backup, check, forget, etc.
+
+Additionally for the `run-after-fail` commands, the `ERROR` environment variable will be set to the latest error message.
+
+### run before and after order during a backup
+
+The commands will be running in this order **during a backup**:
+- `run-before` from the profile - if error, go to `run-after-fail`
+- `run-before` from the backup section - if error, go to `run-after-fail`
+- run the restic backup (with check and retention if configured) - if error, go to `run-after-fail`
+- `run-after` from the backup section - if error, go to `run-after-fail`
+- `run-after` from the profile - if error, go to `run-after-fail`
+
 ## Using resticprofile
 
 Here are a few examples how to run resticprofile (using the main example configuration file)

config/profile.go

@@ -172,6 +172,11 @@ func (p *Profile) GetCommandFlags(command string) map[string][]string {
 
 // GetRetentionFlags returns the flags specific to the "forget" command being run as part of a backup
 func (p *Profile) GetRetentionFlags() map[string][]string {
+	// if there was no "other" flags, the map could be un-initialized
+	if p.Retention.OtherFlags == nil {
+		p.Retention.OtherFlags = make(map[string]interface{})
+	}
+
 	flags := p.GetCommonFlags()
 	// Special case of retention: we do copy the "source" from "backup" as "path" if it hasn't been redefined in "retention"
 	if _, found := p.Retention.OtherFlags[constants.ParameterPath]; !found {

examples/linux.yaml

@@ -10,12 +10,19 @@ default:
 documents:
     inherit: default
     initialize: true
+    run-before: "echo == run-before profile $PROFILE_NAME command $PROFILE_COMMAND"
+    run-after: "echo == run-after profile $PROFILE_NAME command $PROFILE_COMMAND"
+    run-after-fail: "echo == Error in profile $PROFILE_NAME command $PROFILE_COMMAND: $ERROR"
     backup:
+        run-before: "echo === run-before backup profile $PROFILE_NAME command $PROFILE_COMMAND"
+        run-after: "echo === run-after backup profile $PROFILE_NAME command $PROFILE_COMMAND"
         tag: documents
         source: ~/Documents
-        schedule:
-        - "*:00,30" # every 15 minutes
-        - "*:15,45" # both combined together
+        schedule: "*:00,15,30,45" # every 15 minutes
+        schedule-permission: user
+        check-before: true
+    retention:
+        before-backup: true
     snapshots:
         tag: documents
 

shell/command.go

@@ -90,7 +90,7 @@ func getShellCommand(command string, args []string) (string, []string, error) {
 		if err != nil {
 			return "", nil, fmt.Errorf("cannot find shell executable (cmd.exe) in path")
 		}
-		// cmd.exe accepts that all arguments are sent one bye one
+		// cmd.exe accepts that all arguments are sent one by one
 		args := append([]string{"/C", command}, removeQuotes(args)...)
 		return shell, args, nil
 	}

wrapper.go

@@ -123,8 +123,9 @@ func (r *resticWrapper) runProfile() error {
 
 				return nil
 			},
-			func() {
-				_ = r.runProfilePostFailCommand()
+			// on failure
+			func(err error) {
+				_ = r.runProfilePostFailCommand(err)
 			},
 		)
 	})
@@ -140,30 +141,45 @@ func (r *resticWrapper) runInitialize() error {
 	rCommand := r.prepareCommand(constants.CommandInit, args)
 	// don't display any error
 	rCommand.stderr = nil
-	return runShellCommand(rCommand)
+	err := runShellCommand(rCommand)
+	if err != nil {
+		return fmt.Errorf("repository initialization on profile '%s': %w", r.profile.Name, err)
+	}
+	return nil
 }
 
 func (r *resticWrapper) runCheck() error {
 	clog.Infof("profile '%s': checking repository consistency", r.profile.Name)
 	args := convertIntoArgs(r.profile.GetCommandFlags(constants.CommandCheck))
 	rCommand := r.prepareCommand(constants.CommandCheck, args)
-	return runShellCommand(rCommand)
+	err := runShellCommand(rCommand)
+	if err != nil {
+		return fmt.Errorf("backup check on profile '%s': %w", r.profile.Name, err)
+	}
+	return nil
 }
 
 func (r *resticWrapper) runRetention() error {
 	clog.Infof("profile '%s': cleaning up repository using retention information", r.profile.Name)
 	args := convertIntoArgs(r.profile.GetRetentionFlags())
 	rCommand := r.prepareCommand(constants.CommandForget, args)
-	return runShellCommand(rCommand)
+	err := runShellCommand(rCommand)
+	if err != nil {
+		return fmt.Errorf("backup retention on profile '%s': %w", r.profile.Name, err)
+	}
+	return nil
 }
 
 func (r *resticWrapper) runCommand(command string) error {
 	clog.Infof("profile '%s': starting '%s'", r.profile.Name, command)
 	args := convertIntoArgs(r.profile.GetCommandFlags(command))
 	rCommand := r.prepareCommand(command, args)
 	err := runShellCommand(rCommand)
+	if err != nil {
+		return fmt.Errorf("%s on profile '%s': %w", r.command, r.profile.Name, err)
+	}
 	clog.Infof("profile '%s': finished '%s'", r.profile.Name, command)
-	return err
+	return nil
 }
 
 func (r *resticWrapper) prepareCommand(command string, args []string) shellCommandDefinition {
@@ -202,13 +218,18 @@ func (r *resticWrapper) runPreCommand(command string) error {
 	if r.profile.Backup == nil || r.profile.Backup.RunBefore == nil || len(r.profile.Backup.RunBefore) == 0 {
 		return nil
 	}
+	env := append(os.Environ(), r.getEnvironment()...)
+	env = append(env, r.getProfileEnvironment()...)
+
 	for i, preCommand := range r.profile.Backup.RunBefore {
 		clog.Debugf("starting pre-backup command %d/%d", i+1, len(r.profile.Backup.RunBefore))
-		env := append(os.Environ(), r.getEnvironment()...)
 		rCommand := newShellCommand(preCommand, nil, env, r.dryRun, r.sigChan)
+		// stdout are stderr are coming from the default terminal (in case they're redirected)
+		rCommand.stdout = term.GetOutput()
+		rCommand.stderr = term.GetErrorOutput()
 		err := runShellCommand(rCommand)
 		if err != nil {
-			return err
+			return fmt.Errorf("run-before backup on profile '%s': %w", r.profile.Name, err)
 		}
 	}
 	return nil
@@ -222,13 +243,18 @@ func (r *resticWrapper) runPostCommand(command string) error {
 	if r.profile.Backup == nil || r.profile.Backup.RunAfter == nil || len(r.profile.Backup.RunAfter) == 0 {
 		return nil
 	}
+	env := append(os.Environ(), r.getEnvironment()...)
+	env = append(env, r.getProfileEnvironment()...)
+
 	for i, postCommand := range r.profile.Backup.RunAfter {
 		clog.Debugf("starting post-backup command %d/%d", i+1, len(r.profile.Backup.RunAfter))
-		env := append(os.Environ(), r.getEnvironment()...)
 		rCommand := newShellCommand(postCommand, nil, env, r.dryRun, r.sigChan)
+		// stdout are stderr are coming from the default terminal (in case they're redirected)
+		rCommand.stdout = term.GetOutput()
+		rCommand.stderr = term.GetErrorOutput()
 		err := runShellCommand(rCommand)
 		if err != nil {
-			return err
+			return fmt.Errorf("run-after backup on profile '%s': %w", r.profile.Name, err)
 		}
 	}
 	return nil
@@ -238,13 +264,18 @@ func (r *resticWrapper) runProfilePreCommand() error {
 	if r.profile.RunBefore == nil || len(r.profile.RunBefore) == 0 {
 		return nil
 	}
+	env := append(os.Environ(), r.getEnvironment()...)
+	env = append(env, r.getProfileEnvironment()...)
+
 	for i, preCommand := range r.profile.RunBefore {
 		clog.Debugf("starting 'run-before' profile command %d/%d", i+1, len(r.profile.RunBefore))
-		env := append(os.Environ(), r.getEnvironment()...)
 		rCommand := newShellCommand(preCommand, nil, env, r.dryRun, r.sigChan)
+		// stdout are stderr are coming from the default terminal (in case they're redirected)
+		rCommand.stdout = term.GetOutput()
+		rCommand.stderr = term.GetErrorOutput()
 		err := runShellCommand(rCommand)
 		if err != nil {
-			return err
+			return fmt.Errorf("run-before on profile '%s': %w", r.profile.Name, err)
 		}
 	}
 	return nil
@@ -254,26 +285,37 @@ func (r *resticWrapper) runProfilePostCommand() error {
 	if r.profile.RunAfter == nil || len(r.profile.RunAfter) == 0 {
 		return nil
 	}
+	env := append(os.Environ(), r.getEnvironment()...)
+	env = append(env, r.getProfileEnvironment()...)
+
 	for i, postCommand := range r.profile.RunAfter {
 		clog.Debugf("starting 'run-after' profile command %d/%d", i+1, len(r.profile.RunAfter))
-		env := append(os.Environ(), r.getEnvironment()...)
 		rCommand := newShellCommand(postCommand, nil, env, r.dryRun, r.sigChan)
+		// stdout are stderr are coming from the default terminal (in case they're redirected)
+		rCommand.stdout = term.GetOutput()
+		rCommand.stderr = term.GetErrorOutput()
 		err := runShellCommand(rCommand)
 		if err != nil {
-			return err
+			return fmt.Errorf("run-after on profile '%s': %w", r.profile.Name, err)
 		}
 	}
 	return nil
 }
 
-func (r *resticWrapper) runProfilePostFailCommand() error {
+func (r *resticWrapper) runProfilePostFailCommand(fail error) error {
 	if r.profile.RunAfterFail == nil || len(r.profile.RunAfterFail) == 0 {
 		return nil
 	}
+	env := append(os.Environ(), r.getEnvironment()...)
+	env = append(env, r.getProfileEnvironment()...)
+	env = append(env, fmt.Sprintf("ERROR=%s", fail.Error()))
+
 	for i, postCommand := range r.profile.RunAfterFail {
 		clog.Debugf("starting 'run-after-fail' profile command %d/%d", i+1, len(r.profile.RunAfterFail))
-		env := append(os.Environ(), r.getEnvironment()...)
 		rCommand := newShellCommand(postCommand, nil, env, r.dryRun, r.sigChan)
+		// stdout are stderr are coming from the default terminal (in case they're redirected)
+		rCommand.stdout = term.GetOutput()
+		rCommand.stderr = term.GetErrorOutput()
 		err := runShellCommand(rCommand)
 		if err != nil {
 			return err
@@ -282,6 +324,7 @@ func (r *resticWrapper) runProfilePostFailCommand() error {
 	return nil
 }
 
+// getEnvironment returns the environment variables defined in the profile configuration
 func (r *resticWrapper) getEnvironment() []string {
 	if r.profile.Environment == nil || len(r.profile.Environment) == 0 {
 		return nil
@@ -298,6 +341,15 @@ func (r *resticWrapper) getEnvironment() []string {
 	return env
 }
 
+// getProfileEnvironment returns some environment variables about the current profile
+// (name and command for now)
+func (r *resticWrapper) getProfileEnvironment() []string {
+	return []string{
+		fmt.Sprintf("PROFILE_NAME=%s", r.profile.Name),
+		fmt.Sprintf("PROFILE_COMMAND=%s", r.command),
+	}
+}
+
 func convertIntoArgs(flags map[string][]string) []string {
 	args := make([]string, 0)
 
@@ -361,10 +413,10 @@ func lockRun(filename string, run func() error) error {
 }
 
 // runOnFailure will run the onFailure function if an error occurred in the run function
-func runOnFailure(run func() error, onFailure func()) error {
+func runOnFailure(run func() error, onFailure func(error)) error {
 	err := run()
 	if err != nil {
-		onFailure()
+		onFailure(err)
 	}
 	return err
 }