add run-after-run parameter

to run shell commands after a restic command failed
breaking change: the auto initialization of a repository now happens after the "run-before" scripts
(in version 0.7.0 it was happening before)

Author: creativeprojects

README.md

@@ -16,6 +16,7 @@ With resticprofile:
 * You can create groups of profiles that will run sequentially
 * You can run shell commands before or after a backup
 * You can also run shell commands before or after running a profile (any command): useful if you need to mount your backup disk
+* You can run a shell command if an error occurred (at any time)
 * You can send a backup stream via _stdin_
 * You can start restic at a lower or higher priority (Priority Class in Windows, *nice* in all unixes) and/or _ionice_ (only available on Linux)
 
@@ -202,6 +203,9 @@ initialize = false
 # will run these scripts before and after each command (including 'backup')
 run-before = "mount /backup"
 run-after = "umount /backup"
+# if a restic command fails, the run-after won't be running
+# add this parameter to run the script in case of a failure
+run-after-fail = "umount /backup"
 
 [default.env]
 TMPDIR= "/tmp"
@@ -433,6 +437,7 @@ Flags used by resticprofile only
 * **lock**: string: specify a local lockfile
 * **run-before**: string OR list of strings
 * **run-after**: string OR list of strings
+* **run-after-fail**: string OR list of strings
 
 Flags passed to the restic command line
 

examples/linux.toml

@@ -13,6 +13,9 @@ repository = "/tmp/backup"
 password-file = "key"
 initialize = false
 no-cache = true
+run-before = "echo Started!"
+run-after = "echo Finished!"
+run-after-fail = "echo An error occured!"
 
 [src]
 inherit = "default"

main.go

@@ -15,7 +15,6 @@ import (
 	"github.com/creativeprojects/resticprofile/config"
 	"github.com/creativeprojects/resticprofile/constants"
 	"github.com/creativeprojects/resticprofile/filesearch"
-	"github.com/creativeprojects/resticprofile/lock"
 	"github.com/creativeprojects/resticprofile/priority"
 	"github.com/spf13/viper"
 )
@@ -267,29 +266,6 @@ func runProfile(global *config.Global, flags commandLineFlags, profileName strin
 	}
 }
 
-// lockRun is making sure the function is only run once by putting a lockfile on the disk
-func lockRun(filename string, run func() error) error {
-	if filename == "" {
-		// No lock
-		return run()
-	}
-	// Make sure the path to the lock exists
-	dir := filepath.Dir(filename)
-	if dir != "" {
-		err := os.MkdirAll(dir, 0755)
-		if err != nil {
-			clog.Warningf("The profile will run without a lockfile: %v", err)
-			return run()
-		}
-	}
-	runLock := lock.NewLock(filename)
-	if !runLock.TryAcquire() {
-		return fmt.Errorf("another process is already running this profile: %s", runLock.Who())
-	}
-	defer runLock.Release()
-	return run()
-}
-
 // randomBool returns true for Heads and false for Tails
 func randomBool() bool {
 	return rand.Int31n(10000) < 5000

wrapper.go

@@ -3,11 +3,13 @@ package main
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/creativeprojects/resticprofile/clog"
 	"github.com/creativeprojects/resticprofile/config"
 	"github.com/creativeprojects/resticprofile/constants"
+	"github.com/creativeprojects/resticprofile/lock"
 )
 
 type resticWrapper struct {
@@ -38,79 +40,88 @@ func newResticWrapper(
 }
 
 func (r *resticWrapper) runProfile() error {
-	if r.initialize && r.command != constants.CommandInit {
-		_ = r.runInitialize()
-		// it's ok for the initialize to error out when the repository exists
-	}
-
 	err := lockRun(r.profile.Lock, func() error {
-		var err error
-
-		// pre-profile commands
-		err = r.runProfilePreCommand()
-		if err != nil {
-			return err
-		}
+		return runOnFailure(
+			func() error {
+				var err error
 
-		// pre-commands (for backup)
-		if r.command == constants.CommandBackup {
-			// Shell commands
-			err = r.runPreCommand(r.command)
-			if err != nil {
-				return err
-			}
-			// Check
-			if r.profile.Backup != nil && r.profile.Backup.CheckBefore {
-				err = r.runCheck()
+				// pre-profile commands
+				err = r.runProfilePreCommand()
 				if err != nil {
 					return err
 				}
-			}
-			// Retention
-			if r.profile.Retention != nil && r.profile.Retention.BeforeBackup {
-				err = r.runRetention()
-				if err != nil {
-					return err
+
+				// breaking change from 0.7.0 and 0.7.1:
+				// run the initialization after the pre-profile commands
+				if r.initialize && r.command != constants.CommandInit {
+					_ = r.runInitialize()
+					// it's ok for the initialize to error out when the repository exists
 				}
-			}
-		}
 
-		// Main command
-		err = r.runCommand(r.command)
-		if err != nil {
-			return err
-		}
+				// pre-commands (for backup)
+				if r.command == constants.CommandBackup {
+					// Shell commands
+					err = r.runPreCommand(r.command)
+					if err != nil {
+						return err
+					}
+					// Check
+					if r.profile.Backup != nil && r.profile.Backup.CheckBefore {
+						err = r.runCheck()
+						if err != nil {
+							return err
+						}
+					}
+					// Retention
+					if r.profile.Retention != nil && r.profile.Retention.BeforeBackup {
+						err = r.runRetention()
+						if err != nil {
+							return err
+						}
+					}
+				}
 
-		// post-commands (for backup)
-		if r.command == constants.CommandBackup {
-			// Retention
-			if r.profile.Retention != nil && r.profile.Retention.AfterBackup {
-				err = r.runRetention()
+				// Main command
+				err = r.runCommand(r.command)
 				if err != nil {
 					return err
 				}
-			}
-			// Check
-			if r.profile.Backup != nil && r.profile.Backup.CheckAfter {
-				err = r.runCheck()
+
+				// post-commands (for backup)
+				if r.command == constants.CommandBackup {
+					// Retention
+					if r.profile.Retention != nil && r.profile.Retention.AfterBackup {
+						err = r.runRetention()
+						if err != nil {
+							return err
+						}
+					}
+					// Check
+					if r.profile.Backup != nil && r.profile.Backup.CheckAfter {
+						err = r.runCheck()
+						if err != nil {
+							return err
+						}
+					}
+					// Shell commands
+					err = r.runPostCommand(r.command)
+					if err != nil {
+						return err
+					}
+				}
+
+				// post-profile commands
+				err = r.runProfilePostCommand()
 				if err != nil {
 					return err
 				}
-			}
-			// Shell commands
-			err = r.runPostCommand(r.command)
-			if err != nil {
-				return err
-			}
-		}
-
-		// post-profile commands
-		err = r.runProfilePostCommand()
-		if err != nil {
-			return err
-		}
 
-		return nil
+				return nil
+			},
+			func() {
+				_ = r.runProfilePostFailCommand()
+			},
+		)
 	})
 	if err != nil {
 		return err
@@ -312,3 +323,35 @@ func convertIntoArgs(flags map[string][]string) []string {
 	}
 	return args
 }
+
+// lockRun is making sure the function is only run once by putting a lockfile on the disk
+func lockRun(filename string, run func() error) error {
+	if filename == "" {
+		// No lock
+		return run()
+	}
+	// Make sure the path to the lock exists
+	dir := filepath.Dir(filename)
+	if dir != "" {
+		err := os.MkdirAll(dir, 0755)
+		if err != nil {
+			clog.Warningf("The profile will run without a lockfile: %v", err)
+			return run()
+		}
+	}
+	runLock := lock.NewLock(filename)
+	if !runLock.TryAcquire() {
+		return fmt.Errorf("another process is already running this profile: %s", runLock.Who())
+	}
+	defer runLock.Release()
+	return run()
+}
+
+// runOnFailure will run the onFailure function if an error occurred in the run function
+func runOnFailure(run func() error, onFailure func()) error {
+	err := run()
+	if err != nil {
+		onFailure()
+	}
+	return err
+}

wrapper_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"os"
 	"testing"
 
 	"github.com/creativeprojects/resticprofile/config"
@@ -69,14 +70,46 @@ func TestConversionToArgs(t *testing.T) {
 func TestPreProfileScriptFail(t *testing.T) {
 	profile := config.NewProfile("name")
 	profile.RunBefore = []string{"exit 1"} // this should both work on unix shell and windows batch
-	wrapper := newResticWrapper("restic", false, profile, "test", nil, nil)
+	wrapper := newResticWrapper("echo", false, profile, "test", nil, nil)
 	err := wrapper.runProfile()
 	assert.EqualError(t, err, "exit status 1")
 }
 
-func TestRunEmptyProfile(t *testing.T) {
+func TestPostProfileScriptFail(t *testing.T) {
+	profile := config.NewProfile("name")
+	profile.RunAfter = []string{"exit 1"} // this should both work on unix shell and windows batch
+	wrapper := newResticWrapper("echo", false, profile, "test", nil, nil)
+	err := wrapper.runProfile()
+	assert.EqualError(t, err, "exit status 1")
+}
+
+func TestRunEchoProfile(t *testing.T) {
 	profile := config.NewProfile("name")
 	wrapper := newResticWrapper("echo", false, profile, "test", nil, nil)
 	err := wrapper.runProfile()
 	assert.NoError(t, err)
 }
+
+func TestPostProfileAfterFail(t *testing.T) {
+	testFile := "TestPostProfileAfterFail.txt"
+	_ = os.Remove(testFile)
+	profile := config.NewProfile("name")
+	profile.RunAfter = []string{"echo failed > " + testFile}
+	wrapper := newResticWrapper("exit", false, profile, "1", nil, nil)
+	err := wrapper.runProfile()
+	assert.EqualError(t, err, "exit status 1")
+	assert.NoFileExistsf(t, testFile, "the run-after script should not have been running")
+	_ = os.Remove(testFile)
+}
+
+func TestPostFailProfile(t *testing.T) {
+	testFile := "TestPostFailProfile.txt"
+	_ = os.Remove(testFile)
+	profile := config.NewProfile("name")
+	profile.RunAfterFail = []string{"echo failed > " + testFile}
+	wrapper := newResticWrapper("exit", false, profile, "1", nil, nil)
+	err := wrapper.runProfile()
+	assert.EqualError(t, err, "exit status 1")
+	assert.FileExistsf(t, testFile, "the run-after-fail script has not been running")
+	_ = os.Remove(testFile)
+}