fmt

.drone.yml

@@ -29,7 +29,7 @@ steps:
       event: tag
 
   - name: release
-    image: goreleaser/goreleaser:v1.24.0
+    image: goreleaser/goreleaser:v1.18.2
     environment:
       GITEA_TOKEN:
         from_secret: goreleaser_gitea_token

.goreleaser.yml

@@ -51,6 +51,12 @@ builds:
       - "-X 'main.Commit={{ .Commit }}'"
       - "-X 'main.Version={{ .Version }}'"
 
+archives:
+  - replacements:
+      386: i386
+      amd64: x86_64
+    format: binary
+
 checksum:
   name_template: "checksums.txt"
 

cli/app/app.go

@@ -1,7 +1,7 @@
 package app
 
 import (
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var AppCommand = cli.Command{
@@ -10,28 +10,28 @@ var AppCommand = cli.Command{
 	Usage:       "Manage apps",
 	ArgsUsage:   "<domain>",
 	Description: "Functionality for managing the life cycle of your apps",
-	Subcommands: []cli.Command{
+	Subcommands: []*cli.Command{
-		appBackupCommand,
+		&appBackupCommand,
-		appCheckCommand,
+		&appCheckCommand,
-		appCmdCommand,
+		&appCmdCommand,
-		appConfigCommand,
+		&appConfigCommand,
-		appCpCommand,
+		&appCpCommand,
-		appDeployCommand,
+		&appDeployCommand,
-		appErrorsCommand,
+		&appErrorsCommand,
-		appListCommand,
+		&appListCommand,
-		appLogsCommand,
+		&appLogsCommand,
-		appNewCommand,
+		&appNewCommand,
-		appPsCommand,
+		&appPsCommand,
-		appRemoveCommand,
+		&appRemoveCommand,
-		appRestartCommand,
+		&appRestartCommand,
-		appRestoreCommand,
+		&appRestoreCommand,
-		appRollbackCommand,
+		&appRollbackCommand,
-		appRunCommand,
+		&appRunCommand,
-		appSecretCommand,
+		&appSecretCommand,
-		appServicesCommand,
+		&appServicesCommand,
-		appUndeployCommand,
+		&appUndeployCommand,
-		appUpgradeCommand,
+		&appUpgradeCommand,
-		appVersionCommand,
+		&appVersionCommand,
-		appVolumeCommand,
+		&appVolumeCommand,
 	},
 }

cli/app/backup.go

@@ -1,414 +1,296 @@
 package app
 
 import (
-	"archive/tar"
-	"context"
 	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/recipe"
-	containerPkg "coopcloud.tech/abra/pkg/container"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/abra/pkg/upstream/container"
-	"github.com/docker/cli/cli/command"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/docker/docker/pkg/archive"
-	"github.com/klauspost/pgzip"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
-type backupConfig struct {
+var snapshot string
-	preHookCmd  string
+var snapshotFlag = &cli.StringFlag{
-	postHookCmd string
+	Name:        "snapshot, s",
-	backupPaths []string
+	Usage:       "Lists specific snapshot",
+	Destination: &snapshot,
 }
 
-var appBackupCommand = cli.Command{
+var includePath string
-	Name:      "backup",
+var includePathFlag = &cli.StringFlag{
-	Aliases:   []string{"bk"},
+	Name:        "path, p",
-	Usage:     "Run app backup",
+	Usage:       "Include path",
-	ArgsUsage: "<domain> [<service>]",
+	Destination: &includePath,
+}
+
+var resticRepo string
+var resticRepoFlag = &cli.StringFlag{
+	Name:        "repo, r",
+	Usage:       "Restic repository",
+	Destination: &resticRepo,
+}
+
+var appBackupListCommand = cli.Command{
+	Name:    "list",
+	Aliases: []string{"ls"},
 	Flags: []cli.Flag{
 		internal.DebugFlag,
 		internal.OfflineFlag,
-		internal.ChaosFlag,
+		snapshotFlag,
+		includePathFlag,
 	},
 	Before:       internal.SubCommandBefore,
+	Usage:        "List all backups",
 	BashComplete: autocomplete.AppNameComplete,
-	Description: `
-Run an app backup.
-
-A backup command and pre/post hook commands are defined in the recipe
-configuration. Abra reads this configuration and run the comands in the context
-of the deployed services. Pass <service> if you only want to back up a single
-service. All backups are placed in the ~/.abra/backups directory.
-
-A single backup file is produced for all backup paths specified for a service.
-If we have the following backup configuration:
-
-    - "backupbot.backup.path=/var/lib/foo,/var/lib/bar"
-
-And we run "abra app backup example.com app", Abra will produce a file that
-looks like:
-
-    ~/.abra/backups/example_com_app_609341138.tar.gz
-
-This file is a compressed archive which contains all backup paths. To see paths, run:
-
-    tar -tf ~/.abra/backups/example_com_app_609341138.tar.gz
-
-(Make sure to change the name of the backup file)
-
-This single file can be used to restore your app. See "abra app restore" for more.
-`,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		recipe, err := recipePkg.Get(app.Recipe, internal.Offline)
+		if err := recipe.EnsureExists(app.Recipe); err != nil {
-		if err != nil {
 			logrus.Fatal(err)
 		}
 
 		if !internal.Chaos {
-			if err := recipePkg.EnsureIsClean(app.Recipe); err != nil {
+			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
 				logrus.Fatal(err)
 			}
 
 			if !internal.Offline {
-				if err := recipePkg.EnsureUpToDate(app.Recipe); err != nil {
+				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
 					logrus.Fatal(err)
 				}
 			}
 
-			if err := recipePkg.EnsureLatest(app.Recipe); err != nil {
+			if err := recipe.EnsureLatest(app.Recipe); err != nil {
 				logrus.Fatal(err)
 			}
 		}
 
-		backupConfigs := make(map[string]backupConfig)
-		for _, service := range recipe.Config.Services {
-			if backupsEnabled, ok := service.Deploy.Labels["backupbot.backup"]; ok {
-				if backupsEnabled == "true" {
-					fullServiceName := fmt.Sprintf("%s_%s", app.StackName(), service.Name)
-					bkConfig := backupConfig{}
-
-					logrus.Debugf("backup config detected for %s", fullServiceName)
-
-					if paths, ok := service.Deploy.Labels["backupbot.backup.path"]; ok {
-						logrus.Debugf("detected backup paths for %s: %s", fullServiceName, paths)
-						bkConfig.backupPaths = strings.Split(paths, ",")
-					}
-
-					if preHookCmd, ok := service.Deploy.Labels["backupbot.backup.pre-hook"]; ok {
-						logrus.Debugf("detected pre-hook command for %s: %s", fullServiceName, preHookCmd)
-						bkConfig.preHookCmd = preHookCmd
-					}
-
-					if postHookCmd, ok := service.Deploy.Labels["backupbot.backup.post-hook"]; ok {
-						logrus.Debugf("detected post-hook command for %s: %s", fullServiceName, postHookCmd)
-						bkConfig.postHookCmd = postHookCmd
-					}
-
-					backupConfigs[service.Name] = bkConfig
-				}
-			}
-		}
-
 		cl, err := client.New(app.Server)
 		if err != nil {
 			logrus.Fatal(err)
 		}
 
-		serviceName := c.Args().Get(1)
+		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
-		if serviceName != "" {
+		if err != nil {
-			backupConfig, ok := backupConfigs[serviceName]
-			if !ok {
-				logrus.Fatalf("no backup config for %s? does %s exist?", serviceName, serviceName)
-			}
-
-			logrus.Infof("running backup for the %s service", serviceName)
-
-			if err := runBackup(cl, app, serviceName, backupConfig); err != nil {
 			logrus.Fatal(err)
 		}
-		} else {
+
-			if len(backupConfigs) == 0 {
+		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
-				logrus.Fatalf("no backup configs discovered for %s?", app.Name)
+		if snapshot != "" {
+			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
+			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
+		}
+		if includePath != "" {
+			logrus.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath)
+			execEnv = append(execEnv, fmt.Sprintf("INCLUDE_PATH=%s", includePath))
 		}
 
-			for serviceName, backupConfig := range backupConfigs {
+		if err := internal.RunBackupCmdRemote(cl, "ls", targetContainer.ID, execEnv); err != nil {
-				logrus.Infof("running backup for the %s service", serviceName)
-
-				if err := runBackup(cl, app, serviceName, backupConfig); err != nil {
 			logrus.Fatal(err)
 		}
-			}
-		}
 
 		return nil
 	},
 }
 
-// TimeStamp generates a file name friendly timestamp.
+var appBackupDownloadCommand = cli.Command{
-func TimeStamp() string {
+	Name:    "download",
-	ts := time.Now().UTC().Format(time.RFC3339)
+	Aliases: []string{"d"},
-	return strings.Replace(ts, ":", "-", -1)
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.OfflineFlag,
+		snapshotFlag,
+		includePathFlag,
+	},
+	Before:       internal.SubCommandBefore,
+	Usage:        "Download a backup",
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+
+		if err := recipe.EnsureExists(app.Recipe); err != nil {
+			logrus.Fatal(err)
+		}
+
+		if !internal.Chaos {
+			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
+				logrus.Fatal(err)
+			}
+
+			if !internal.Offline {
+				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
+					logrus.Fatal(err)
+				}
+			}
+
+			if err := recipe.EnsureLatest(app.Recipe); err != nil {
+				logrus.Fatal(err)
+			}
+		}
+
+		cl, err := client.New(app.Server)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
+		if snapshot != "" {
+			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
+			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
+		}
+		if includePath != "" {
+			logrus.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath)
+			execEnv = append(execEnv, fmt.Sprintf("INCLUDE_PATH=%s", includePath))
+		}
+
+		if err := internal.RunBackupCmdRemote(cl, "download", targetContainer.ID, execEnv); err != nil {
+			logrus.Fatal(err)
+		}
+
+		remoteBackupDir := "/tmp/backup.tar.gz"
+		currentWorkingDir := "."
+		if err = CopyFromContainer(cl, targetContainer.ID, remoteBackupDir, currentWorkingDir); err != nil {
+			logrus.Fatal(err)
+		}
+
+		fmt.Println("backup successfully downloaded to current working directory")
+
+		return nil
+	},
 }
 
-// runBackup does the actual backup logic.
+var appBackupCreateCommand = cli.Command{
-func runBackup(cl *dockerClient.Client, app config.App, serviceName string, bkConfig backupConfig) error {
+	Name:    "create",
-	if len(bkConfig.backupPaths) == 0 {
+	Aliases: []string{"c"},
-		return fmt.Errorf("backup paths are empty for %s?", serviceName)
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.OfflineFlag,
+		resticRepoFlag,
+	},
+	Before:       internal.SubCommandBefore,
+	Usage:        "Create a new backup",
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+
+		if err := recipe.EnsureExists(app.Recipe); err != nil {
+			logrus.Fatal(err)
 		}
 
-	// FIXME: avoid instantiating a new CLI
+		if !internal.Chaos {
-	dcli, err := command.NewDockerCli()
+			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
+				logrus.Fatal(err)
+			}
+
+			if !internal.Offline {
+				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
+					logrus.Fatal(err)
+				}
+			}
+
+			if err := recipe.EnsureLatest(app.Recipe); err != nil {
+				logrus.Fatal(err)
+			}
+		}
+
+		cl, err := client.New(app.Server)
 		if err != nil {
-		return err
+			logrus.Fatal(err)
 		}
 
-	filters := filters.NewArgs()
+		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
-	filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), serviceName))
-
-	targetContainer, err := containerPkg.GetContainer(context.Background(), cl, filters, true)
 		if err != nil {
-		return err
+			logrus.Fatal(err)
 		}
 
-	fullServiceName := fmt.Sprintf("%s_%s", app.StackName(), serviceName)
+		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
-	if bkConfig.preHookCmd != "" {
+		if resticRepo != "" {
-		splitCmd := internal.SafeSplit(bkConfig.preHookCmd)
+			logrus.Debugf("including RESTIC_REPO=%s in backupbot exec invocation", resticRepo)
-
+			execEnv = append(execEnv, fmt.Sprintf("RESTIC_REPO=%s", resticRepo))
-		logrus.Debugf("split pre-hook command for %s into %s", fullServiceName, splitCmd)
-
-		preHookExecOpts := types.ExecConfig{
-			AttachStderr: true,
-			AttachStdin:  true,
-			AttachStdout: true,
-			Cmd:          splitCmd,
-			Detach:       false,
-			Tty:          true,
 		}
 
-		if err := container.RunExec(dcli, cl, targetContainer.ID, &preHookExecOpts); err != nil {
+		if err := internal.RunBackupCmdRemote(cl, "create", targetContainer.ID, execEnv); err != nil {
-			return fmt.Errorf("failed to run %s on %s: %s", bkConfig.preHookCmd, targetContainer.ID, err.Error())
+			logrus.Fatal(err)
-		}
-
-		logrus.Infof("succesfully ran %s pre-hook command: %s", fullServiceName, bkConfig.preHookCmd)
-	}
-
-	var tempBackupPaths []string
-	for _, remoteBackupPath := range bkConfig.backupPaths {
-		sanitisedPath := strings.ReplaceAll(remoteBackupPath, "/", "_")
-		localBackupPath := filepath.Join(config.BACKUP_DIR, fmt.Sprintf("%s%s_%s.tar.gz", fullServiceName, sanitisedPath, TimeStamp()))
-		logrus.Debugf("temporarily backing up %s:%s to %s", fullServiceName, remoteBackupPath, localBackupPath)
-
-		logrus.Infof("backing up %s:%s", fullServiceName, remoteBackupPath)
-
-		content, _, err := cl.CopyFromContainer(context.Background(), targetContainer.ID, remoteBackupPath)
-		if err != nil {
-			logrus.Debugf("failed to copy %s from container: %s", remoteBackupPath, err.Error())
-			if err := cleanupTempArchives(tempBackupPaths); err != nil {
-				return fmt.Errorf("failed to clean up temporary archives: %s", err.Error())
-			}
-			return fmt.Errorf("failed to copy %s from container: %s", remoteBackupPath, err.Error())
-		}
-		defer content.Close()
-
-		_, srcBase := archive.SplitPathDirEntry(remoteBackupPath)
-		preArchive := archive.RebaseArchiveEntries(content, srcBase, remoteBackupPath)
-		if err := copyToFile(localBackupPath, preArchive); err != nil {
-			logrus.Debugf("failed to create tar archive (%s): %s", localBackupPath, err.Error())
-			if err := cleanupTempArchives(tempBackupPaths); err != nil {
-				return fmt.Errorf("failed to clean up temporary archives: %s", err.Error())
-			}
-			return fmt.Errorf("failed to create tar archive (%s): %s", localBackupPath, err.Error())
-		}
-
-		tempBackupPaths = append(tempBackupPaths, localBackupPath)
-	}
-
-	logrus.Infof("compressing and merging archives...")
-
-	if err := mergeArchives(tempBackupPaths, fullServiceName); err != nil {
-		logrus.Debugf("failed to merge archive files: %s", err.Error())
-		if err := cleanupTempArchives(tempBackupPaths); err != nil {
-			return fmt.Errorf("failed to clean up temporary archives: %s", err.Error())
-		}
-		return fmt.Errorf("failed to merge archive files: %s", err.Error())
-	}
-
-	if err := cleanupTempArchives(tempBackupPaths); err != nil {
-		return fmt.Errorf("failed to clean up temporary archives: %s", err.Error())
-	}
-
-	if bkConfig.postHookCmd != "" {
-		splitCmd := internal.SafeSplit(bkConfig.postHookCmd)
-
-		logrus.Debugf("split post-hook command for %s into %s", fullServiceName, splitCmd)
-
-		postHookExecOpts := types.ExecConfig{
-			AttachStderr: true,
-			AttachStdin:  true,
-			AttachStdout: true,
-			Cmd:          splitCmd,
-			Detach:       false,
-			Tty:          true,
-		}
-
-		if err := container.RunExec(dcli, cl, targetContainer.ID, &postHookExecOpts); err != nil {
-			return err
-		}
-
-		logrus.Infof("succesfully ran %s post-hook command: %s", fullServiceName, bkConfig.postHookCmd)
 		}
 
 		return nil
+	},
 }
 
-func copyToFile(outfile string, r io.Reader) error {
+var appBackupSnapshotsCommand = cli.Command{
-	tmpFile, err := os.CreateTemp(filepath.Dir(outfile), ".tar_temp")
+	Name:    "snapshots",
-	if err != nil {
+	Aliases: []string{"s"},
-		return err
+	Flags: []cli.Flag{
+		internal.DebugFlag,
+		internal.OfflineFlag,
+		snapshotFlag,
+	},
+	Before:       internal.SubCommandBefore,
+	Usage:        "List backup snapshots",
+	BashComplete: autocomplete.AppNameComplete,
+	Action: func(c *cli.Context) error {
+		app := internal.ValidateApp(c)
+
+		if err := recipe.EnsureExists(app.Recipe); err != nil {
+			logrus.Fatal(err)
 		}
 
-	tmpPath := tmpFile.Name()
+		if !internal.Chaos {
-
+			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
-	_, err = io.Copy(tmpFile, r)
+				logrus.Fatal(err)
-	tmpFile.Close()
-
-	if err != nil {
-		os.Remove(tmpPath)
-		return err
 			}
 
-	if err = os.Rename(tmpPath, outfile); err != nil {
+			if !internal.Offline {
-		os.Remove(tmpPath)
+				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-		return err
+					logrus.Fatal(err)
+				}
+			}
+
+			if err := recipe.EnsureLatest(app.Recipe); err != nil {
+				logrus.Fatal(err)
+			}
+		}
+
+		cl, err := client.New(app.Server)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
+		if snapshot != "" {
+			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
+			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
+		}
+
+		if err := internal.RunBackupCmdRemote(cl, "snapshots", targetContainer.ID, execEnv); err != nil {
+			logrus.Fatal(err)
 		}
 
 		return nil
+	},
 }
 
-func cleanupTempArchives(tarPaths []string) error {
+var appBackupCommand = cli.Command{
-	for _, tarPath := range tarPaths {
+	Name:      "backup",
-		if err := os.RemoveAll(tarPath); err != nil {
+	Aliases:   []string{"b"},
-			return err
+	Usage:     "Manage app backups",
-		}
+	ArgsUsage: "<domain>",
-
+	Subcommands: []*cli.Command{
-		logrus.Debugf("remove temporary archive file %s", tarPath)
+		&appBackupListCommand,
-	}
+		&appBackupSnapshotsCommand,
-
+		&appBackupDownloadCommand,
-	return nil
+		&appBackupCreateCommand,
-}
+	},
-
-func mergeArchives(tarPaths []string, serviceName string) error {
-	var out io.Writer
-	var cout *pgzip.Writer
-
-	localBackupPath := filepath.Join(config.BACKUP_DIR, fmt.Sprintf("%s_%s.tar.gz", serviceName, TimeStamp()))
-
-	fout, err := os.Create(localBackupPath)
-	if err != nil {
-		return fmt.Errorf("Failed to open %s: %s", localBackupPath, err)
-	}
-
-	defer fout.Close()
-	out = fout
-
-	cout = pgzip.NewWriter(out)
-	out = cout
-
-	tw := tar.NewWriter(out)
-
-	for _, tarPath := range tarPaths {
-		if err := addTar(tw, tarPath); err != nil {
-			return fmt.Errorf("failed to merge %s: %v", tarPath, err)
-		}
-	}
-
-	if err := tw.Close(); err != nil {
-		return fmt.Errorf("failed to close tar writer %v", err)
-	}
-
-	if cout != nil {
-		if err := cout.Flush(); err != nil {
-			return fmt.Errorf("failed to flush: %s", err)
-		} else if err = cout.Close(); err != nil {
-			return fmt.Errorf("failed to close compressed writer: %s", err)
-		}
-	}
-
-	logrus.Infof("backed up %s to %s", serviceName, localBackupPath)
-
-	return nil
-}
-
-func addTar(tw *tar.Writer, pth string) (err error) {
-	var tr *tar.Reader
-	var rc io.ReadCloser
-	var hdr *tar.Header
-
-	if tr, rc, err = openTarFile(pth); err != nil {
-		return
-	}
-
-	for {
-		if hdr, err = tr.Next(); err != nil {
-			if err == io.EOF {
-				err = nil
-			}
-			break
-		}
-		if err = tw.WriteHeader(hdr); err != nil {
-			break
-		} else if _, err = io.Copy(tw, tr); err != nil {
-			break
-		}
-	}
-	if err == nil {
-		err = rc.Close()
-	} else {
-		rc.Close()
-	}
-	return
-}
-
-func openTarFile(pth string) (tr *tar.Reader, rc io.ReadCloser, err error) {
-	var fin *os.File
-	var n int
-	buff := make([]byte, 1024)
-
-	if fin, err = os.Open(pth); err != nil {
-		return
-	}
-
-	if n, err = fin.Read(buff); err != nil {
-		fin.Close()
-		return
-	} else if n == 0 {
-		fin.Close()
-		err = fmt.Errorf("%s is empty", pth)
-		return
-	}
-
-	if _, err = fin.Seek(0, 0); err != nil {
-		fin.Close()
-		return
-	}
-
-	rc = fin
-	tr = tar.NewReader(rc)
-
-	return tr, rc, nil
 }

cli/app/check.go

@@ -8,7 +8,7 @@ import (
 	"coopcloud.tech/abra/pkg/recipe"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appCheckCommand = cli.Command{

cli/app/cmd.go

@@ -17,7 +17,7 @@ import (
 	"coopcloud.tech/abra/pkg/recipe"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appCmdCommand = cli.Command{
@@ -45,10 +45,10 @@ Example:
 		internal.ChaosFlag,
 	},
 	Before:      internal.SubCommandBefore,
-	Subcommands: []cli.Command{appCmdListCommand},
+	Subcommands: []*cli.Command{&appCmdListCommand},
 	BashComplete: func(ctx *cli.Context) {
 		args := ctx.Args()
-		switch len(args) {
+		switch args.Len() {
 		case 0:
 			autocomplete.AppNameComplete(ctx)
 		case 1:
@@ -84,7 +84,7 @@ Example:
 			internal.ShowSubcommandHelpAndError(c, errors.New("cannot use --local & --user together"))
 		}
 
-		hasCmdArgs, parsedCmdArgs := parseCmdArgs(c.Args(), internal.LocalCmd)
+		hasCmdArgs, parsedCmdArgs := parseCmdArgs(c.Args().Slice())
 
 		abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh")
 		if _, err := os.Stat(abraSh); err != nil {
@@ -95,7 +95,7 @@ Example:
 		}
 
 		if internal.LocalCmd {
-			if !(len(c.Args()) >= 2) {
+			if !(c.Args().Len() >= 2) {
 				internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments"))
 			}
 
@@ -131,7 +131,7 @@ Example:
 				logrus.Fatal(err)
 			}
 		} else {
-			if !(len(c.Args()) >= 3) {
+			if !(c.Args().Len() >= 3) {
 				internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments"))
 			}
 
@@ -180,23 +180,16 @@ Example:
 	},
 }
 
-func parseCmdArgs(args []string, isLocal bool) (bool, string) {
+// Parse the command arguments from the cli args.
-	var (
+// Arguments should look like this:
-		parsedCmdArgs string
+//
-		hasCmdArgs    bool
+//	DOMAIN COMMAND -- ARGUMENT1 ARGUMENT2 ...
-	)
+func parseCmdArgs(args []string) (bool, string) {
-
+	if len(args) < 4 {
-	if isLocal {
+		return false, ""
-		if len(args) > 2 {
-			return true, fmt.Sprintf("%s ", strings.Join(args[2:], " "))
 	}
-	} else {
+
-		if len(args) > 3 {
 	return true, fmt.Sprintf("%s ", strings.Join(args[3:], " "))
-		}
-	}
-
-	return hasCmdArgs, parsedCmdArgs
 }
 
 func cmdNameComplete(appName string) {

cli/app/cmd_test.go

@@ -20,7 +20,7 @@ func TestParseCmdArgs(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		ok, parsed := parseCmdArgs(test.input, false)
+		ok, parsed := parseCmdArgs(test.input)
 		if ok != test.shouldParse {
 			t.Fatalf("[%s] should not parse", strings.Join(test.input, " "))
 		}

cli/app/config.go

@@ -10,7 +10,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appConfigCommand = cli.Command{

cli/app/cp.go

@@ -22,7 +22,7 @@ import (
 	"github.com/docker/docker/errdefs"
 	"github.com/docker/docker/pkg/archive"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appCpCommand = cli.Command{
@@ -76,9 +76,9 @@ And if you want to copy that file back to your current working directory locally
 		logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(container.ID), app.Server)
 
 		if toContainer {
-			err = copyToContainer(cl, container.ID, srcPath, dstPath)
+			err = CopyToContainer(cl, container.ID, srcPath, dstPath)
 		} else {
-			err = copyFromContainer(cl, container.ID, srcPath, dstPath)
+			err = CopyFromContainer(cl, container.ID, srcPath, dstPath)
 		}
 		if err != nil {
 			logrus.Fatal(err)
@@ -106,9 +106,9 @@ func parseSrcAndDst(src, dst string) (srcPath string, dstPath string, service st
 	return "", "", "", false, errServiceMissing
 }
 
-// copyToContainer copies a file or directory from the local file system to the container.
+// CopyToContainer copies a file or directory from the local file system to the container.
 // See the possible copy modes and their documentation.
-func copyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath string) error {
+func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath string) error {
 	srcStat, err := os.Stat(srcPath)
 	if err != nil {
 		return fmt.Errorf("local %s ", err)
@@ -140,7 +140,7 @@ func copyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 		if err != nil {
 			return err
 		}
-		if err := container.RunExec(dcli, cl, containerID, &types.ExecConfig{
+		if _, err := container.RunExec(dcli, cl, containerID, &types.ExecConfig{
 			AttachStderr: true,
 			AttachStdin:  true,
 			AttachStdout: true,
@@ -179,7 +179,7 @@ func copyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 		if err != nil {
 			return err
 		}
-		if err := container.RunExec(dcli, cl, containerID, &types.ExecConfig{
+		if _, err := container.RunExec(dcli, cl, containerID, &types.ExecConfig{
 			AttachStderr: true,
 			AttachStdin:  true,
 			AttachStdout: true,
@@ -194,9 +194,9 @@ func copyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri
 	return nil
 }
 
-// copyFromContainer copies a file or directory from the given container to the local file system.
+// CopyFromContainer copies a file or directory from the given container to the local file system.
 // See the possible copy modes and their documentation.
-func copyFromContainer(cl *dockerClient.Client, containerID, srcPath, dstPath string) error {
+func CopyFromContainer(cl *dockerClient.Client, containerID, srcPath, dstPath string) error {
 	srcStat, err := cl.ContainerStatPath(context.Background(), containerID, srcPath)
 	if err != nil {
 		if errdefs.IsNotFound(err) {

cli/app/deploy.go

@@ -17,7 +17,7 @@ import (
 	"coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appDeployCommand = cli.Command{

cli/app/errors.go

@@ -17,7 +17,7 @@ import (
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appErrorsCommand = cli.Command{

cli/app/list.go

@@ -13,19 +13,21 @@ import (
 	"coopcloud.tech/abra/pkg/recipe"
 	"coopcloud.tech/tagcmp"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var status bool
 var statusFlag = &cli.BoolFlag{
-	Name:        "status, S",
+	Name:        "status",
+	Aliases:     []string{"S"},
 	Usage:       "Show app deployment status",
 	Destination: &status,
 }
 
 var recipeFilter string
 var recipeFlag = &cli.StringFlag{
-	Name:        "recipe, r",
+	Name:        "recipe",
+	Aliases:     []string{"r"},
 	Value:       "",
 	Usage:       "Show apps of a specific recipe",
 	Destination: &recipeFilter,
@@ -33,7 +35,8 @@ var recipeFlag = &cli.StringFlag{
 
 var listAppServer string
 var listAppServerFlag = &cli.StringFlag{
-	Name:        "server, s",
+	Name:        "server",
+	Aliases:     []string{"s"},
 	Value:       "",
 	Usage:       "Show apps of a specific server",
 	Destination: &listAppServer,

cli/app/logs.go

@@ -19,7 +19,7 @@ import (
 	"github.com/docker/docker/api/types/swarm"
 	dockerClient "github.com/docker/docker/client"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appLogsCommand = cli.Command{

cli/app/new.go

@@ -16,7 +16,7 @@ import (
 	"github.com/AlecAivazis/survey/v2"
 	dockerClient "github.com/docker/docker/client"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appNewDescription = `
@@ -58,7 +58,7 @@ var appNewCommand = cli.Command{
 	ArgsUsage: "[<recipe>] [<version>]",
 	BashComplete: func(ctx *cli.Context) {
 		args := ctx.Args()
-		switch len(args) {
+		switch args.Len() {
 		case 0:
 			autocomplete.RecipeNameComplete(ctx)
 		case 1:

cli/app/ps.go

@@ -17,7 +17,7 @@ import (
 	"github.com/docker/docker/api/types"
 	dockerClient "github.com/docker/docker/client"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appPsCommand = cli.Command{

cli/app/remove.go

@@ -15,7 +15,7 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/volume"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appRemoveCommand = cli.Command{

cli/app/restart.go

@@ -11,7 +11,7 @@ import (
 	upstream "coopcloud.tech/abra/pkg/upstream/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appRestartCommand = cli.Command{

cli/app/restore.go

@@ -1,223 +1,82 @@
 package app
 
 import (
-	"context"
-	"errors"
 	"fmt"
-	"os"
 
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
-	containerPkg "coopcloud.tech/abra/pkg/container"
 	"coopcloud.tech/abra/pkg/recipe"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/abra/pkg/upstream/container"
-	"github.com/docker/cli/cli/command"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/docker/docker/pkg/archive"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
-type restoreConfig struct {
+var targetPath string
-	preHookCmd  string
+var targetPathFlag = &cli.StringFlag{
-	postHookCmd string
+	Name:        "target, t",
+	Usage:       "Target path",
+	Destination: &targetPath,
 }
 
 var appRestoreCommand = cli.Command{
 	Name:      "restore",
 	Aliases:   []string{"rs"},
-	Usage:     "Run app restore",
+	Usage:     "Restore an app backup",
-	ArgsUsage: "<domain> <service> <file>",
+	ArgsUsage: "<domain> <service>",
 	Flags: []cli.Flag{
 		internal.DebugFlag,
 		internal.OfflineFlag,
-		internal.ChaosFlag,
+		targetPathFlag,
 	},
 	Before:       internal.SubCommandBefore,
 	BashComplete: autocomplete.AppNameComplete,
-	Description: `
-Run an app restore.
-
-Pre/post hook commands are defined in the recipe configuration. Abra reads this
-configuration and run the comands in the context of the service before
-restoring the backup.
-
-Unlike "abra app backup", restore must be run on a per-service basis. You can
-not restore all services in one go. Backup files produced by Abra are
-compressed archives which use absolute paths. This allows Abra to restore
-according to standard tar command logic, i.e. the backup will be restored to
-the path it was originally backed up from.
-
-Example:
-
-    abra app restore example.com app ~/.abra/backups/example_com_app_609341138.tar.gz
-`,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		recipe, err := recipe.Get(app.Recipe, internal.Offline)
+		if err := recipe.EnsureExists(app.Recipe); err != nil {
-		if err != nil {
 			logrus.Fatal(err)
 		}
 
 		if !internal.Chaos {
-			if err := recipePkg.EnsureIsClean(app.Recipe); err != nil {
+			if err := recipe.EnsureIsClean(app.Recipe); err != nil {
 				logrus.Fatal(err)
 			}
 
 			if !internal.Offline {
-				if err := recipePkg.EnsureUpToDate(app.Recipe); err != nil {
+				if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
 					logrus.Fatal(err)
 				}
 			}
 
-			if err := recipePkg.EnsureLatest(app.Recipe); err != nil {
+			if err := recipe.EnsureLatest(app.Recipe); err != nil {
 				logrus.Fatal(err)
 			}
 		}
 
-		serviceName := c.Args().Get(1)
-		if serviceName == "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("missing <service>?"))
-		}
-
-		backupPath := c.Args().Get(2)
-		if backupPath == "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("missing <file>?"))
-		}
-
-		if _, err := os.Stat(backupPath); err != nil {
-			if os.IsNotExist(err) {
-				logrus.Fatalf("%s doesn't exist?", backupPath)
-			}
-		}
-
-		restoreConfigs := make(map[string]restoreConfig)
-		for _, service := range recipe.Config.Services {
-			if restoreEnabled, ok := service.Deploy.Labels["backupbot.restore"]; ok {
-				if restoreEnabled == "true" {
-					fullServiceName := fmt.Sprintf("%s_%s", app.StackName(), service.Name)
-					rsConfig := restoreConfig{}
-
-					logrus.Debugf("restore config detected for %s", fullServiceName)
-
-					if preHookCmd, ok := service.Deploy.Labels["backupbot.restore.pre-hook"]; ok {
-						logrus.Debugf("detected pre-hook command for %s: %s", fullServiceName, preHookCmd)
-						rsConfig.preHookCmd = preHookCmd
-					}
-
-					if postHookCmd, ok := service.Deploy.Labels["backupbot.restore.post-hook"]; ok {
-						logrus.Debugf("detected post-hook command for %s: %s", fullServiceName, postHookCmd)
-						rsConfig.postHookCmd = postHookCmd
-					}
-
-					restoreConfigs[service.Name] = rsConfig
-				}
-			}
-		}
-
-		rsConfig, ok := restoreConfigs[serviceName]
-		if !ok {
-			rsConfig = restoreConfig{}
-		}
-
 		cl, err := client.New(app.Server)
 		if err != nil {
 			logrus.Fatal(err)
 		}
 
-		if err := runRestore(cl, app, backupPath, serviceName, rsConfig); err != nil {
+		targetContainer, err := internal.RetrieveBackupBotContainer(cl)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)}
+		if snapshot != "" {
+			logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot)
+			execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot))
+		}
+		if targetPath != "" {
+			logrus.Debugf("including TARGET=%s in backupbot exec invocation", targetPath)
+			execEnv = append(execEnv, fmt.Sprintf("TARGET=%s", targetPath))
+		}
+
+		if err := internal.RunBackupCmdRemote(cl, "restore", targetContainer.ID, execEnv); err != nil {
 			logrus.Fatal(err)
 		}
 
 		return nil
 	},
 }
-
-// runRestore does the actual restore logic.
-func runRestore(cl *dockerClient.Client, app config.App, backupPath, serviceName string, rsConfig restoreConfig) error {
-	// FIXME: avoid instantiating a new CLI
-	dcli, err := command.NewDockerCli()
-	if err != nil {
-		return err
-	}
-
-	filters := filters.NewArgs()
-	filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), serviceName))
-
-	targetContainer, err := containerPkg.GetContainer(context.Background(), cl, filters, true)
-	if err != nil {
-		return err
-	}
-
-	fullServiceName := fmt.Sprintf("%s_%s", app.StackName(), serviceName)
-	if rsConfig.preHookCmd != "" {
-		splitCmd := internal.SafeSplit(rsConfig.preHookCmd)
-
-		logrus.Debugf("split pre-hook command for %s into %s", fullServiceName, splitCmd)
-
-		preHookExecOpts := types.ExecConfig{
-			AttachStderr: true,
-			AttachStdin:  true,
-			AttachStdout: true,
-			Cmd:          splitCmd,
-			Detach:       false,
-			Tty:          true,
-		}
-
-		if err := container.RunExec(dcli, cl, targetContainer.ID, &preHookExecOpts); err != nil {
-			return err
-		}
-
-		logrus.Infof("succesfully ran %s pre-hook command: %s", fullServiceName, rsConfig.preHookCmd)
-	}
-
-	backupReader, err := os.Open(backupPath)
-	if err != nil {
-		return err
-	}
-
-	content, err := archive.DecompressStream(backupReader)
-	if err != nil {
-		return err
-	}
-
-	// NOTE(d1): we use absolute paths so tar knows what to do. it will restore
-	// files according to the paths set in the compressed archive
-	restorePath := "/"
-
-	copyOpts := types.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
-	if err := cl.CopyToContainer(context.Background(), targetContainer.ID, restorePath, content, copyOpts); err != nil {
-		return err
-	}
-
-	logrus.Infof("restored %s to %s", backupPath, fullServiceName)
-
-	if rsConfig.postHookCmd != "" {
-		splitCmd := internal.SafeSplit(rsConfig.postHookCmd)
-
-		logrus.Debugf("split post-hook command for %s into %s", fullServiceName, splitCmd)
-
-		postHookExecOpts := types.ExecConfig{
-			AttachStderr: true,
-			AttachStdin:  true,
-			AttachStdout: true,
-			Cmd:          splitCmd,
-			Detach:       false,
-			Tty:          true,
-		}
-
-		if err := container.RunExec(dcli, cl, targetContainer.ID, &postHookExecOpts); err != nil {
-			return err
-		}
-
-		logrus.Infof("succesfully ran %s post-hook command: %s", fullServiceName, rsConfig.postHookCmd)
-	}
-
-	return nil
-}

cli/app/rollback.go

@@ -15,7 +15,7 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appRollbackCommand = cli.Command{

cli/app/run.go

@@ -14,7 +14,7 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var user string
@@ -45,11 +45,11 @@ var appRunCommand = cli.Command{
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		if len(c.Args()) < 2 {
+		if c.Args().Len() < 2 {
 			internal.ShowSubcommandHelpAndError(c, errors.New("no <service> provided?"))
 		}
 
-		if len(c.Args()) < 3 {
+		if c.Args().Len() < 3 {
 			internal.ShowSubcommandHelpAndError(c, errors.New("no <args> provided?"))
 		}
 
@@ -68,7 +68,7 @@ var appRunCommand = cli.Command{
 			logrus.Fatal(err)
 		}
 
-		cmd := c.Args()[2:]
+		cmd := c.Args().Slice()[2:]
 		execCreateOpts := types.ExecConfig{
 			AttachStderr: true,
 			AttachStdin:  true,
@@ -91,7 +91,7 @@ var appRunCommand = cli.Command{
 			logrus.Fatal(err)
 		}
 
-		if err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
+		if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
 			logrus.Fatal(err)
 		}
 

cli/app/secret.go

@@ -17,7 +17,7 @@ import (
 	"github.com/docker/docker/api/types"
 	dockerClient "github.com/docker/docker/client"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var (
@@ -76,7 +76,7 @@ var appSecretGenerateCommand = cli.Command{
 			}
 		}
 
-		if len(c.Args()) == 1 && !allSecrets {
+		if c.Args().Len() == 1 && !allSecrets {
 			err := errors.New("missing arguments <secret>/<version> or '--all'")
 			internal.ShowSubcommandHelpAndError(c, err)
 		}
@@ -175,7 +175,7 @@ Example:
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 
-		if len(c.Args()) != 4 {
+		if c.Args().Len() != 4 {
 			internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments?"))
 		}
 
@@ -419,10 +419,10 @@ var appSecretCommand = cli.Command{
 	Aliases:   []string{"s"},
 	Usage:     "Manage app secrets",
 	ArgsUsage: "<domain>",
-	Subcommands: []cli.Command{
+	Subcommands: []*cli.Command{
-		appSecretGenerateCommand,
+		&appSecretGenerateCommand,
-		appSecretInsertCommand,
+		&appSecretInsertCommand,
-		appSecretRmCommand,
+		&appSecretRmCommand,
-		appSecretLsCommand,
+		&appSecretLsCommand,
 	},
 }

cli/app/services.go

@@ -13,7 +13,7 @@ import (
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/docker/docker/api/types"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appServicesCommand = cli.Command{

cli/app/undeploy.go

@@ -14,7 +14,7 @@ import (
 	"github.com/docker/docker/api/types/filters"
 	dockerClient "github.com/docker/docker/client"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var prune bool

cli/app/upgrade.go

@@ -15,7 +15,7 @@ import (
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appUpgradeCommand = cli.Command{

cli/app/version.go

@@ -13,7 +13,7 @@ import (
 	"github.com/docker/distribution/reference"
 	"github.com/olekukonko/tablewriter"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 func sortServiceByName(versions [][]string) func(i, j int) bool {

cli/app/volume.go

@@ -10,7 +10,7 @@ import (
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var appVolumeListCommand = cli.Command{
@@ -150,8 +150,8 @@ var appVolumeCommand = cli.Command{
 	Aliases:   []string{"vl"},
 	Usage:     "Manage app volumes",
 	ArgsUsage: "<domain>",
-	Subcommands: []cli.Command{
+	Subcommands: []*cli.Command{
-		appVolumeListCommand,
+		&appVolumeListCommand,
-		appVolumeRemoveCommand,
+		&appVolumeRemoveCommand,
 	},
 }

cli/catalogue/catalogue.go

@@ -15,7 +15,7 @@ import (
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/go-git/go-git/v5"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var catalogueGenerateCommand = cli.Command{
@@ -217,7 +217,7 @@ var CatalogueCommand = cli.Command{
 	Aliases:     []string{"c"},
 	ArgsUsage:   "<recipe>",
 	Description: "This command helps recipe packagers interact with the recipe catalogue",
-	Subcommands: []cli.Command{
+	Subcommands: []*cli.Command{
-		catalogueGenerateCommand,
+		&catalogueGenerateCommand,
 	},
 }

cli/cli.go

@@ -18,7 +18,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/web"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 // AutoCompleteCommand helps people set up auto-complete in their shells
@@ -153,13 +153,13 @@ func newAbraApp(version, commit string) *cli.App {
                          |_|
 `,
 		Version: fmt.Sprintf("%s-%s", version, commit[:7]),
-		Commands: []cli.Command{
+		Commands: []*cli.Command{
-			app.AppCommand,
+			&app.AppCommand,
-			server.ServerCommand,
+			&server.ServerCommand,
-			recipe.RecipeCommand,
+			&recipe.RecipeCommand,
-			catalogue.CatalogueCommand,
+			&catalogue.CatalogueCommand,
-			UpgradeCommand,
+			&UpgradeCommand,
-			AutoCompleteCommand,
+			&AutoCompleteCommand,
 		},
 		BashComplete: autocomplete.SubcommandComplete,
 	}

cli/internal/backup.go

@@ -1,35 +1,67 @@
 package internal
 
 import (
-	"strings"
+	"context"
+
+	"coopcloud.tech/abra/pkg/config"
+	containerPkg "coopcloud.tech/abra/pkg/container"
+	"coopcloud.tech/abra/pkg/service"
+	"coopcloud.tech/abra/pkg/upstream/container"
+	"github.com/docker/cli/cli/command"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/filters"
+	dockerClient "github.com/docker/docker/client"
+	"github.com/sirupsen/logrus"
 )
 
-// SafeSplit splits up a string into a list of commands safely.
+// RetrieveBackupBotContainer gets the deployed backupbot container.
-func SafeSplit(s string) []string {
+func RetrieveBackupBotContainer(cl *dockerClient.Client) (types.Container, error) {
-	split := strings.Split(s, " ")
+	ctx := context.Background()
-
+	chosenService, err := service.GetServiceByLabel(ctx, cl, config.BackupbotLabel, NoInput)
-	var result []string
+	if err != nil {
-	var inquote string
+		return types.Container{}, err
-	var block string
-	for _, i := range split {
-		if inquote == "" {
-			if strings.HasPrefix(i, "'") || strings.HasPrefix(i, "\"") {
-				inquote = string(i[0])
-				block = strings.TrimPrefix(i, inquote) + " "
-			} else {
-				result = append(result, i)
-			}
-		} else {
-			if !strings.HasSuffix(i, inquote) {
-				block += i + " "
-			} else {
-				block += strings.TrimSuffix(i, inquote)
-				inquote = ""
-				result = append(result, block)
-				block = ""
-			}
-		}
 	}
 
-	return result
+	logrus.Debugf("retrieved %s as backup enabled service", chosenService.Spec.Name)
+
+	filters := filters.NewArgs()
+	filters.Add("name", chosenService.Spec.Name)
+	targetContainer, err := containerPkg.GetContainer(
+		ctx,
+		cl,
+		filters,
+		NoInput,
+	)
+	if err != nil {
+		return types.Container{}, err
+	}
+
+	return targetContainer, nil
+}
+
+// RunBackupCmdRemote runs a backup related command on a remote backupbot container.
+func RunBackupCmdRemote(cl *dockerClient.Client, backupCmd string, containerID string, execEnv []string) error {
+	execBackupListOpts := types.ExecConfig{
+		AttachStderr: true,
+		AttachStdin:  true,
+		AttachStdout: true,
+		Cmd:          []string{"/usr/bin/backup", "--", backupCmd},
+		Detach:       false,
+		Env:          execEnv,
+		Tty:          true,
+	}
+
+	logrus.Debugf("running backup %s on %s with exec config %v", backupCmd, containerID, execBackupListOpts)
+
+	// FIXME: avoid instantiating a new CLI
+	dcli, err := command.NewDockerCli()
+	if err != nil {
+		return err
+	}
+
+	if _, err := container.RunExec(dcli, cl, containerID, &execBackupListOpts); err != nil {
+		return err
+	}
+
+	return nil
 }

cli/internal/cli.go

@@ -5,7 +5,7 @@ import (
 
 	logrusStack "github.com/Gurpartap/logrus-stack"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 // Secrets stores the variable from SecretsFlag
@@ -13,7 +13,8 @@ var Secrets bool
 
 // SecretsFlag turns on/off automatically generating secrets
 var SecretsFlag = &cli.BoolFlag{
-	Name:        "secrets, S",
+	Name:        "secrets",
+	Aliases:     []string{"S"},
 	Usage:       "Automatically generate secrets",
 	Destination: &Secrets,
 }
@@ -23,7 +24,8 @@ var Pass bool
 
 // PassFlag turns on/off storing generated secrets in pass
 var PassFlag = &cli.BoolFlag{
-	Name:        "pass, p",
+	Name:        "pass",
+	Aliases:     []string{"p"},
 	Usage:       "Store the generated secrets in a local pass store",
 	Destination: &Pass,
 }
@@ -33,7 +35,8 @@ var PassRemove bool
 
 // PassRemoveFlag turns on/off removing generated secrets from pass
 var PassRemoveFlag = &cli.BoolFlag{
-	Name:        "pass, p",
+	Name:        "pass",
+	Aliases:     []string{"p"},
 	Usage:       "Remove generated secrets from a local pass store",
 	Destination: &PassRemove,
 }
@@ -43,7 +46,8 @@ var Force bool
 
 // ForceFlag turns on/off force functionality.
 var ForceFlag = &cli.BoolFlag{
-	Name:        "force, f",
+	Name:        "force",
+	Aliases:     []string{"f"},
 	Usage:       "Perform action without further prompt. Use with care!",
 	Destination: &Force,
 }
@@ -53,7 +57,8 @@ var Chaos bool
 
 // ChaosFlag turns on/off chaos functionality.
 var ChaosFlag = &cli.BoolFlag{
-	Name:        "chaos, C",
+	Name:        "chaos",
+	Aliases:     []string{"C"},
 	Usage:       "Proceed with uncommitted recipes changes. Use with care!",
 	Destination: &Chaos,
 }
@@ -63,24 +68,29 @@ var Tty bool
 
 // TtyFlag turns on/off tty mode.
 var TtyFlag = &cli.BoolFlag{
-	Name:        "tty, T",
+	Name:        "tty",
+	Aliases:     []string{"T"},
 	Usage:       "Disables TTY mode to run this command from a script.",
 	Destination: &Tty,
 }
 
-var NoInput bool
+var (
-var NoInputFlag = &cli.BoolFlag{
+	NoInput     bool
-	Name:        "no-input, n",
+	NoInputFlag = &cli.BoolFlag{
+		Name:        "no-input",
+		Aliases:     []string{"n"},
 		Usage:       "Toggle non-interactive mode",
 		Destination: &NoInput,
-}
+	}
+)
 
 // Debug stores the variable from DebugFlag.
 var Debug bool
 
 // DebugFlag turns on/off verbose logging down to the DEBUG level.
 var DebugFlag = &cli.BoolFlag{
-	Name:        "debug, d",
+	Name:        "debug",
+	Aliases:     []string{"d"},
 	Destination: &Debug,
 	Usage:       "Show DEBUG messages",
 }
@@ -90,7 +100,8 @@ var Offline bool
 
 // DebugFlag turns on/off offline mode.
 var OfflineFlag = &cli.BoolFlag{
-	Name:        "offline, o",
+	Name:        "offline",
+	Aliases:     []string{"o"},
 	Destination: &Offline,
 	Usage:       "Prefer offline & filesystem access when possible",
 }
@@ -100,7 +111,8 @@ var MachineReadable bool
 
 // MachineReadableFlag turns on/off machine readable output where supported
 var MachineReadableFlag = &cli.BoolFlag{
-	Name:        "machine, m",
+	Name:        "machine",
+	Aliases:     []string{"m"},
 	Destination: &MachineReadable,
 	Usage:       "Output in a machine-readable format (where supported)",
 }
@@ -110,133 +122,185 @@ var RC bool
 
 // RCFlag chooses the latest release candidate for install
 var RCFlag = &cli.BoolFlag{
-	Name:        "rc, r",
+	Name:        "rc",
+	Aliases:     []string{"c"},
 	Destination: &RC,
 	Usage:       "Install the latest release candidate",
 }
 
-var Major bool
+var (
-var MajorFlag = &cli.BoolFlag{
+	Major     bool
-	Name:        "major, x",
+	MajorFlag = &cli.BoolFlag{
+		Name:        "major",
+		Aliases:     []string{"x"},
 		Usage:       "Increase the major part of the version",
 		Destination: &Major,
-}
+	}
+)
 
-var Minor bool
+var (
-var MinorFlag = &cli.BoolFlag{
+	Minor     bool
-	Name:        "minor, y",
+	MinorFlag = &cli.BoolFlag{
+		Name:        "minor",
+		Aliases:     []string{"y"},
 		Usage:       "Increase the minor part of the version",
 		Destination: &Minor,
-}
+	}
+)
 
-var Patch bool
+var (
-var PatchFlag = &cli.BoolFlag{
+	Patch     bool
-	Name:        "patch, z",
+	PatchFlag = &cli.BoolFlag{
+		Name:        "patch",
+		Aliases:     []string{"z"},
 		Usage:       "Increase the patch part of the version",
 		Destination: &Patch,
-}
+	}
+)
 
-var Dry bool
+var (
-var DryFlag = &cli.BoolFlag{
+	Dry     bool
-	Name:        "dry-run, r",
+	DryFlag = &cli.BoolFlag{
+		Name:        "dry-run",
+		Aliases:     []string{"r"},
 		Usage:       "Only reports changes that would be made",
 		Destination: &Dry,
-}
+	}
+)
 
-var Publish bool
+var (
-var PublishFlag = &cli.BoolFlag{
+	Publish     bool
-	Name:        "publish, p",
+	PublishFlag = &cli.BoolFlag{
+		Name:        "publish",
+		Aliases:     []string{"p"},
 		Usage:       "Publish changes to git.coopcloud.tech",
 		Destination: &Publish,
-}
+	}
+)
 
-var Domain string
+var (
-var DomainFlag = &cli.StringFlag{
+	Domain     string
-	Name:        "domain, D",
+	DomainFlag = &cli.StringFlag{
+		Name:        "domain",
+		Aliases:     []string{"D"},
 		Value:       "",
 		Usage:       "Choose a domain name",
 		Destination: &Domain,
-}
+	}
+)
 
-var NewAppServer string
+var (
-var NewAppServerFlag = &cli.StringFlag{
+	NewAppServer     string
-	Name:        "server, s",
+	NewAppServerFlag = &cli.StringFlag{
+		Name:        "server",
+		Aliases:     []string{"s"},
 		Value:       "",
 		Usage:       "Show apps of a specific server",
 		Destination: &NewAppServer,
-}
+	}
+)
 
-var NoDomainChecks bool
+var (
-var NoDomainChecksFlag = &cli.BoolFlag{
+	NoDomainChecks     bool
-	Name:        "no-domain-checks, D",
+	NoDomainChecksFlag = &cli.BoolFlag{
+		Name:        "no-domain-checks",
+		Aliases:     []string{"D"},
 		Usage:       "Disable app domain sanity checks",
 		Destination: &NoDomainChecks,
-}
+	}
+)
 
-var StdErrOnly bool
+var (
-var StdErrOnlyFlag = &cli.BoolFlag{
+	StdErrOnly     bool
-	Name:        "stderr, s",
+	StdErrOnlyFlag = &cli.BoolFlag{
+		Name:        "stderr",
+		Aliases:     []string{"s"},
 		Usage:       "Only tail stderr",
 		Destination: &StdErrOnly,
-}
+	}
+)
 
-var SinceLogs string
+var (
-var SinceLogsFlag = &cli.StringFlag{
+	SinceLogs     string
-	Name:        "since, S",
+	SinceLogsFlag = &cli.StringFlag{
+		Name:        "since",
+		Aliases:     []string{"S"},
 		Value:       "",
 		Usage:       "tail logs since YYYY-MM-DDTHH:MM:SSZ",
 		Destination: &SinceLogs,
-}
+	}
+)
 
-var DontWaitConverge bool
+var (
-var DontWaitConvergeFlag = &cli.BoolFlag{
+	DontWaitConverge     bool
-	Name:        "no-converge-checks, c",
+	DontWaitConvergeFlag = &cli.BoolFlag{
+		Name:        "no-converge-checks",
+		Aliases:     []string{"c"},
 		Usage:       "Don't wait for converge logic checks",
 		Destination: &DontWaitConverge,
-}
+	}
+)
 
-var Watch bool
+var (
-var WatchFlag = &cli.BoolFlag{
+	Watch     bool
-	Name:        "watch, w",
+	WatchFlag = &cli.BoolFlag{
+		Name:        "watch",
+		Aliases:     []string{"w"},
 		Usage:       "Watch status by polling repeatedly",
 		Destination: &Watch,
-}
+	}
+)
 
-var OnlyErrors bool
+var (
-var OnlyErrorFlag = &cli.BoolFlag{
+	OnlyErrors    bool
-	Name:        "errors, e",
+	OnlyErrorFlag = &cli.BoolFlag{
+		Name:        "errors",
+		Aliases:     []string{"e"},
 		Usage:       "Only show errors",
 		Destination: &OnlyErrors,
-}
+	}
+)
 
-var SkipUpdates bool
+var (
-var SkipUpdatesFlag = &cli.BoolFlag{
+	SkipUpdates     bool
-	Name:        "skip-updates, s",
+	SkipUpdatesFlag = &cli.BoolFlag{
+		Name:        "skip-updates",
+		Aliases:     []string{"s"},
 		Usage:       "Skip updating recipe repositories",
 		Destination: &SkipUpdates,
-}
+	}
+)
 
-var AllTags bool
+var (
-var AllTagsFlag = &cli.BoolFlag{
+	AllTags     bool
-	Name:        "all-tags, a",
+	AllTagsFlag = &cli.BoolFlag{
+		Name:        "all-tags",
+		Aliases:     []string{"a"},
 		Usage:       "List all tags, not just upgrades",
 		Destination: &AllTags,
-}
+	}
+)
 
-var LocalCmd bool
+var (
-var LocalCmdFlag = &cli.BoolFlag{
+	LocalCmd     bool
-	Name:        "local, l",
+	LocalCmdFlag = &cli.BoolFlag{
+		Name:        "local",
+		Aliases:     []string{"l"},
 		Usage:       "Run command locally",
 		Destination: &LocalCmd,
-}
+	}
+)
 
-var RemoteUser string
+var (
-var RemoteUserFlag = &cli.StringFlag{
+	RemoteUser     string
-	Name:        "user, u",
+	RemoteUserFlag = &cli.StringFlag{
+		Name:        "user",
+		Aliases:     []string{"u"},
 		Value:       "",
 		Usage:       "User to run command within a service context",
 		Destination: &RemoteUser,
-}
+	}
+)
 
 // SubCommandBefore wires up pre-action machinery (e.g. --debug handling).
 func SubCommandBefore(c *cli.Context) error {

cli/internal/command.go

@@ -60,7 +60,7 @@ func RunCmdRemote(cl *dockerClient.Client, app config.App, abraSh, serviceName,
 		Tty:          false,
 	}
 
-	if err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
+	if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
 		logrus.Infof("%s does not exist for %s, use /bin/sh as fallback", shell, app.Name)
 		shell = "/bin/sh"
 	}
@@ -85,7 +85,7 @@ func RunCmdRemote(cl *dockerClient.Client, app config.App, abraSh, serviceName,
 		execCreateOpts.Tty = false
 	}
 
-	if err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
+	if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
 		return err
 	}
 

cli/internal/errors.go

@@ -4,7 +4,7 @@ import (
 	"os"
 
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 // ShowSubcommandHelpAndError exits the program on error, logs the error to the

cli/internal/validate.go

@@ -9,7 +9,7 @@ import (
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 // ValidateRecipe ensures the recipe arg is valid.
@@ -120,9 +120,9 @@ func ValidateDomain(c *cli.Context) string {
 
 // ValidateSubCmdFlags ensures flag order conforms to correct order
 func ValidateSubCmdFlags(c *cli.Context) bool {
-	for argIdx, arg := range c.Args() {
+	for argIdx, arg := range c.Args().Slice() {
 		if !strings.HasPrefix(arg, "--") {
-			for _, flag := range c.Args()[argIdx:] {
+			for _, flag := range c.Args().Slice()[argIdx:] {
 				if strings.HasPrefix(flag, "--") {
 					return false
 				}

cli/recipe/diff.go

@@ -8,7 +8,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	gitPkg "coopcloud.tech/abra/pkg/git"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var recipeDiffCommand = cli.Command{

cli/recipe/fetch.go

@@ -6,7 +6,7 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var recipeFetchCommand = cli.Command{

cli/recipe/lint.go

@@ -9,7 +9,7 @@ import (
 	"coopcloud.tech/abra/pkg/lint"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var recipeLintCommand = cli.Command{

cli/recipe/list.go

@@ -10,7 +10,7 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var pattern string

cli/recipe/new.go

@@ -13,7 +13,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/git"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 // recipeMetadata is the recipe metadata for the README.md

cli/recipe/recipe.go

@@ -1,7 +1,7 @@
 package recipe
 
 import (
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 // RecipeCommand defines all recipe related sub-commands.
@@ -21,16 +21,16 @@ sure the recipe is in good working order and the config upgraded in a timely
 manner. Abra supports convenient automation for recipe maintainenace, see the
 "abra recipe upgrade", "abra recipe sync" and "abra recipe release" commands.
 `,
-	Subcommands: []cli.Command{
+	Subcommands: []*cli.Command{
-		recipeFetchCommand,
+		&recipeFetchCommand,
-		recipeLintCommand,
+		&recipeLintCommand,
-		recipeListCommand,
+		&recipeListCommand,
-		recipeNewCommand,
+		&recipeNewCommand,
-		recipeReleaseCommand,
+		&recipeReleaseCommand,
-		recipeSyncCommand,
+		&recipeSyncCommand,
-		recipeUpgradeCommand,
+		&recipeUpgradeCommand,
-		recipeVersionCommand,
+		&recipeVersionCommand,
-		recipeResetCommand,
+		&recipeResetCommand,
-		recipeDiffCommand,
+		&recipeDiffCommand,
 	},
 }

cli/recipe/release.go

@@ -20,7 +20,7 @@ import (
 	"github.com/docker/distribution/reference"
 	"github.com/go-git/go-git/v5"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var recipeReleaseCommand = cli.Command{

cli/recipe/reset.go

@@ -8,7 +8,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"github.com/go-git/go-git/v5"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var recipeResetCommand = cli.Command{

cli/recipe/sync.go

@@ -14,7 +14,7 @@ import (
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var recipeSyncCommand = cli.Command{

cli/recipe/upgrade.go

@@ -20,7 +20,7 @@ import (
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/distribution/reference"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 type imgPin struct {

cli/recipe/version.go

@@ -10,7 +10,7 @@ import (
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
 	"github.com/olekukonko/tablewriter"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 func sortServiceByName(versions [][]string) func(i, j int) bool {

cli/server/add.go

@@ -13,12 +13,13 @@ import (
 	"coopcloud.tech/abra/pkg/server"
 	sshPkg "coopcloud.tech/abra/pkg/ssh"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var local bool
 var localFlag = &cli.BoolFlag{
-	Name:        "local, l",
+	Name:        "local",
+	Aliases:     []string{"l"},
 	Usage:       "Use local server",
 	Destination: &local,
 }
@@ -122,7 +123,7 @@ developer machine.
 	Before:    internal.SubCommandBefore,
 	ArgsUsage: "<domain>",
 	Action: func(c *cli.Context) error {
-		if len(c.Args()) > 0 && local || !internal.ValidateSubCmdFlags(c) {
+		if c.Args().Len() > 0 && local || !internal.ValidateSubCmdFlags(c) {
 			err := errors.New("cannot use <domain> and --local together")
 			internal.ShowSubcommandHelpAndError(c, err)
 		}

cli/server/list.go

@@ -9,7 +9,7 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"github.com/docker/cli/cli/connhelper/ssh"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var problemsFilter bool

cli/server/prune.go

@@ -9,7 +9,7 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var allFilter bool

cli/server/remove.go

@@ -9,7 +9,7 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 var serverRemoveCommand = cli.Command{

cli/server/server.go

@@ -1,7 +1,7 @@
 package server
 
 import (
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 // ServerCommand defines the `abra server` command and its subcommands
@@ -9,10 +9,10 @@ var ServerCommand = cli.Command{
 	Name:    "server",
 	Aliases: []string{"s"},
 	Usage:   "Manage servers",
-	Subcommands: []cli.Command{
+	Subcommands: []*cli.Command{
-		serverAddCommand,
+		&serverAddCommand,
-		serverListCommand,
+		&serverListCommand,
-		serverRemoveCommand,
+		&serverRemoveCommand,
-		serverPruneCommand,
+		&serverPruneCommand,
 	},
 }

cli/updater/updater.go

@@ -21,24 +21,28 @@ import (
 	dockerclient "github.com/docker/docker/client"
 
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 const SERVER = "localhost"
 
-var majorUpdate bool
+var (
-var majorFlag = &cli.BoolFlag{
+	majorUpdate bool
-	Name:        "major, m",
+	majorFlag   = &cli.BoolFlag{
+		Name:        "major",
+		Aliases:     []string{"m"},
 		Usage:       "Also check for major updates",
 		Destination: &majorUpdate,
-}
+	}
 
-var updateAll bool
+	updateAll bool
-var allFlag = &cli.BoolFlag{
+	allFlag   = &cli.BoolFlag{
-	Name:        "all, a",
+		Name:        "all",
+		Aliases:     []string{"a"},
 		Usage:       "Update all deployed apps",
 		Destination: &updateAll,
-}
+	}
+)
 
 // Notify checks for available upgrades
 var Notify = cli.Command{
@@ -271,7 +275,8 @@ func getDeployedVersion(cl *dockerclient.Client, stackName string, recipeName st
 // than the deployed version. It only includes major upgrades if the "--major"
 // flag is set.
 func getAvailableUpgrades(cl *dockerclient.Client, stackName string, recipeName string,
-	deployedVersion string) ([]string, error) {
+	deployedVersion string,
+) ([]string, error) {
 	catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
 	if err != nil {
 		return nil, err
@@ -429,7 +434,8 @@ func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error {
 
 // upgrade performs all necessary steps to upgrade an app.
 func upgrade(cl *dockerclient.Client, stackName, recipeName,
-	upgradeVersion string) error {
+	upgradeVersion string,
+) error {
 	env, err := getEnv(cl, stackName)
 	if err != nil {
 		return err
@@ -474,9 +480,9 @@ func newAbraApp(version, commit string) *cli.App {
                          |_|
 `,
 		Version: fmt.Sprintf("%s-%s", version, commit[:7]),
-		Commands: []cli.Command{
+		Commands: []*cli.Command{
-			Notify,
+			&Notify,
-			UpgradeApp,
+			&UpgradeApp,
 		},
 	}
 

go.mod

@@ -25,7 +25,7 @@ require (
 require (
 	dario.cat/mergo v1.0.0 // indirect
 	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
-	github.com/BurntSushi/toml v1.0.0 // indirect
+	github.com/BurntSushi/toml v1.3.2 // indirect
 	github.com/Microsoft/go-winio v0.6.1 // indirect
 	github.com/Microsoft/hcsshim v0.9.2 // indirect
 	github.com/ProtonMail/go-crypto v0.0.0-20230828082145-3c4c8a2d2371 // indirect
@@ -33,7 +33,7 @@ require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/cloudflare/circl v1.3.3 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.1 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
 	github.com/cyphar/filepath-securejoin v0.2.4 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/distribution/reference v0.5.0 // indirect
@@ -75,9 +75,11 @@ require (
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/skeema/knownhosts v1.2.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/urfave/cli/v2 v2.27.1 // indirect
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
 	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
+	github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e // indirect
 	golang.org/x/crypto v0.14.0 // indirect
 	golang.org/x/mod v0.12.0 // indirect
 	golang.org/x/net v0.17.0 // indirect

go.sum

@@ -74,6 +74,8 @@ github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBp
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/toml v1.0.0 h1:dtDWrepsVPfW9H/4y7dDgFc2MBUSeJhlaDtK13CxFlU=
 github.com/BurntSushi/toml v1.0.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
+github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
 github.com/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4 h1:vdT7QwBhJJEVNFMBNhRSFDRCB6O16T28VhvqRgqFyn8=
@@ -311,6 +313,8 @@ github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:ma
 github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/cpuguy83/go-md2man/v2 v2.0.1 h1:r/myEWzV9lfsM1tFLgDyu0atFtJ1fXn261LKYj/3DxU=
 github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
+github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
@@ -893,6 +897,7 @@ github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6L
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
 github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
+github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww=
 github.com/russross/blackfriday v1.6.0/go.mod h1:ti0ldHuxg49ri4ksnFxlkCfN+hvslNlmVHqNRXXJNAY=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
@@ -992,6 +997,8 @@ github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtX
 github.com/urfave/cli v1.22.4/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/urfave/cli v1.22.9 h1:cv3/KhXGBGjEXLC4bH0sLuJ9BewaAbpk5oyMOveu4pw=
 github.com/urfave/cli v1.22.9/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho=
+github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
 github.com/vbatts/tar-split v0.11.2/go.mod h1:vV3ZuO2yWSVsz+pfFzDG/upWH1JhjOiEaWq6kXyQ3VI=
 github.com/vishvananda/netlink v0.0.0-20181108222139-023a6dafdcdf/go.mod h1:+SR5DhBJrl6ZM7CoCKvpw5BKroDKQ+PJqOg65H/2ktk=
 github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
@@ -1013,6 +1020,8 @@ github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17
 github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
+github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e h1:+SOyEddqYF09QP7vr7CgJ1eti3pY9Fn3LHO1M1r/0sI=
+github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

pkg/autocomplete/autocomplete.go

@@ -6,7 +6,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/recipe"
 	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
+	"github.com/urfave/cli/v2"
 )
 
 // AppNameComplete copletes app names.

pkg/config/env.go

@@ -36,6 +36,8 @@ var REPOS_BASE_URL = "https://git.coopcloud.tech/coop-cloud"
 var CATALOGUE_JSON_REPO_NAME = "recipes-catalogue-json"
 var SSH_URL_TEMPLATE = "ssh://git@git.coopcloud.tech:2222/coop-cloud/%s.git"
 
+var BackupbotLabel = "coop-cloud.backupbot.enabled"
+
 // envVarModifiers is a list of env var modifier strings. These are added to
 // env vars as comments and modify their processing by Abra, e.g. determining
 // how long secrets should be.

pkg/container/container.go

@@ -28,7 +28,7 @@ func GetContainer(c context.Context, cl *client.Client, filters filters.Args, no
 		return types.Container{}, fmt.Errorf("no containers matching the %v filter found?", filter)
 	}
 
-	if len(containers) != 1 {
+	if len(containers) > 1 {
 		var containersRaw []string
 		for _, container := range containers {
 			containerName := strings.Join(container.Names, " ")

pkg/service/service.go

@@ -14,6 +14,70 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+// GetService retrieves a service container based on a label. If prompt is true
+// and the retrievd count of service containers does not match 1, then a prompt
+// is presented to let the user choose. An error is returned when no service is
+// found.
+func GetServiceByLabel(c context.Context, cl *client.Client, label string, prompt bool) (swarm.Service, error) {
+	services, err := cl.ServiceList(c, types.ServiceListOptions{})
+	if err != nil {
+		return swarm.Service{}, err
+	}
+
+	if len(services) == 0 {
+		return swarm.Service{}, fmt.Errorf("no services deployed?")
+	}
+
+	var matchingServices []swarm.Service
+	for _, service := range services {
+		if enabled, exists := service.Spec.Labels[label]; exists && enabled == "true" {
+			matchingServices = append(matchingServices, service)
+		}
+	}
+
+	if len(matchingServices) == 0 {
+		return swarm.Service{}, fmt.Errorf("no services deployed matching label '%s'?", label)
+	}
+
+	if len(matchingServices) > 1 {
+		var servicesRaw []string
+		for _, service := range matchingServices {
+			serviceName := service.Spec.Name
+			created := formatter.HumanDuration(service.CreatedAt.Unix())
+			servicesRaw = append(servicesRaw, fmt.Sprintf("%s (created %v)", serviceName, created))
+		}
+
+		if !prompt {
+			err := fmt.Errorf("expected 1 service but found %v: %s", len(matchingServices), strings.Join(servicesRaw, " "))
+			return swarm.Service{}, err
+		}
+
+		logrus.Warnf("ambiguous service list received, prompting for input")
+
+		var response string
+		prompt := &survey.Select{
+			Message: "which service are you looking for?",
+			Options: servicesRaw,
+		}
+
+		if err := survey.AskOne(prompt, &response); err != nil {
+			return swarm.Service{}, err
+		}
+
+		chosenService := strings.TrimSpace(strings.Split(response, " ")[0])
+		for _, service := range matchingServices {
+			serviceName := strings.ToLower(service.Spec.Name)
+			if serviceName == chosenService {
+				return service, nil
+			}
+		}
+
+		logrus.Panic("failed to match chosen service")
+	}
+
+	return matchingServices[0], nil
+}
+
 // GetService retrieves a service container. If prompt is true and the retrievd
 // count of service containers does not match 1, then a prompt is presented to
 // let the user choose. A count of 0 is handled gracefully.

pkg/upstream/container/exec.go

@@ -13,7 +13,10 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-func RunExec(dockerCli command.Cli, client *apiclient.Client, containerID string, execConfig *types.ExecConfig) error {
+// RunExec runs a command on a remote container. io.Writer corresponds to the
+// command output.
+func RunExec(dockerCli command.Cli, client *apiclient.Client, containerID string,
+	execConfig *types.ExecConfig) (io.Writer, error) {
 	ctx := context.Background()
 
 	// We need to check the tty _before_ we do the ContainerExecCreate, because
@@ -21,22 +24,22 @@ func RunExec(dockerCli command.Cli, client *apiclient.Client, containerID string
 	// there's no easy way to clean those up). But also in order to make "not
 	// exist" errors take precedence we do a dummy inspect first.
 	if _, err := client.ContainerInspect(ctx, containerID); err != nil {
-		return err
+		return nil, err
 	}
 	if !execConfig.Detach {
 		if err := dockerCli.In().CheckTty(execConfig.AttachStdin, execConfig.Tty); err != nil {
-			return err
+			return nil, err
 		}
 	}
 
 	response, err := client.ContainerExecCreate(ctx, containerID, *execConfig)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	execID := response.ID
 	if execID == "" {
-		return errors.New("exec ID empty")
+		return nil, errors.New("exec ID empty")
 	}
 
 	if execConfig.Detach {
@@ -44,13 +47,13 @@ func RunExec(dockerCli command.Cli, client *apiclient.Client, containerID string
 			Detach: execConfig.Detach,
 			Tty:    execConfig.Tty,
 		}
-		return client.ContainerExecStart(ctx, execID, execStartCheck)
+		return nil, client.ContainerExecStart(ctx, execID, execStartCheck)
 	}
 	return interactiveExec(ctx, dockerCli, client, execConfig, execID)
 }
 
 func interactiveExec(ctx context.Context, dockerCli command.Cli, client *apiclient.Client,
-	execConfig *types.ExecConfig, execID string) error {
+	execConfig *types.ExecConfig, execID string) (io.Writer, error) {
 	// Interactive exec requested.
 	var (
 		out, stderr io.Writer
@@ -76,7 +79,7 @@ func interactiveExec(ctx context.Context, dockerCli command.Cli, client *apiclie
 	}
 	resp, err := client.ContainerExecAttach(ctx, execID, execStartCheck)
 	if err != nil {
-		return err
+		return out, err
 	}
 	defer resp.Close()
 
@@ -107,10 +110,10 @@ func interactiveExec(ctx context.Context, dockerCli command.Cli, client *apiclie
 
 	if err := <-errCh; err != nil {
 		logrus.Debugf("Error hijack: %s", err)
-		return err
+		return out, err
 	}
 
-	return getExecExitStatus(ctx, client, execID)
+	return out, getExecExitStatus(ctx, client, execID)
 }
 
 func getExecExitStatus(ctx context.Context, client apiclient.ContainerAPIClient, execID string) error {

scripts/installer/installer

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-ABRA_VERSION="0.9.0-beta"
+ABRA_VERSION="0.8.1-beta"
 ABRA_RELEASE_URL="https://git.coopcloud.tech/api/v1/repos/coop-cloud/abra/releases/tags/$ABRA_VERSION"
 RC_VERSION="0.8.0-rc1-beta"
 RC_VERSION_URL="https://git.coopcloud.tech/api/v1/repos/coop-cloud/abra/releases/tags/$RC_VERSION"

tests/integration/helpers/app.bash

@@ -1,17 +1,18 @@
 #!/usr/bin/env bash
 
 _new_app() {
-  run $ABRA app new "$TEST_RECIPE" \
+  run $ABRA app new \
     --no-input \
     --server "$TEST_SERVER" \
     --domain "$TEST_APP_DOMAIN" \
-    --secrets
+    --secrets \
+    "$TEST_RECIPE"
   assert_success
   assert_exists "$ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env"
 }
 
 _deploy_app() {
-  run $ABRA app deploy "$TEST_APP_DOMAIN" --no-input
+  run $ABRA app deploy --no-input "$TEST_APP_DOMAIN"
   assert_success
 
   run $ABRA app ls --server "$TEST_SERVER" --status
@@ -21,7 +22,7 @@ _deploy_app() {
 }
 
 _undeploy_app() {
-  run $ABRA app undeploy "$TEST_APP_DOMAIN" --no-input
+  run $ABRA app undeploy --no-input "$TEST_APP_DOMAIN"
   assert_success
 
   run $ABRA app ls --server "$TEST_SERVER" --status
@@ -34,10 +35,10 @@ _rm_app() {
   # NOTE(d1): not asserting outcomes on teardown here since some might fail
   # depending on what the test created. all commands run through anyway
   if [[ -f "$ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env" ]]; then
-    run $ABRA app undeploy "$TEST_APP_DOMAIN" --no-input
+    run $ABRA app undeploy --no-input "$TEST_APP_DOMAIN"
-    run $ABRA app secret remove "$TEST_APP_DOMAIN" --all --no-input
+    run $ABRA app secret remove --all --no-input "$TEST_APP_DOMAIN"
-    run $ABRA app volume remove "$TEST_APP_DOMAIN" --no-input
+    run $ABRA app volume remove --no-input "$TEST_APP_DOMAIN"
-    run $ABRA app remove "$TEST_APP_DOMAIN" --no-input
+    run $ABRA app remove --no-input "$TEST_APP_DOMAIN"
   fi
 }
 
@@ -46,10 +47,11 @@ _reset_app(){
   assert_success
   assert_not_exists "$ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env"
 
-  run $ABRA app new "$TEST_RECIPE" \
+  run $ABRA app new \
     --no-input \
     --server "$TEST_SERVER" \
-    --domain "$TEST_APP_DOMAIN"
+    --domain "$TEST_APP_DOMAIN" \
+    "$TEST_RECIPE"
   assert_success
   assert_exists "$ABRA_DIR/servers/$TEST_SERVER/$TEST_APP_DOMAIN.env"
 }