fix(kadabra): only warn if a deployed app has no published release

Closes coop-cloud/organising#408

.gitignore

@@ -2,8 +2,8 @@
 .e2e.env
 .envrc
 .vscode/
-abra
 /kadabra
+abra
 dist/
 tests/integration/.abra/catalogue
 vendor/

.goreleaser.yml

@@ -3,33 +3,17 @@ gitea_urls:
   api: https://git.coopcloud.tech/api/v1
   download: https://git.coopcloud.tech/
   skip_tls_verify: false
+
 before:
   hooks:
     - go mod tidy
+
 builds:
-  - env:
-      - CGO_ENABLED=0
+  - id: abra
+    binary: abra
     dir: cmd/abra
-    id: abra
-    goos:
-      - linux
-      - darwin
-    goarch:
-      - 386
-      - amd64
-      - arm
-      - arm64
-    goarm:
-      - 5
-      - 6
-      - 7
-    ldflags:
-      - "-X 'main.Commit={{ .Commit }}'"
-      - "-X 'main.Version={{ .Version }}'"
-  - env:
+    env:
       - CGO_ENABLED=0
-    id: kadabra
-    dir: cmd/kadabra
     goos:
       - linux
       - darwin
@@ -45,15 +29,40 @@ builds:
     ldflags:
       - "-X 'main.Commit={{ .Commit }}'"
       - "-X 'main.Version={{ .Version }}'"
+
+  - id: kadabra
+    binary: kadabra
+    dir: cmd/kadabra
+    env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - darwin
+    goarch:
+      - 386
+      - amd64
+      - arm
+      - arm64
+    goarm:
+      - 5
+      - 6
+      - 7
+    ldflags:
+      - "-X 'main.Commit={{ .Commit }}'"
+      - "-X 'main.Version={{ .Version }}'"
+
 archives:
   - replacements:
       386: i386
       amd64: x86_64
     format: binary
+
 checksum:
   name_template: "checksums.txt"
+
 snapshot:
   name_template: "{{ incpatch .Version }}-next"
+
 changelog:
   sort: desc
   filters:

AUTHORS.md

@@ -5,9 +5,12 @@
 
 - 3wordchant
 - cassowary
+- codegod100
 - decentral1se
 - frando
 - kawaiipunk
 - knoflook
 - moritz
 - roxxers
+- vera
+- yksflip

Dockerfile

@@ -9,8 +9,6 @@ COPY . /app
 WORKDIR /app
 
 RUN CGO_ENABLED=0 make build
-# RUN rm go.sum && go get -v -d -u ./... && \
-# 	make build
 
 FROM scratch
 

LICENSE

@@ -1,5 +1,5 @@
 Abra: The Co-op Cloud utility belt
-Copyright (C) 2022  Co-op Cloud <helo@coopcloud.tech>
+Copyright (C) 2022 Co-op Cloud <helo@coopcloud.tech>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

Makefile

@@ -1,9 +1,10 @@
-ABRA    := ./cmd/abra
-KADABRA := ./cmd/kadabra
-COMMIT  := $(shell git rev-list -1 HEAD)
-GOPATH  := $(shell go env GOPATH)
-LDFLAGS := "-X 'main.Commit=$(COMMIT)'"
+ABRA         := ./cmd/abra
+KADABRA      := ./cmd/kadabra
+COMMIT       := $(shell git rev-list -1 HEAD)
+GOPATH       := $(shell go env GOPATH)
+LDFLAGS      := "-X 'main.Commit=$(COMMIT)'"
 DIST_LDFLAGS := $(LDFLAGS)" -s -w"
+
 export GOPRIVATE=coopcloud.tech
 
 all: format check build test
@@ -15,11 +16,11 @@ install:
 	@go install -ldflags=$(LDFLAGS) $(ABRA)
 
 build-dev:
-	@go build -ldflags=$(LDFLAGS) $(ABRA)
+	@go build -v -ldflags=$(LDFLAGS) $(ABRA)
 
 build:
-	@go build -ldflags=$(DIST_LDFLAGS) $(ABRA)
-	@go build -ldflags=$(DIST_LDFLAGS) $(KADABRA)
+	@go build -v -ldflags=$(DIST_LDFLAGS) $(ABRA)
+	@go build -v -ldflags=$(DIST_LDFLAGS) $(KADABRA)
 
 clean:
 	@rm '$(GOPATH)/bin/abra'
@@ -29,7 +30,8 @@ format:
 	@gofmt -s -w .
 
 check:
-	@test -z $$(gofmt -l .) || (echo "gofmt: formatting issue - run 'make format' to resolve" && exit 1)
+	@test -z $$(gofmt -l .) || \
+	(echo "gofmt: formatting issue - run 'make format' to resolve" && exit 1)
 
 test:
 	@go test ./... -cover -v

cli/app/backup.go

@@ -16,6 +16,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	containerPkg "coopcloud.tech/abra/pkg/container"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
@@ -72,13 +73,14 @@ This single file can be used to restore your app. See "abra app restore" for mor
 `,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
+		conf := runtime.New()
 
 		cl, err := client.New(app.Server)
 		if err != nil {
 			logrus.Fatal(err)
 		}
 
-		recipe, err := recipe.Get(app.Recipe)
+		recipe, err := recipe.Get(app.Recipe, conf)
 		if err != nil {
 			logrus.Fatal(err)
 		}

cli/app/errors.go

@@ -12,6 +12,7 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
@@ -55,6 +56,7 @@ the logs.
 	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
+		conf := runtime.New()
 
 		cl, err := client.New(app.Server)
 		if err != nil {
@@ -71,14 +73,14 @@ the logs.
 		}
 
 		if !internal.Watch {
-			if err := checkErrors(c, cl, app); err != nil {
+			if err := checkErrors(c, cl, app, conf); err != nil {
 				logrus.Fatal(err)
 			}
 			return nil
 		}
 
 		for {
-			if err := checkErrors(c, cl, app); err != nil {
+			if err := checkErrors(c, cl, app, conf); err != nil {
 				logrus.Fatal(err)
 			}
 			time.Sleep(2 * time.Second)
@@ -88,8 +90,8 @@ the logs.
 	},
 }
 
-func checkErrors(c *cli.Context, cl *dockerClient.Client, app config.App) error {
-	recipe, err := recipe.Get(app.Recipe)
+func checkErrors(c *cli.Context, cl *dockerClient.Client, app config.App, conf *runtime.Config) error {
+	recipe, err := recipe.Get(app.Recipe, conf)
 	if err != nil {
 		return err
 	}

cli/app/logs.go

@@ -11,6 +11,7 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/abra/pkg/service"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
@@ -20,12 +21,14 @@ import (
 )
 
 var logOpts = types.ContainerLogsOptions{
-	Details:    false,
-	Follow:     true,
 	ShowStderr: true,
 	ShowStdout: true,
-	Tail:       "20",
+	Since:      "",
+	Until:      "",
 	Timestamps: true,
+	Follow:     true,
+	Tail:       "20",
+	Details:    false,
 }
 
 // stackLogs lists logs for all stack services
@@ -74,18 +77,21 @@ var appLogsCommand = cli.Command{
 	Usage:     "Tail app logs",
 	Flags: []cli.Flag{
 		internal.StdErrOnlyFlag,
+		internal.SinceLogsFlag,
 		internal.DebugFlag,
 	},
 	Before:       internal.SubCommandBefore,
 	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
+		app := internal.ValidateApp(c, runtime.WithEnsureRecipeExists(false))
 
 		cl, err := client.New(app.Server)
 		if err != nil {
 			logrus.Fatal(err)
 		}
 
+		logOpts.Since = internal.SinceLogs
+
 		serviceName := c.Args().Get(1)
 		if serviceName == "" {
 			logrus.Debugf("tailing logs for all %s services", app.Recipe)

cli/app/restore.go

@@ -12,6 +12,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	containerPkg "coopcloud.tech/abra/pkg/container"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/abra/pkg/upstream/container"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
@@ -55,6 +56,7 @@ Example:
 `,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
+		conf := runtime.New()
 
 		cl, err := client.New(app.Server)
 		if err != nil {
@@ -77,7 +79,7 @@ Example:
 			}
 		}
 
-		recipe, err := recipe.Get(app.Recipe)
+		recipe, err := recipe.Get(app.Recipe, conf)
 		if err != nil {
 			logrus.Fatal(err)
 		}

cli/app/rollback.go

@@ -8,6 +8,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
 
@@ -49,14 +50,15 @@ recipes.
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 		stackName := app.StackName()
+		conf := runtime.New()
 
 		if !internal.Chaos {
-			if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
+			if err := recipe.EnsureUpToDate(app.Recipe, conf); err != nil {
 				logrus.Fatal(err)
 			}
 		}
 
-		r, err := recipe.Get(app.Recipe)
+		r, err := recipe.Get(app.Recipe, conf)
 		if err != nil {
 			logrus.Fatal(err)
 		}

cli/app/undeploy.go

@@ -2,15 +2,82 @@ package app
 
 import (
 	"context"
+	"fmt"
+	"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/formatter"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
+	"github.com/docker/docker/api/types/filters"
+	dockerClient "github.com/docker/docker/client"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
+var prune bool
+
+var pruneFlag = &cli.BoolFlag{
+	Name:        "prune, p",
+	Destination: &prune,
+	Usage:       "Prunes unused containers, networks, and dangling images for an app",
+}
+
+// pruneApp runs the equivalent of a "docker system prune" but only filtering
+// against resources connected with the app deployment. It is not a system wide
+// prune. Volumes are not pruned to avoid unwated data loss.
+func pruneApp(c *cli.Context, cl *dockerClient.Client, app config.App) error {
+	stackName := app.StackName()
+	ctx := context.Background()
+
+	for {
+		logrus.Debugf("polling for %s stack, waiting to be undeployed...", stackName)
+
+		services, err := stack.GetStackServices(ctx, cl, stackName)
+		if err != nil {
+			return err
+		}
+
+		if len(services) == 0 {
+			logrus.Debugf("%s undeployed, moving on with pruning logic", stackName)
+			time.Sleep(time.Second) // give runtime more time to tear down related state
+			break
+		}
+
+		time.Sleep(time.Second)
+	}
+
+	pruneFilters := filters.NewArgs()
+	stackSearch := fmt.Sprintf("%s*", stackName)
+	pruneFilters.Add("label", stackSearch)
+	cr, err := cl.ContainersPrune(ctx, pruneFilters)
+	if err != nil {
+		return err
+	}
+
+	cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed)
+	logrus.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)
+
+	nr, err := cl.NetworksPrune(ctx, pruneFilters)
+	if err != nil {
+		return err
+	}
+
+	logrus.Infof("networks pruned: %d", len(nr.NetworksDeleted))
+
+	ir, err := cl.ImagesPrune(ctx, pruneFilters)
+	if err != nil {
+		return err
+	}
+
+	imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed)
+	logrus.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)
+
+	return nil
+}
+
 var appUndeployCommand = cli.Command{
 	Name:      "undeploy",
 	Aliases:   []string{"un"},
@@ -18,18 +85,22 @@ var appUndeployCommand = cli.Command{
 	Flags: []cli.Flag{
 		internal.DebugFlag,
 		internal.NoInputFlag,
+		pruneFlag,
 	},
-	Before: internal.SubCommandBefore,
-	Usage:  "Undeploy an app",
+	Before:       internal.SubCommandBefore,
+	Usage:        "Undeploy an app",
+	BashComplete: autocomplete.AppNameComplete,
 	Description: `
-This does not destroy any of the application data. However, you should remain
-vigilant, as your swarm installation will consider any previously attached
-volumes as eligiblef or pruning once undeployed.
+This does not destroy any of the application data.
+
+However, you should remain vigilant, as your swarm installation will consider
+any previously attached volumes as eligible for pruning once undeployed.
+
+Passing "-p/--prune" does not remove those volumes.
 `,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 		stackName := app.StackName()
-
 		cl, err := client.New(app.Server)
 		if err != nil {
 			logrus.Fatal(err)
@@ -55,7 +126,12 @@ volumes as eligiblef or pruning once undeployed.
 			logrus.Fatal(err)
 		}
 
+		if prune {
+			if err := pruneApp(c, cl, app); err != nil {
+				logrus.Fatal(err)
+			}
+		}
+
 		return nil
 	},
-	BashComplete: autocomplete.AppNameComplete,
 }

cli/app/upgrade.go

@@ -10,6 +10,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
@@ -52,6 +53,7 @@ recipes.
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 		stackName := app.StackName()
+		conf := runtime.New()
 
 		cl, err := client.New(app.Server)
 		if err != nil {
@@ -59,12 +61,12 @@ recipes.
 		}
 
 		if !internal.Chaos {
-			if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
+			if err := recipe.EnsureUpToDate(app.Recipe, conf); err != nil {
 				logrus.Fatal(err)
 			}
 		}
 
-		r, err := recipe.Get(app.Recipe)
+		r, err := recipe.Get(app.Recipe, conf)
 		if err != nil {
 			logrus.Fatal(err)
 		}

cli/app/version.go

@@ -8,6 +8,7 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/docker/distribution/reference"
 	"github.com/sirupsen/logrus"
@@ -48,6 +49,7 @@ version.
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 		stackName := app.StackName()
+		conf := runtime.New()
 
 		cl, err := client.New(app.Server)
 		if err != nil {
@@ -69,7 +71,7 @@ version.
 			logrus.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		recipeMeta, err := recipe.GetRecipeMeta(app.Recipe)
+		recipeMeta, err := recipe.GetRecipeMeta(app.Recipe, conf)
 		if err != nil {
 			logrus.Fatal(err)
 		}

cli/catalogue/catalogue.go

@@ -13,6 +13,7 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"github.com/go-git/go-git/v5"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
@@ -54,8 +55,10 @@ keys configured on your account.
 	ArgsUsage: "[<recipe>]",
 	Action: func(c *cli.Context) error {
 		recipeName := c.Args().First()
+		conf := runtime.New()
+
 		if recipeName != "" {
-			internal.ValidateRecipe(c, true)
+			internal.ValidateRecipe(c)
 		}
 
 		if err := catalogue.EnsureUpToDate(); err != nil {
@@ -79,7 +82,7 @@ keys configured on your account.
 
 		if !internal.SkipUpdates {
 			logrus.Warn(logMsg)
-			if err := recipe.UpdateRepositories(repos, recipeName); err != nil {
+			if err := recipe.UpdateRepositories(repos, recipeName, conf); err != nil {
 				logrus.Fatal(err)
 			}
 		}
@@ -97,7 +100,7 @@ keys configured on your account.
 				continue
 			}
 
-			versions, err := recipe.GetRecipeVersions(recipeMeta.Name)
+			versions, err := recipe.GetRecipeVersions(recipeMeta.Name, conf)
 			if err != nil {
 				logrus.Warn(err)
 			}

cli/cli.go

@@ -189,6 +189,7 @@ func newAbraApp(version, commit string) *cli.App {
 
 		return nil
 	}
+
 	return app
 }
 

cli/internal/cli.go

@@ -328,6 +328,14 @@ var StdErrOnlyFlag = &cli.BoolFlag{
 	Destination: &StdErrOnly,
 }
 
+var SinceLogs string
+var SinceLogsFlag = &cli.StringFlag{
+	Name:        "since, S",
+	Value:       "",
+	Usage:       "tail logs since YYYY-MM-DDTHH:MM:SSZ",
+	Destination: &SinceLogs,
+}
+
 var DontWaitConverge bool
 var DontWaitConvergeFlag = &cli.BoolFlag{
 	Name:        "no-converge-checks, c",

cli/internal/deploy.go

@@ -15,6 +15,7 @@ import (
 	"coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/sirupsen/logrus"
@@ -24,6 +25,7 @@ import (
 // DeployAction is the main command-line action for this package
 func DeployAction(c *cli.Context) error {
 	app := ValidateApp(c)
+	conf := runtime.New()
 
 	cl, err := client.New(app.Server)
 	if err != nil {
@@ -31,12 +33,12 @@ func DeployAction(c *cli.Context) error {
 	}
 
 	if !Chaos {
-		if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
+		if err := recipe.EnsureUpToDate(app.Recipe, conf); err != nil {
 			logrus.Fatal(err)
 		}
 	}
 
-	r, err := recipe.Get(app.Recipe)
+	r, err := recipe.Get(app.Recipe, conf)
 	if err != nil {
 		logrus.Fatal(err)
 	}
@@ -83,7 +85,7 @@ func DeployAction(c *cli.Context) error {
 			}
 			version = formatter.SmallSHA(head.String())
 			logrus.Warn("no versions detected, using latest commit")
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
+			if err := recipe.EnsureLatest(app.Recipe, conf); err != nil {
 				logrus.Fatal(err)
 			}
 		}

cli/internal/new.go

@@ -11,6 +11,7 @@ import (
 	"coopcloud.tech/abra/pkg/jsontable"
 	"coopcloud.tech/abra/pkg/recipe"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/abra/pkg/secret"
 	"github.com/AlecAivazis/survey/v2"
 	dockerClient "github.com/docker/docker/client"
@@ -119,9 +120,10 @@ func ensureServerFlag() error {
 
 // NewAction is the new app creation logic
 func NewAction(c *cli.Context) error {
-	recipe := ValidateRecipeWithPrompt(c, false)
+	recipe := ValidateRecipeWithPrompt(c, runtime.WithEnsureRecipeLatest(false))
 
-	if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil {
+	conf := runtime.New(runtime.WithEnsureRecipeLatest(false))
+	if err := recipePkg.EnsureUpToDate(recipe.Name, conf); err != nil {
 		logrus.Fatal(err)
 	}
 

cli/internal/validate.go

@@ -9,6 +9,7 @@ import (
 	"coopcloud.tech/abra/pkg/app"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
@@ -18,14 +19,15 @@ import (
 var AppName string
 
 // ValidateRecipe ensures the recipe arg is valid.
-func ValidateRecipe(c *cli.Context, ensureLatest bool) recipe.Recipe {
+func ValidateRecipe(c *cli.Context, opts ...runtime.Option) recipe.Recipe {
 	recipeName := c.Args().First()
+	conf := runtime.New(opts...)
 
 	if recipeName == "" {
 		ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
 	}
 
-	chosenRecipe, err := recipe.Get(recipeName)
+	chosenRecipe, err := recipe.Get(recipeName, conf)
 	if err != nil {
 		if c.Command.Name == "generate" {
 			if strings.Contains(err.Error(), "missing a compose") {
@@ -40,10 +42,8 @@ func ValidateRecipe(c *cli.Context, ensureLatest bool) recipe.Recipe {
 		}
 	}
 
-	if ensureLatest {
-		if err := recipe.EnsureLatest(recipeName); err != nil {
-			logrus.Fatal(err)
-		}
+	if err := recipe.EnsureLatest(recipeName, conf); err != nil {
+		logrus.Fatal(err)
 	}
 
 	logrus.Debugf("validated %s as recipe argument", recipeName)
@@ -53,8 +53,9 @@ func ValidateRecipe(c *cli.Context, ensureLatest bool) recipe.Recipe {
 
 // ValidateRecipeWithPrompt ensures a recipe argument is present before
 // validating, asking for input if required.
-func ValidateRecipeWithPrompt(c *cli.Context, ensureLatest bool) recipe.Recipe {
+func ValidateRecipeWithPrompt(c *cli.Context, opts ...runtime.Option) recipe.Recipe {
 	recipeName := c.Args().First()
+	conf := runtime.New(opts...)
 
 	if recipeName == "" && !NoInput {
 		var recipes []string
@@ -102,15 +103,13 @@ func ValidateRecipeWithPrompt(c *cli.Context, ensureLatest bool) recipe.Recipe {
 		ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
 	}
 
-	chosenRecipe, err := recipe.Get(recipeName)
+	chosenRecipe, err := recipe.Get(recipeName, conf)
 	if err != nil {
 		logrus.Fatal(err)
 	}
 
-	if ensureLatest {
-		if err := recipe.EnsureLatest(recipeName); err != nil {
-			logrus.Fatal(err)
-		}
+	if err := recipe.EnsureLatest(recipeName, conf); err != nil {
+		logrus.Fatal(err)
 	}
 
 	logrus.Debugf("validated %s as recipe argument", recipeName)
@@ -119,8 +118,9 @@ func ValidateRecipeWithPrompt(c *cli.Context, ensureLatest bool) recipe.Recipe {
 }
 
 // ValidateApp ensures the app name arg is valid.
-func ValidateApp(c *cli.Context) config.App {
+func ValidateApp(c *cli.Context, opts ...runtime.Option) config.App {
 	appName := c.Args().First()
+	conf := runtime.New(opts...)
 
 	if AppName != "" {
 		appName = AppName
@@ -136,7 +136,7 @@ func ValidateApp(c *cli.Context) config.App {
 		logrus.Fatal(err)
 	}
 
-	if err := recipe.EnsureExists(app.Recipe); err != nil {
+	if err := recipe.EnsureExists(app.Recipe, conf); err != nil {
 		logrus.Fatal(err)
 	}
 

cli/recipe/fetch.go

@@ -4,6 +4,7 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
@@ -21,8 +22,10 @@ var recipeFetchCommand = cli.Command{
 	BashComplete: autocomplete.RecipeNameComplete,
 	Action: func(c *cli.Context) error {
 		recipeName := c.Args().First()
+		conf := runtime.New()
+
 		if recipeName != "" {
-			internal.ValidateRecipe(c, true)
+			internal.ValidateRecipe(c)
 			return nil // ValidateRecipe ensures latest checkout
 		}
 
@@ -31,7 +34,7 @@ var recipeFetchCommand = cli.Command{
 			logrus.Fatal(err)
 		}
 
-		if err := recipe.UpdateRepositories(repos, recipeName); err != nil {
+		if err := recipe.UpdateRepositories(repos, recipeName, conf); err != nil {
 			logrus.Fatal(err)
 		}
 

cli/recipe/lint.go

@@ -8,6 +8,7 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	"coopcloud.tech/abra/pkg/lint"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
@@ -24,9 +25,10 @@ var recipeLintCommand = cli.Command{
 	Before:       internal.SubCommandBefore,
 	BashComplete: autocomplete.RecipeNameComplete,
 	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipe(c, true)
+		recipe := internal.ValidateRecipe(c)
+		conf := runtime.New()
 
-		if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil {
+		if err := recipePkg.EnsureUpToDate(recipe.Name, conf); err != nil {
 			logrus.Fatal(err)
 		}
 

cli/recipe/release.go

@@ -13,6 +13,7 @@ import (
 	gitPkg "coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/recipe"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/distribution/reference"
@@ -58,7 +59,7 @@ your SSH keys configured on your account.
 	Before:       internal.SubCommandBefore,
 	BashComplete: autocomplete.RecipeNameComplete,
 	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipeWithPrompt(c, false)
+		recipe := internal.ValidateRecipeWithPrompt(c, runtime.WithEnsureRecipeLatest(false))
 
 		imagesTmp, err := getImageVersions(recipe)
 		if err != nil {

cli/recipe/sync.go

@@ -8,6 +8,7 @@ import (
 	"coopcloud.tech/abra/cli/internal"
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/config"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/go-git/go-git/v5"
@@ -41,7 +42,7 @@ auto-generate it for you. The <recipe> configuration will be updated on the
 local file system.
 `,
 	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipeWithPrompt(c, false)
+		recipe := internal.ValidateRecipeWithPrompt(c, runtime.WithEnsureRecipeLatest(false))
 
 		mainApp, err := internal.GetMainAppImage(recipe)
 		if err != nil {

cli/recipe/upgrade.go

@@ -14,6 +14,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/tagcmp"
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/docker/distribution/reference"
@@ -59,9 +60,10 @@ You may invoke this command in "wizard" mode and be prompted for input:
 	},
 	Before: internal.SubCommandBefore,
 	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipeWithPrompt(c, true)
+		recipe := internal.ValidateRecipeWithPrompt(c)
+		conf := runtime.New()
 
-		if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil {
+		if err := recipePkg.EnsureUpToDate(recipe.Name, conf); err != nil {
 			logrus.Fatal(err)
 		}
 

cli/recipe/version.go

@@ -5,6 +5,7 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/formatter"
 	recipePkg "coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
@@ -20,7 +21,7 @@ var recipeVersionCommand = cli.Command{
 	Before:       internal.SubCommandBefore,
 	BashComplete: autocomplete.RecipeNameComplete,
 	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipe(c, false)
+		recipe := internal.ValidateRecipe(c, runtime.WithEnsureRecipeLatest(false))
 
 		catalogue, err := recipePkg.ReadRecipeCatalogue()
 		if err != nil {

cli/server/list.go

@@ -39,11 +39,7 @@ var serverListCommand = cli.Command{
 
 		tableColumns := []string{"name", "host", "user", "port"}
 		table := formatter.CreateTable(tableColumns)
-		if internal.MachineReadable {
-			defer table.JSONRender()
-		} else {
-			defer table.Render()
-		}
+
 		serverNames, err := config.ReadServerNames()
 		if err != nil {
 			logrus.Fatal(err)
@@ -84,6 +80,16 @@ var serverListCommand = cli.Command{
 			}
 		}
 
+		if internal.MachineReadable {
+			table.JSONRender()
+		} else {
+			if problemsFilter && table.NumLines() == 0 {
+				logrus.Info("all servers wired up correctly 👏")
+			} else {
+				table.Render()
+			}
+		}
+
 		return nil
 	},
 }

cli/server/prune.go

@@ -0,0 +1,100 @@
+package server
+
+import (
+	"context"
+
+	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
+	"coopcloud.tech/abra/pkg/client"
+	"coopcloud.tech/abra/pkg/formatter"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli"
+)
+
+var allFilter bool
+
+var allFilterFlag = &cli.BoolFlag{
+	Name:        "all, a",
+	Usage:       "Remove all unused images not just dangling ones",
+	Destination: &allFilter,
+}
+
+var volunesFilter bool
+
+var volumesFilterFlag = &cli.BoolFlag{
+	Name:        "volumes, v",
+	Usage:       "Prune volumes. This will remove app data, Be Careful!",
+	Destination: &volunesFilter,
+}
+
+var serverPruneCommand = cli.Command{
+	Name:    "prune",
+	Aliases: []string{"p"},
+	Usage:   "Prune a managed server; Runs a docker system prune",
+	Description: `
+Prunes unused containers, networks, and dangling images.
+
+If passing "-v/--volumes" then volumes not connected with a deployed app will
+also be removed. This can result in unwanted data loss if not used carefully.
+	`,
+	ArgsUsage: "[<server>]",
+	Flags: []cli.Flag{
+		allFilterFlag,
+		volumesFilterFlag,
+		internal.DebugFlag,
+	},
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.ServerNameComplete,
+	Action: func(c *cli.Context) error {
+		var args filters.Args
+
+		serverName := internal.ValidateServer(c)
+
+		cl, err := client.New(serverName)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		ctx := context.Background()
+		cr, err := cl.ContainersPrune(ctx, args)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed)
+		logrus.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)
+
+		nr, err := cl.NetworksPrune(ctx, args)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		logrus.Infof("networks pruned: %d", len(nr.NetworksDeleted))
+
+		pruneFilters := filters.NewArgs()
+		if allFilter {
+			pruneFilters.Add("dangling", "false")
+		}
+
+		ir, err := cl.ImagesPrune(ctx, pruneFilters)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed)
+		logrus.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)
+
+		if volunesFilter {
+			vr, err := cl.VolumesPrune(ctx, args)
+			if err != nil {
+				logrus.Fatal(err)
+			}
+
+			volSpaceReclaimed := formatter.ByteCountSI(vr.SpaceReclaimed)
+			logrus.Infof("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed)
+		}
+
+		return nil
+	},
+}

cli/server/remove.go

@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 
 	"coopcloud.tech/abra/cli/internal"
+	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/formatter"
@@ -124,7 +125,8 @@ like tears in rain.
 		internal.HetznerCloudNameFlag,
 		internal.HetznerCloudAPITokenFlag,
 	},
-	Before: internal.SubCommandBefore,
+	Before:       internal.SubCommandBefore,
+	BashComplete: autocomplete.ServerNameComplete,
 	Action: func(c *cli.Context) error {
 		serverName := internal.ValidateServer(c)
 

cli/server/server.go

@@ -22,5 +22,6 @@ recipes, see available flags on "abra server add" for more.
 		serverAddCommand,
 		serverListCommand,
 		serverRemoveCommand,
+		serverPruneCommand,
 	},
 }

cli/updater/updater.go

@@ -12,6 +12,7 @@ import (
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/lint"
 	"coopcloud.tech/abra/pkg/recipe"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/abra/pkg/upstream/convert"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/tagcmp"
@@ -40,7 +41,7 @@ var allFlag = &cli.BoolFlag{
 	Destination: &updateAll,
 }
 
-// Check for available upgrades
+// Notify checks for available upgrades
 var Notify = cli.Command{
 	Name:    "notify",
 	Aliases: []string{"n"},
@@ -49,24 +50,30 @@ var Notify = cli.Command{
 		internal.DebugFlag,
 		majorFlag,
 	},
-	Before:      internal.SubCommandBefore,
-	Description: `It reads the deployed app versions and looks for new versions in the recipe catalogue. If a new patch/minor version is available, a notification is printed. To include major versions use the --major flag.`,
+	Before: internal.SubCommandBefore,
+	Description: `
+It reads the deployed app versions and looks for new versions in the recipe
+catalogue. If a new patch/minor version is available, a notification is
+printed. To include major versions use the --major flag.
+`,
 	Action: func(c *cli.Context) error {
-
 		cl, err := client.New("default")
 		if err != nil {
 			logrus.Fatal(err)
 		}
+
 		stacks, err := stack.GetStacks(cl)
 		if err != nil {
 			logrus.Fatal(err)
 		}
+
 		for _, stackInfo := range stacks {
 			stackName := stackInfo.Name
 			recipeName, err := getLabel(cl, stackName, "recipe")
 			if err != nil {
 				logrus.Fatal(err)
 			}
+
 			if recipeName != "" {
 				_, err = getLatestUpgrade(cl, stackName, recipeName)
 				if err != nil {
@@ -74,37 +81,49 @@ var Notify = cli.Command{
 				}
 			}
 		}
+
 		return nil
 	},
 }
 
-// Upgrade apps
+// UpgradeApp upgrades apps.
 var UpgradeApp = cli.Command{
 	Name:      "upgrade",
 	Aliases:   []string{"u"},
 	Usage:     "Upgrade apps",
-	ArgsUsage: "<stack_name> <recipe>",
+	ArgsUsage: "<stack-name> <recipe>",
 	Flags: []cli.Flag{
 		internal.DebugFlag,
 		internal.ChaosFlag,
 		majorFlag,
 		allFlag,
 	},
-	Before:      internal.SubCommandBefore,
-	Description: `Upgrade an app by specifying its stack name and recipe. By passing --all instead every deployed app is upgraded. For each apps with enabled auto updates the deployed version is compared with the current recipe catalogue version. If a new patch/minor version is available the app is upgraded. To include major versions use the --major flag. Don't do that, it will probably break things. Only apps that are not deployed with --chaos are upgraded, to update chaos deployments use the --chaos flag. Use it with care.`,
+	Before: internal.SubCommandBefore,
+	Description: `
+Upgrade an app by specifying its stack name and recipe. By passing "--all"
+instead, every deployed app is upgraded. For each apps with enabled auto
+updates the deployed version is compared with the current recipe catalogue
+version. If a new patch/minor version is available, the app is upgraded. To
+include major versions use the "--major" flag. Don't do that, it will probably
+break things. Only apps that are not deployed with "--chaos" are upgraded, to
+update chaos deployments use the "--chaos" flag. Use it with care.
+`,
 	Action: func(c *cli.Context) error {
 		cl, err := client.New("default")
 		if err != nil {
 			logrus.Fatal(err)
 		}
 
+		conf := runtime.New()
+
 		if !updateAll {
 			stackName := c.Args().Get(0)
 			recipeName := c.Args().Get(1)
-			err = tryUpgrade(cl, stackName, recipeName)
+			err = tryUpgrade(cl, stackName, recipeName, conf)
 			if err != nil {
 				logrus.Fatal(err)
 			}
+
 			return nil
 		}
 
@@ -112,22 +131,25 @@ var UpgradeApp = cli.Command{
 		if err != nil {
 			logrus.Fatal(err)
 		}
+
 		for _, stackInfo := range stacks {
 			stackName := stackInfo.Name
 			recipeName, err := getLabel(cl, stackName, "recipe")
 			if err != nil {
 				logrus.Fatal(err)
 			}
-			err = tryUpgrade(cl, stackName, recipeName)
+
+			err = tryUpgrade(cl, stackName, recipeName, conf)
 			if err != nil {
 				logrus.Fatal(err)
 			}
 		}
+
 		return nil
 	},
 }
 
-// getLabel reads docker label in the format coop-cloud.${STACK_NAME}.${LABEL}
+// getLabel reads docker labels in the format of "coop-cloud.${STACK_NAME}.${LABEL}".
 func getLabel(cl *dockerclient.Client, stackName string, label string) (string, error) {
 	filter := filters.NewArgs()
 	filter.Add("label", fmt.Sprintf("%s=%s", convert.LabelNamespace, stackName))
@@ -136,34 +158,41 @@ func getLabel(cl *dockerclient.Client, stackName string, label string) (string,
 	if err != nil {
 		return "", err
 	}
+
 	for _, service := range services {
 		labelKey := fmt.Sprintf("coop-cloud.%s.%s", stackName, label)
 		if labelValue, ok := service.Spec.Labels[labelKey]; ok {
 			return labelValue, nil
 		}
 	}
+
 	logrus.Debugf("no %s label found for %s", label, stackName)
+
 	return "", nil
 }
 
-// getBoolLabel reads a boolean docker label
+// getBoolLabel reads a boolean docker label.
 func getBoolLabel(cl *dockerclient.Client, stackName string, label string) (bool, error) {
 	lableValue, err := getLabel(cl, stackName, label)
 	if err != nil {
 		return false, err
 	}
+
 	if lableValue != "" {
 		value, err := strconv.ParseBool(lableValue)
 		if err != nil {
 			return false, err
 		}
+
 		return value, nil
 	}
+
 	logrus.Debugf("Boolean label %s could not be found for %s, set default to false.", label, stackName)
+
 	return false, nil
 }
 
-// getEnv reads Env variables from docker services
+// getEnv reads env variables from docker services.
 func getEnv(cl *dockerclient.Client, stackName string) (config.AppEnv, error) {
 	envMap := make(map[string]string)
 	filter := filters.NewArgs()
@@ -173,6 +202,7 @@ func getEnv(cl *dockerclient.Client, stackName string) (config.AppEnv, error) {
 	if err != nil {
 		return nil, err
 	}
+
 	for _, service := range services {
 		envList := service.Spec.TaskTemplate.ContainerSpec.Env
 		for _, envString := range envList {
@@ -187,53 +217,60 @@ func getEnv(cl *dockerclient.Client, stackName string) (config.AppEnv, error) {
 			envMap[k] = v
 		}
 	}
+
 	return envMap, nil
 }
 
-// getLatestUpgrade returns the latest available version for an app regarding to the --major flag
-// if it is newer than the currently deployed version
+// getLatestUpgrade returns the latest available version for an app respecting
+// the "--major" flag if it is newer than the currently deployed version.
 func getLatestUpgrade(cl *dockerclient.Client, stackName string, recipeName string) (string, error) {
 	deployedVersion, err := getDeployedVersion(cl, stackName, recipeName)
 	if err != nil {
 		return "", err
 	}
+
 	availableUpgrades, err := getAvailableUpgrades(cl, stackName, recipeName, deployedVersion)
 	if err != nil {
 		return "", err
 	}
+
 	if len(availableUpgrades) == 0 {
 		logrus.Debugf("no available upgrades for %s", stackName)
 		return "", nil
 	}
-	// Uncomment to select the next version instead of the last version
-	// availableUpgrades = internal.ReverseStringList(availableUpgrades)
+
 	var chosenUpgrade string
 	if len(availableUpgrades) > 0 {
 		chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
 		logrus.Infof("%s (%s) can be upgraded from version %s to %s", stackName, recipeName, deployedVersion, chosenUpgrade)
 	}
-	return chosenUpgrade, nil
 
+	return chosenUpgrade, nil
 }
 
-// getDeployedVersion returns the currently deployed version of an app
+// getDeployedVersion returns the currently deployed version of an app.
 func getDeployedVersion(cl *dockerclient.Client, stackName string, recipeName string) (string, error) {
 	logrus.Debugf("Retrieve deployed version whether %s is already deployed", stackName)
+
 	isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
 	if err != nil {
 		return "", err
 	}
+
 	if !isDeployed {
 		return "", fmt.Errorf("%s is not deployed?", stackName)
 	}
+
 	if deployedVersion == "unknown" {
 		return "", fmt.Errorf("failed to determine deployed version of %s", stackName)
 	}
+
 	return deployedVersion, nil
 }
 
-// getAvailableUpgrades returns all available versions of an app that are newer than
-// the deployed version. It only includes major steps if the --major flag is set.
+// getAvailableUpgrades returns all available versions of an app that are newer
+// 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) {
 	catl, err := recipe.ReadRecipeCatalogue()
@@ -247,68 +284,78 @@ func getAvailableUpgrades(cl *dockerclient.Client, stackName string, recipeName
 	}
 
 	if len(versions) == 0 {
-		return nil, fmt.Errorf("no published releases for %s in the recipe catalogue?", recipeName)
+		logrus.Warnf("no published releases for %s in the recipe catalogue?", recipeName)
+		return nil, nil
 	}
 
 	var availableUpgrades []string
-
 	for _, version := range versions {
 		parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
 		if err != nil {
 			return nil, err
 		}
+
 		parsedVersion, err := tagcmp.Parse(version)
 		if err != nil {
 			return nil, err
 		}
+
 		versionDelta, err := parsedDeployedVersion.UpgradeDelta(parsedVersion)
 		if err != nil {
 			return nil, err
 		}
+
 		if 0 < versionDelta.UpgradeType() && (versionDelta.UpgradeType() < 4 || majorUpdate) {
 			availableUpgrades = append(availableUpgrades, version)
 		}
 	}
+
 	logrus.Debugf("Available updates for %s: %s", stackName, availableUpgrades)
 
 	return availableUpgrades, nil
-
 }
 
-// processRecipeRepoVersion clones, pulls, checks out the version and lints the recipe repository
-func processRecipeRepoVersion(recipeName string, version string) error {
-	if err := recipe.EnsureExists(recipeName); err != nil {
+// processRecipeRepoVersion clones, pulls, checks out the version and lints the
+// recipe repository.
+func processRecipeRepoVersion(recipeName, version string, conf *runtime.Config) error {
+	if err := recipe.EnsureExists(recipeName, conf); err != nil {
 		return err
 	}
-	if err := recipe.EnsureUpToDate(recipeName); err != nil {
+
+	if err := recipe.EnsureUpToDate(recipeName, conf); err != nil {
 		return err
 	}
+
 	if err := recipe.EnsureVersion(recipeName, version); err != nil {
 		return err
 	}
-	if r, err := recipe.Get(recipeName); err != nil {
+
+	if r, err := recipe.Get(recipeName, conf); err != nil {
 		return err
 	} else if err := lint.LintForErrors(r); err != nil {
 		return err
 	}
+
 	return nil
 }
 
-// mergeAbraShEnv merges abra.sh env's into the app env's
+// mergeAbraShEnv merges abra.sh env vars into the app env vars.
 func mergeAbraShEnv(recipeName string, env config.AppEnv) error {
 	abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, recipeName, "abra.sh")
 	abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
 	if err != nil {
 		return err
 	}
+
 	for k, v := range abraShEnv {
 		logrus.Debugf("read v:%s k: %s", v, k)
 		env[k] = v
 	}
+
 	return nil
 }
 
-// createDeployConfig merges and enriches the compose config for the deployment
+// createDeployConfig merges and enriches the compose config for the deployment.
 func createDeployConfig(recipeName string, stackName string, env config.AppEnv) (*composetypes.Config, stack.Deploy, error) {
 	env["STACK_NAME"] = stackName
 
@@ -317,64 +364,77 @@ func createDeployConfig(recipeName string, stackName string, env config.AppEnv)
 		Prune:        false,
 		ResolveImage: stack.ResolveImageAlways,
 	}
+
 	composeFiles, err := config.GetAppComposeFiles(recipeName, env)
 	if err != nil {
 		return nil, deployOpts, err
 	}
+
 	deployOpts.Composefiles = composeFiles
 	compose, err := config.GetAppComposeConfig(stackName, deployOpts, env)
 	if err != nil {
 		return nil, deployOpts, err
 	}
+
 	config.ExposeAllEnv(stackName, compose, env)
+
 	// after the upgrade the deployment won't be in chaos state anymore
 	config.SetChaosLabel(compose, stackName, false)
 	config.SetRecipeLabel(compose, stackName, recipeName)
 	config.SetUpdateLabel(compose, stackName, env)
+
 	return compose, deployOpts, nil
 }
 
-// tryUpgrade performs the upgrade if all the requirements are fulfilled
-func tryUpgrade(cl *dockerclient.Client, stackName string, recipeName string) error {
+// tryUpgrade performs the upgrade if all the requirements are fulfilled.
+func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string, conf *runtime.Config) error {
 	if recipeName == "" {
 		logrus.Debugf("Don't update %s due to missing recipe name", stackName)
 		return nil
 	}
+
 	chaos, err := getBoolLabel(cl, stackName, "chaos")
 	if err != nil {
 		return err
 	}
+
 	if chaos && !internal.Chaos {
 		logrus.Debugf("Don't update %s due to chaos deployment.", stackName)
 		return nil
 	}
+
 	updatesEnabled, err := getBoolLabel(cl, stackName, "autoupdate")
 	if err != nil {
 		return err
 	}
+
 	if !updatesEnabled {
 		logrus.Debugf("Don't update %s due to disabling auto updates or missing ENABLE_AUTOUPDATE env.", stackName)
 		return nil
 	}
+
 	upgradeVersion, err := getLatestUpgrade(cl, stackName, recipeName)
 	if err != nil {
 		return err
 	}
+
 	if upgradeVersion == "" {
 		logrus.Debugf("Don't update %s due to no new version.", stackName)
 		return nil
 	}
-	err = upgrade(cl, stackName, recipeName, upgradeVersion)
-	return err
 
+	err = upgrade(cl, stackName, recipeName, upgradeVersion, conf)
+
+	return err
 }
 
-// upgrade performs all necessary steps to upgrade an app
-func upgrade(cl *dockerclient.Client, stackName string, recipeName string, upgradeVersion string) error {
+// upgrade performs all necessary steps to upgrade an app.
+func upgrade(cl *dockerclient.Client, stackName, recipeName, upgradeVersion string, conf *runtime.Config) error {
 	env, err := getEnv(cl, stackName)
 	if err != nil {
 		return err
 	}
+
 	app := config.App{
 		Name:   stackName,
 		Recipe: recipeName,
@@ -382,7 +442,7 @@ func upgrade(cl *dockerclient.Client, stackName string, recipeName string, upgra
 		Env:    env,
 	}
 
-	if err = processRecipeRepoVersion(recipeName, upgradeVersion); err != nil {
+	if err = processRecipeRepoVersion(recipeName, upgradeVersion, conf); err != nil {
 		return err
 	}
 
@@ -396,14 +456,16 @@ func upgrade(cl *dockerclient.Client, stackName string, recipeName string, upgra
 	}
 
 	logrus.Infof("Upgrade %s (%s) to version %s", stackName, recipeName, upgradeVersion)
+
 	err = stack.RunDeploy(cl, deployOpts, compose, stackName, true)
+
 	return err
 }
 
 func newAbraApp(version, commit string) *cli.App {
 	app := &cli.App{
 		Name: "kadabra",
-		Usage: `The Co-op Cloud autoupdater
+		Usage: `The Co-op Cloud auto-updater
     ____                           ____ _                 _
    / ___|___         ___  _ __    / ___| | ___  _   _  __| |
   | |   / _ \ _____ / _ \| '_ \  | |   | |/ _ \| | | |/ _' |
@@ -419,9 +481,10 @@ func newAbraApp(version, commit string) *cli.App {
 	}
 
 	app.Before = func(c *cli.Context) error {
-		logrus.Debugf("abra version %s, commit %s", version, commit)
+		logrus.Debugf("kadabra version %s, commit %s", version, commit)
 		return nil
 	}
+
 	return app
 }
 

cmd/abra/main.go

@@ -5,10 +5,10 @@ import (
 	"coopcloud.tech/abra/cli"
 )
 
-// Version is the current version of Abra
+// Version is the current version of Abra.
 var Version string
 
-// Commit is the current git commit of Abra
+// Commit is the current git commit of Abra.
 var Commit string
 
 func main() {

cmd/kadabra/main.go

@@ -5,10 +5,10 @@ import (
 	"coopcloud.tech/abra/cli/updater"
 )
 
-// Version is the current version of Abra
+// Version is the current version of Kadabra.
 var Version string
 
-// Commit is the current git commit of Abra
+// Commit is the current git commit of Kadabra.
 var Commit string
 
 func main() {

go.mod

@@ -12,7 +12,7 @@ require (
 	github.com/docker/docker v20.10.23+incompatible
 	github.com/docker/go-units v0.5.0
 	github.com/go-git/go-git/v5 v5.5.2
-	github.com/hetznercloud/hcloud-go v1.39.0
+	github.com/hetznercloud/hcloud-go v1.40.0
 	github.com/moby/sys/signal v0.7.0
 	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6
 	github.com/olekukonko/tablewriter v0.0.5

go.sum

@@ -605,8 +605,8 @@ github.com/hashicorp/memberlist v0.2.2/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOn
 github.com/hashicorp/memberlist v0.3.0/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE=
 github.com/hashicorp/serf v0.9.5/go.mod h1:UWDWwZeL5cuWDJdl0C6wrvrUwEqtQ4ZKBKKENpqIUyk=
 github.com/hashicorp/serf v0.9.6/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpTwn9UV4=
-github.com/hetznercloud/hcloud-go v1.39.0 h1:RUlzI458nGnPR6dlcZlrsGXYC1hQlFbKdm8tVtEQQB0=
-github.com/hetznercloud/hcloud-go v1.39.0/go.mod h1:mepQwR6va27S3UQthaEPGS86jtzSY9xWL1e9dyxXpgA=
+github.com/hetznercloud/hcloud-go v1.40.0 h1:rchS+LVd80GuAOQUM5pLs0Fn7tb4PflPCuxskLYc1JQ=
+github.com/hetznercloud/hcloud-go v1.40.0/go.mod h1:jcKomw7kDIjrJ9FI72S/RdRPK8X8arYzEnXjRM/uXT8=
 github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec h1:qv2VnGeEQHchGaZ/u7lxST/RaJw+cv273q79D81Xbog=
 github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec/go.mod h1:Q48J4R4DvxnHolD5P8pOtXigYlRuPLGl6moFx3ulM68=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=

pkg/autocomplete/autocomplete.go

@@ -9,7 +9,7 @@ import (
 	"github.com/urfave/cli"
 )
 
-// AppNameComplete copletes app names
+// AppNameComplete copletes app names.
 func AppNameComplete(c *cli.Context) {
 	appNames, err := config.GetAppNames()
 	if err != nil {
@@ -25,7 +25,7 @@ func AppNameComplete(c *cli.Context) {
 	}
 }
 
-// RecipeNameComplete completes recipe names
+// RecipeNameComplete completes recipe names.
 func RecipeNameComplete(c *cli.Context) {
 	catl, err := recipe.ReadRecipeCatalogue()
 	if err != nil {
@@ -41,7 +41,23 @@ func RecipeNameComplete(c *cli.Context) {
 	}
 }
 
-// SubcommandComplete completes subcommands.
+// ServerNameComplete completes server names.
+func ServerNameComplete(c *cli.Context) {
+	files, err := config.LoadAppFiles("")
+	if err != nil {
+		logrus.Fatal(err)
+	}
+
+	if c.NArg() > 0 {
+		return
+	}
+
+	for _, appFile := range files {
+		fmt.Println(appFile.Server)
+	}
+}
+
+// SubcommandComplete completes sub-commands.
 func SubcommandComplete(c *cli.Context) {
 	if c.NArg() > 0 {
 		return

pkg/client/client.go

@@ -26,7 +26,7 @@ func New(serverName string) (*client.Client, error) {
 	if serverName != "default" {
 		context, err := GetContext(serverName)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("unknown server, run \"abra server add %s\"?", serverName)
 		}
 
 		ctxEndpoint, err := contextPkg.GetContextEndpoint(context)

pkg/config/app.go

@@ -173,7 +173,7 @@ func newApp(env AppEnv, name string, appFile AppFile) (App, error) {
 	if !exists {
 		recipe, exists = env["TYPE"]
 		if !exists {
-			return App{}, fmt.Errorf("%s is missing the RECIPE env var", name)
+			return App{}, fmt.Errorf("%s is missing the TYPE env var?", name)
 		}
 	}
 
@@ -369,13 +369,6 @@ func GetAppStatuses(apps []App, MachineReadable bool) (map[string]map[string]str
 		}
 	}
 
-	for server := range servers {
-		// validate that all server connections work
-		if _, err := client.New(server); err != nil {
-			return statuses, err
-		}
-	}
-
 	var bar *progressbar.ProgressBar
 	if !MachineReadable {
 		bar = formatter.CreateProgressbar(len(servers), "querying remote servers...")

pkg/formatter/formatter.go

@@ -1,6 +1,7 @@
 package formatter
 
 import (
+	"fmt"
 	"os"
 	"strings"
 	"time"
@@ -70,3 +71,21 @@ func StripTagMeta(image string) string {
 
 	return image
 }
+
+// ByteCountSI presents a human friendly representation of a byte count. See
+// https://yourbasic.org/golang/formatting-byte-size-to-human-readable-format.
+func ByteCountSI(b uint64) string {
+	const unit = 1000
+
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+
+	div, exp := uint64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+
+	return fmt.Sprintf("%.1f %cB", float64(b)/float64(div), "kMGTPE"[exp])
+}

pkg/recipe/recipe.go

@@ -18,6 +18,7 @@ import (
 	"coopcloud.tech/abra/pkg/formatter"
 	gitPkg "coopcloud.tech/abra/pkg/git"
 	"coopcloud.tech/abra/pkg/limit"
+	"coopcloud.tech/abra/pkg/runtime"
 	"coopcloud.tech/abra/pkg/upstream/stack"
 	loader "coopcloud.tech/abra/pkg/upstream/stack"
 	"coopcloud.tech/abra/pkg/web"
@@ -206,8 +207,8 @@ func (r Recipe) Tags() ([]string, error) {
 }
 
 // Get retrieves a recipe.
-func Get(recipeName string) (Recipe, error) {
-	if err := EnsureExists(recipeName); err != nil {
+func Get(recipeName string, conf *runtime.Config) (Recipe, error) {
+	if err := EnsureExists(recipeName, conf); err != nil {
 		return Recipe{}, err
 	}
 
@@ -233,7 +234,7 @@ func Get(recipeName string) (Recipe, error) {
 		return Recipe{}, err
 	}
 
-	meta, err := GetRecipeMeta(recipeName)
+	meta, err := GetRecipeMeta(recipeName, conf)
 	if err != nil {
 		if strings.Contains(err.Error(), "does not exist") {
 			meta = RecipeMeta{}
@@ -250,7 +251,11 @@ func Get(recipeName string) (Recipe, error) {
 }
 
 // EnsureExists ensures that a recipe is locally cloned
-func EnsureExists(recipeName string) error {
+func EnsureExists(recipeName string, conf *runtime.Config) error {
+	if !conf.EnsureRecipeExists {
+		return nil
+	}
+
 	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
 
 	if _, err := os.Stat(recipeDir); os.IsNotExist(err) {
@@ -333,7 +338,11 @@ func EnsureVersion(recipeName, version string) error {
 }
 
 // EnsureLatest makes sure the latest commit is checked out for a local recipe repository
-func EnsureLatest(recipeName string) error {
+func EnsureLatest(recipeName string, conf *runtime.Config) error {
+	if !conf.EnsureRecipeLatest {
+		return nil
+	}
+
 	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
 
 	isClean, err := gitPkg.IsClean(recipeDir)
@@ -361,7 +370,7 @@ func EnsureLatest(recipeName string) error {
 		return err
 	}
 
-	meta, err := GetRecipeMeta(recipeName)
+	meta, err := GetRecipeMeta(recipeName, conf)
 	if err != nil {
 		return err
 	}
@@ -578,7 +587,11 @@ func GetStringInBetween(recipeName, str, start, end string) (result string, err
 }
 
 // EnsureUpToDate ensures that the local repo is synced to the remote
-func EnsureUpToDate(recipeName string) error {
+func EnsureUpToDate(recipeName string, conf *runtime.Config) error {
+	if !conf.EnsureRecipeLatest {
+		return nil
+	}
+
 	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
 
 	isClean, err := gitPkg.IsClean(recipeDir)
@@ -790,7 +803,7 @@ func VersionsOfService(recipe, serviceName string) ([]string, error) {
 }
 
 // GetRecipeMeta retrieves the recipe metadata from the recipe catalogue.
-func GetRecipeMeta(recipeName string) (RecipeMeta, error) {
+func GetRecipeMeta(recipeName string, conf *runtime.Config) (RecipeMeta, error) {
 	catl, err := ReadRecipeCatalogue()
 	if err != nil {
 		return RecipeMeta{}, err
@@ -801,7 +814,7 @@ func GetRecipeMeta(recipeName string) (RecipeMeta, error) {
 		return RecipeMeta{}, fmt.Errorf("recipe %s does not exist?", recipeName)
 	}
 
-	if err := EnsureExists(recipeName); err != nil {
+	if err := EnsureExists(recipeName, conf); err != nil {
 		return RecipeMeta{}, err
 	}
 
@@ -923,9 +936,8 @@ func ReadReposMetadata() (RepoCatalogue, error) {
 }
 
 // GetRecipeVersions retrieves all recipe versions.
-func GetRecipeVersions(recipeName string) (RecipeVersions, error) {
+func GetRecipeVersions(recipeName string, conf *runtime.Config) (RecipeVersions, error) {
 	versions := RecipeVersions{}
-
 	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
 
 	logrus.Debugf("attempting to open git repository in %s", recipeDir)
@@ -962,7 +974,7 @@ func GetRecipeVersions(recipeName string) (RecipeVersions, error) {
 
 		logrus.Debugf("successfully checked out %s in %s", ref.Name(), recipeDir)
 
-		recipe, err := Get(recipeName)
+		recipe, err := Get(recipeName, conf)
 		if err != nil {
 			return err
 		}
@@ -1027,7 +1039,7 @@ func GetRecipeCatalogueVersions(recipeName string, catl RecipeCatalogue) ([]stri
 }
 
 // UpdateRepositories clones and updates all recipe repositories locally.
-func UpdateRepositories(repos RepoCatalogue, recipeName string) error {
+func UpdateRepositories(repos RepoCatalogue, recipeName string, conf *runtime.Config) error {
 	var barLength int
 	if recipeName != "" {
 		barLength = 1
@@ -1061,7 +1073,7 @@ func UpdateRepositories(repos RepoCatalogue, recipeName string) error {
 				logrus.Fatal(err)
 			}
 
-			if err := EnsureUpToDate(rm.Name); err != nil {
+			if err := EnsureUpToDate(rm.Name, conf); err != nil {
 				logrus.Fatal(err)
 			}
 

pkg/runtime/runtime.go

@@ -0,0 +1,61 @@
+package runtime
+
+import "github.com/sirupsen/logrus"
+
+// Config is an internal configuration modifier. It can be instantiated on a
+// command call and can be changed on the fly to help make decisions further
+// down in the internals, e.g. whether or not to clone the recipe locally or
+// not.
+type Config struct {
+	EnsureRecipeExists bool // ensure that the recipe is cloned locally
+	EnsureRecipeLatest bool // ensure the local recipe has latest changes
+}
+
+// Option modified a Config. The convetion for passing Options to functions is
+// so far, only used in internal/validate.go. A Config is then constructed and
+// passed down further into the code. This may change in the future but this is
+// at least the abstraction so far.
+type Option func(c *Config)
+
+// New instantiates a new Config.
+func New(opts ...Option) *Config {
+	conf := &Config{
+		EnsureRecipeExists: true,
+	}
+
+	for _, optFunc := range opts {
+		optFunc(conf)
+	}
+
+	return conf
+}
+
+// WithEnsureRecipeExists determines whether or not we should be cloning the
+// local recipe or not. This can be useful for being more adaptable to offline
+// scenarios.
+func WithEnsureRecipeExists(ensureRecipeExists bool) Option {
+	return func(c *Config) {
+		if ensureRecipeExists {
+			logrus.Debugf("runtime config: EnsureRecipeExists = %v, ensuring recipes are cloned", ensureRecipeExists)
+		} else {
+			logrus.Debugf("runtime config: EnsureRecipeExists = %v, not cloning recipes", ensureRecipeExists)
+		}
+
+		c.EnsureRecipeExists = ensureRecipeExists
+	}
+}
+
+// WithEnsureRecipeLatest determines whether we should update the local recipes
+// remotely via Git. This can be useful when e.g. ensuring we have the latest
+// changes before making new ones.
+func WithEnsureRecipeLatest(ensureRecipeLatest bool) Option {
+	return func(c *Config) {
+		if ensureRecipeLatest {
+			logrus.Debugf("runtime config: EnsureRecipeLatest = %v, ensuring recipes have latest changes", ensureRecipeLatest)
+		} else {
+			logrus.Debugf("runtime config: EnsureRecipeLatest = %v, leaving recipes alone", ensureRecipeLatest)
+		}
+
+		c.EnsureRecipeLatest = ensureRecipeLatest
+	}
+}

pkg/ssh/ssh.go

@@ -77,6 +77,8 @@ func Fatal(hostname string, err error) error {
 		return fmt.Errorf("connection timed out for %s", hostname)
 	} else if strings.Contains(out, "Permission denied") {
 		return fmt.Errorf("ssh auth: permission denied for %s", hostname)
+	} else if strings.Contains(out, "Network is unreachable") {
+		return fmt.Errorf("unable to connect to %s, network is unreachable?", hostname)
 	} else {
 		return err
 	}

scripts/installer/installer

@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 
-ABRA_VERSION="0.6.0-beta"
+ABRA_VERSION="0.7.0-beta"
 ABRA_RELEASE_URL="https://git.coopcloud.tech/api/v1/repos/coop-cloud/abra/releases/tags/$ABRA_VERSION"
-RC_VERSION="0.7.0-rc1-beta"
+RC_VERSION="0.7.0-beta"
 RC_VERSION_URL="https://git.coopcloud.tech/api/v1/repos/coop-cloud/abra/releases/tags/$RC_VERSION"
 
 for arg in "$@"; do