Bump version

Closes #31

.drone.yml

@@ -1,64 +1,33 @@
 ---
 kind: pipeline
-name: coopcloud.tech/abra
+name: linters
 steps:
-  - name: make check
-    image: golang:1.18
+  - name: run shellcheck
+    image: koalaman/shellcheck-alpine:v0.7.1
     commands:
-      - make check
+      - shellcheck abra
 
-  - name: make build
-    image: golang:1.18
+  - name: run unit tests
+    image: docker:dind
     commands:
-      - make build
+      - apk add bats git bash
+      - bats tests
 
-  - name: make test
-    image: golang:1.18
+  - name: collect code coverage
+    failure: ignore  # until we fix this
+    image: kcov/kcov:38
     commands:
-      - make test
+      - apt update && apt install -y bats git bash
+      - kcov . bats tests || true
 
-  - name: notify on failure
-    image: plugins/matrix
+  - name: send code coverage report to codecov
+    failure: ignore  # until we fix this
+    image: plugins/codecov
     settings:
-      homeserver: https://matrix.autonomic.zone
-      roomid: "IFazIpLtxiScqbHqoa:autonomic.zone"
-      userid: "@autono-bot:autonomic.zone"
-      accesstoken:
-        from_secret: autono_bot_access_token
-    depends_on:
-      - make check
-      - make build
-      - make test
-    when:
-      status:
-        - failure
+      token:
+        from_secret: codecov_token
+        required: true
 
-  - name: fetch
-    image: docker:git
-    commands:
-      - git fetch --tags
-    depends_on:
-      - make check
-      - make build
-      - make test
-    when:
-      event: tag
-
-  - name: release
-    image: golang:1.18
-    environment:
-      GITEA_TOKEN:
-        from_secret: goreleaser_gitea_token
-    volumes:
-      - name: deps
-        path: /go
-    commands:
-      - curl -sL https://git.io/goreleaser | bash
-    depends_on:
-      - fetch
-    when:
-      event: tag
-
-volumes:
-  - name: deps
-    temp: {}
+trigger:
+  branch:
+    - main

.e2e.env.sample

@@ -1,4 +0,0 @@
-GANDI_TOKEN=...
-HCLOUD_TOKEN=...
-REGISTRY_PASSWORD=...
-REGISTRY_USERNAME=...

.envrc.sample

@@ -1,6 +0,0 @@
-go env -w GOPRIVATE=coopcloud.tech
-
-# export PASSWORD_STORE_DIR=$(pwd)/../../autonomic/passwords/passwords/
-# export HCLOUD_TOKEN=$(pass show logins/hetzner/cicd/api_key)
-# export CAPSUL_TOKEN=...
-# export GITEA_TOKEN=...

.gitea/ISSUE_TEMPLATE.md

@@ -1,8 +0,0 @@
----
-name: "Do not use this issue tracker"
-about: "Do not use this issue tracker"
-title: "Do not use this issue tracker"
-labels: []
----
-
-Please report your issue on [`coop-cloud/organising`](https://git.coopcloud.tech/coop-cloud/organising)

.gitignore

@@ -1,8 +1,2 @@
-*fmtcoverage.html
-.e2e.env
-.envrc
-.vscode/
-abra
-dist/
-tests/integration/.abra/catalogue
-vendor/
+coverage/
+/.venv

.goreleaser.yml

@@ -1,38 +0,0 @@
----
-project_name: abra
-gitea_urls:
-  api: https://git.coopcloud.tech/api/v1
-  download: https://git.coopcloud.tech/
-  skip_tls_verify: false
-before:
-  hooks:
-    - go mod tidy
-    - go generate ./...
-builds:
-  - env:
-      - CGO_ENABLED=0
-    dir: cmd/abra
-    goos:
-      - linux
-      - darwin
-    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:
-    exclude:
-      - "^WIP:"
-      - "^style:"
-      - "^test:"
-      - "^tests:"
-      - "^Revert"

AUTHORS.md

@@ -1,10 +0,0 @@
-# authors
-
-> If you're looking at this and you hack on Abra and you're not listed here,
-> please do add yourself! This is a community project, let's show
-
-- 3wordchant
-- decentral1se
-- kawaiipunk
-- knoflook
-- roxxers

CHANGELOG.md

@@ -0,0 +1,28 @@
+# abra x.x.x (UNRELEASED)
+
+- ???
+
+# abra 0.3.1 (2020-09-27)
+
+- Fix installer version
+
+# abra 0.3.0 (2020-09-27)
+
+- Add multilogs stack logs implementation ([#8](https://git.autonomic.zone/compose-stacks/abra/issues/8)
+- Add beginnings of "monorepo" functionality
+
+# abra 0.2.0 (2020-09-24)
+
+- Prepare for swarm install script using script.d ([#12](https://git.autonomic.zone/compose-stacks/planning/issues/12))
+
+# abra 0.1.2 (2020-09-22)
+
+- Add upgrade command ([#10](https://git.autonomic.zone/autonomic-cooperative/abra/issues/10))
+
+# abra 0.1.1 (2020-09-22)
+
+- Add installer script ([#9](https://git.autonomic.zone/autonomic-cooperative/abra/issues/9))
+
+# abra 0.1.0 (2020-09-22)
+
+- Initial pre-alpha release

Makefile

@@ -1,42 +1,38 @@
-ABRA    := ./cmd/abra
-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
-
-run:
-	@go run -ldflags=$(LDFLAGS) $(ABRA)
-
-install:
-	@go install -ldflags=$(LDFLAGS) $(ABRA)
-
-build-dev:
-	@go build -ldflags=$(LDFLAGS) $(ABRA)
-
-build:
-	@go build -ldflags=$(DIST_LDFLAGS) $(ABRA)
-
-clean:
-	@rm '$(GOPATH)/bin/abra'
-
-format:
-	@gofmt -s -w .
-
-check:
-	@test -z $$(gofmt -l .) || (echo "gofmt: formatting issue - run 'make format' to resolve" && exit 1)
+.PHONY: test shellcheck docopt kcov codecov
 
 test:
-	@go test ./... -cover -v
+	@DOCKER_CONTEXT=default docker run \
+		-it \
+		--rm \
+		-v $$(pwd):/workdir \
+		docker:dind \
+		sh -c "apk add bats git bash && cd /workdir && bats /workdir/test.bats"
 
-loc:
-	@find . -name "*.go" | xargs wc -l
+shellcheck:
+	@docker run \
+		-it \
+		--rm \
+		-v $$(pwd):/workdir \
+		koalaman/shellcheck-alpine \
+		shellcheck /workdir/abra
 
-loc-author:
-	@git ls-files -z | \
-		xargs -0rn 1 -P "$$(nproc)" -I{} sh -c 'git blame -w -M -C -C --line-porcelain -- {} | grep -I --line-buffered "^author "' | \
-   	sort -f | \
-   	uniq -ic | \
-   	sort -n
+docopt:
+	@if [ ! -d ".venv" ]; then \
+		python3 -m venv .venv && \
+		.venv/bin/pip install -U pip setuptools wheel && \
+		.venv/bin/pip install docopt-sh; \
+	fi
+	.venv/bin/docopt.sh abra
+
+kcov:
+	@docker run \
+		-it \
+		--rm \
+		-v $$(pwd):/workdir \
+		kcov/kcov:latest \
+		sh -c "kcov /workdir/coverage /workdir/abra || true"
+
+codecov: SHELL:=/bin/bash
+codecov:
+	@bash <(curl -s https://codecov.io/bash) \
+		-s coverage -t $$(pass show hosts/swarm.autonomic.zone/drone/codecov/token)

README.md

@@ -1,12 +1,14 @@
 # abra
 
-> https://coopcloud.tech
+[![Build Status](https://drone.autonomic.zone/api/badges/coop-cloud/abra/status.svg)](https://drone.autonomic.zone/coop-cloud/abra)
+[![codecov](https://codecov.io/gh/Autonomic-Cooperative/abra/branch/main/graph/badge.svg?token=aX3I5NMRsj)](undefined)
 
-[![Build Status](https://build.coopcloud.tech/api/badges/coop-cloud/abra/status.svg?ref=refs/heads/main)](https://build.coopcloud.tech/coop-cloud/abra)
-[![Go Report Card](https://goreportcard.com/badge/git.coopcloud.tech/coop-cloud/abra)](https://goreportcard.com/report/git.coopcloud.tech/coop-cloud/abra)
+> https://cloud.autonomic.zone
 
-The Co-op Cloud utility belt 🎩🐇
+The cooperative cloud utility belt 🎩🐇
 
-`abra` is our flagship client & command-line tool which has been developed specifically in the context of the Co-op Cloud project for the purpose of making day-to-day operations for [operators](https://docs.coopcloud.tech/operators/) and [maintainers](https://docs.coopcloud.tech/maintainers/) as convenient as possible. It is libre software, written in [Go](https://go.dev) and maintained and extended by the community ❤
+## Install
 
-Please see [docs.coopcloud.tech/abra/](https://docs.coopcloud.tech/abra/) for help on install, upgrade, hacking, troubleshooting & more!
+```sh
+curl https://install.abra.autonomic.zone | bash
+```

cli/app/app.go

@@ -1,34 +0,0 @@
-package app
-
-import (
-	"github.com/urfave/cli"
-)
-
-var AppCommand = cli.Command{
-	Name:        "app",
-	Aliases:     []string{"a"},
-	Usage:       "Manage apps",
-	ArgsUsage:   "<domain>",
-	Description: "This command provides functionality for managing the life cycle of your apps",
-	Subcommands: []cli.Command{
-		appNewCommand,
-		appConfigCommand,
-		appRestartCommand,
-		appDeployCommand,
-		appUpgradeCommand,
-		appUndeployCommand,
-		appRemoveCommand,
-		appCheckCommand,
-		appListCommand,
-		appPsCommand,
-		appLogsCommand,
-		appCpCommand,
-		appRunCommand,
-		appRollbackCommand,
-		appSecretCommand,
-		appVolumeCommand,
-		appVersionCommand,
-		appErrorsCommand,
-		appCmdCommand,
-	},
-}

cli/app/check.go

@@ -1,57 +0,0 @@
-package app
-
-import (
-	"os"
-	"path"
-	"strings"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appCheckCommand = cli.Command{
-	Name:      "check",
-	Aliases:   []string{"chk"},
-	Usage:     "Check if app is configured correctly",
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		envSamplePath := path.Join(config.RECIPES_DIR, app.Recipe, ".env.sample")
-		if _, err := os.Stat(envSamplePath); err != nil {
-			if os.IsNotExist(err) {
-				logrus.Fatalf("%s does not exist?", envSamplePath)
-			}
-			logrus.Fatal(err)
-		}
-
-		envSample, err := config.ReadEnv(envSamplePath)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		var missing []string
-		for k := range envSample {
-			if _, ok := app.Env[k]; !ok {
-				missing = append(missing, k)
-			}
-		}
-
-		if len(missing) > 0 {
-			missingEnvVars := strings.Join(missing, ", ")
-			logrus.Fatalf("%s is missing %s", app.Path, missingEnvVars)
-		}
-
-		logrus.Infof("all necessary environment variables defined for %s", app.Name)
-
-		return nil
-	},
-	BashComplete: autocomplete.AppNameComplete,
-}

cli/app/cmd.go

@@ -1,233 +0,0 @@
-package app
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path"
-	"strings"
-
-	"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/formatter"
-	"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"
-	"github.com/docker/docker/pkg/archive"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var localCmd bool
-var localCmdFlag = &cli.BoolFlag{
-	Name:        "local, l",
-	Usage:       "Run command locally",
-	Destination: &localCmd,
-}
-
-var remoteUser string
-var remoteUserFlag = &cli.StringFlag{
-	Name:        "user, u",
-	Value:       "",
-	Usage:       "User to run command within a service context",
-	Destination: &remoteUser,
-}
-
-var appCmdCommand = cli.Command{
-	Name:    "command",
-	Aliases: []string{"cmd"},
-	Usage:   "Run app commands",
-	Description: `
-This command runs app specific commands.
-
-These commands are bash functions, defined in the abra.sh of the recipe itself.
-They can be run within the context of a service (e.g. app) or locally on your
-work station by passing "--local". Arguments can be passed into these functions
-using the "-- <args>" syntax.
-
-Example:
-
-  abra app cmd example.com app create_user -- me@example.com
-`,
-	ArgsUsage: "<domain> [<service>] <command>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		localCmdFlag,
-		remoteUserFlag,
-	},
-	BashComplete: autocomplete.AppNameComplete,
-	Before:       internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		if localCmd && remoteUser != "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("cannot use --local & <user> together"))
-		}
-
-		abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh")
-		if _, err := os.Stat(abraSh); err != nil {
-			if os.IsNotExist(err) {
-				logrus.Fatalf("%s does not exist for %s?", abraSh, app.Name)
-			}
-			logrus.Fatal(err)
-		}
-
-		var parsedCmdArgs string
-		var cmdArgsIdx int
-		var hasCmdArgs bool
-		for idx, arg := range c.Args() {
-			if arg == "--" {
-				cmdArgsIdx = idx
-				hasCmdArgs = true
-			}
-
-			if hasCmdArgs && idx > cmdArgsIdx {
-				parsedCmdArgs += fmt.Sprintf("%s ", c.Args().Get(idx))
-			}
-		}
-
-		if localCmd {
-			cmdName := c.Args().Get(1)
-			if err := ensureCommand(abraSh, app.Recipe, cmdName); err != nil {
-				logrus.Fatal(err)
-			}
-
-			logrus.Debugf("--local detected, running %s on local work station", cmdName)
-
-			var sourceAndExec string
-			if hasCmdArgs {
-				logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs)
-				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; . %s; %s %s", app.StackName(), abraSh, cmdName, parsedCmdArgs)
-			} else {
-				logrus.Debug("did not detect any command arguments")
-				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; . %s; %s", app.StackName(), abraSh, cmdName)
-			}
-
-			cmd := exec.Command("/bin/sh", "-c", sourceAndExec)
-
-			if err := internal.RunCmd(cmd); err != nil {
-				logrus.Fatal(err)
-			}
-		} else {
-			targetServiceName := c.Args().Get(1)
-
-			cmdName := c.Args().Get(2)
-			if err := ensureCommand(abraSh, app.Recipe, cmdName); err != nil {
-				logrus.Fatal(err)
-			}
-
-			serviceNames, err := config.GetAppServiceNames(app.Name)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			matchingServiceName := false
-			for _, serviceName := range serviceNames {
-				if serviceName == targetServiceName {
-					matchingServiceName = true
-				}
-			}
-
-			if !matchingServiceName {
-				logrus.Fatalf("no service %s for %s?", targetServiceName, app.Name)
-			}
-
-			logrus.Debugf("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName)
-
-			if hasCmdArgs {
-				logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs)
-			} else {
-				logrus.Debug("did not detect any command arguments")
-			}
-
-			if err := runCmdRemote(app, abraSh, targetServiceName, cmdName, parsedCmdArgs); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		return nil
-	},
-}
-
-func ensureCommand(abraSh, recipeName, execCmd string) error {
-	bytes, err := ioutil.ReadFile(abraSh)
-	if err != nil {
-		return err
-	}
-
-	if !strings.Contains(string(bytes), execCmd) {
-		return fmt.Errorf("%s doesn't have a %s function", recipeName, execCmd)
-	}
-
-	return nil
-}
-
-func runCmdRemote(app config.App, abraSh, serviceName, cmdName, cmdArgs string) error {
-	cl, err := client.New(app.Server)
-	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
-	}
-
-	logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(targetContainer.ID), app.Server)
-
-	toTarOpts := &archive.TarOptions{NoOverwriteDirNonDir: true, Compression: archive.Gzip}
-	content, err := archive.TarWithOptions(abraSh, toTarOpts)
-	if err != nil {
-		return err
-	}
-
-	copyOpts := types.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
-	if err := cl.CopyToContainer(context.Background(), targetContainer.ID, "/tmp", content, copyOpts); err != nil {
-		return err
-	}
-
-	var cmd []string
-	if cmdArgs != "" {
-		cmd = []string{"/bin/sh", "-c", fmt.Sprintf("TARGET=%s; APP_NAME=%s; . /tmp/abra.sh; %s %s", serviceName, app.StackName(), cmdName, cmdArgs)}
-	} else {
-		cmd = []string{"/bin/sh", "-c", fmt.Sprintf("TARGET=%s; APP_NAME=%s; . /tmp/abra.sh; %s", serviceName, app.StackName(), cmdName)}
-	}
-
-	logrus.Debugf("running command: %s", strings.Join(cmd, " "))
-
-	execCreateOpts := types.ExecConfig{
-		AttachStderr: true,
-		AttachStdin:  true,
-		AttachStdout: true,
-		Cmd:          cmd,
-		Detach:       false,
-		Tty:          true,
-	}
-
-	if remoteUser != "" {
-		logrus.Debugf("running command with user %s", remoteUser)
-		execCreateOpts.User = remoteUser
-	}
-
-	// FIXME: avoid instantiating a new CLI
-	dcli, err := command.NewDockerCli()
-	if err != nil {
-		return err
-	}
-
-	if err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
-		return err
-	}
-
-	return nil
-}

cli/app/config.go

@@ -1,64 +0,0 @@
-package app
-
-import (
-	"errors"
-	"os"
-	"os/exec"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appConfigCommand = cli.Command{
-	Name:      "config",
-	Aliases:   []string{"cfg"},
-	Usage:     "Edit app config",
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		appName := c.Args().First()
-
-		if appName == "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no app provided"))
-		}
-
-		files, err := config.LoadAppFiles("")
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		appFile, exists := files[appName]
-		if !exists {
-			logrus.Fatalf("cannot find app with name %s", appName)
-		}
-
-		ed, ok := os.LookupEnv("EDITOR")
-		if !ok {
-			edPrompt := &survey.Select{
-				Message: "Which editor do you wish to use?",
-				Options: []string{"vi", "vim", "nvim", "nano", "pico", "emacs"},
-			}
-			if err := survey.AskOne(edPrompt, &ed); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		cmd := exec.Command(ed, appFile.Path)
-		cmd.Stdin = os.Stdin
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		if err := cmd.Run(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		return nil
-	},
-	BashComplete: autocomplete.AppNameComplete,
-}

cli/app/cp.go

@@ -1,151 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strings"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/container"
-	"coopcloud.tech/abra/pkg/formatter"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/pkg/archive"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appCpCommand = cli.Command{
-	Name:      "cp",
-	Aliases:   []string{"c"},
-	ArgsUsage: "<domain> <src> <dst>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Usage:  "Copy files to/from a running app service",
-	Description: `
-This command supports copying files to and from any app service file system.
-
-If you want to copy a myfile.txt to the root of the app service:
-
-    abra app cp <domain> myfile.txt app:/
-
-And if you want to copy that file back to your current working directory locally:
-
-		abra app cp <domain> app:/myfile.txt .
-`,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		src := c.Args().Get(1)
-		dst := c.Args().Get(2)
-		if src == "" {
-			logrus.Fatal("missing <src> argument")
-		} else if dst == "" {
-			logrus.Fatal("missing <dest> argument")
-		}
-
-		parsedSrc := strings.SplitN(src, ":", 2)
-		parsedDst := strings.SplitN(dst, ":", 2)
-		errorMsg := "one of <src>/<dest> arguments must take $SERVICE:$PATH form"
-		if len(parsedSrc) == 2 && len(parsedDst) == 2 {
-			logrus.Fatal(errorMsg)
-		} else if len(parsedSrc) != 2 {
-			if len(parsedDst) != 2 {
-				logrus.Fatal(errorMsg)
-			}
-		} else if len(parsedDst) != 2 {
-			if len(parsedSrc) != 2 {
-				logrus.Fatal(errorMsg)
-			}
-		}
-
-		var service string
-		var srcPath string
-		var dstPath string
-		isToContainer := false // <container:src> <dst>
-		if len(parsedSrc) == 2 {
-			service = parsedSrc[0]
-			srcPath = parsedSrc[1]
-			dstPath = dst
-			logrus.Debugf("assuming transfer is coming FROM the container")
-		} else if len(parsedDst) == 2 {
-			service = parsedDst[0]
-			dstPath = parsedDst[1]
-			srcPath = src
-			isToContainer = true // <src> <container:dst>
-			logrus.Debugf("assuming transfer is going TO the container")
-		}
-
-		if !isToContainer {
-			if _, err := os.Stat(dstPath); os.IsNotExist(err) {
-				logrus.Fatalf("%s does not exist locally?", dstPath)
-			}
-		}
-		err := configureAndCp(c, app, srcPath, dstPath, service, isToContainer)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		return nil
-
-	},
-	BashComplete: autocomplete.AppNameComplete,
-}
-
-func configureAndCp(
-	c *cli.Context,
-	app config.App,
-	srcPath string,
-	dstPath string,
-	service string,
-	isToContainer bool) error {
-	cl, err := client.New(app.Server)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	filters := filters.NewArgs()
-	filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), service))
-
-	container, err := container.GetContainer(context.Background(), cl, filters, internal.NoInput)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(container.ID), app.Server)
-
-	if isToContainer {
-		if _, err := os.Stat(srcPath); err != nil {
-			logrus.Fatalf("%s does not exist?", srcPath)
-		}
-
-		toTarOpts := &archive.TarOptions{NoOverwriteDirNonDir: true, Compression: archive.Gzip}
-		content, err := archive.TarWithOptions(srcPath, toTarOpts)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		copyOpts := types.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false}
-		if err := cl.CopyToContainer(context.Background(), container.ID, dstPath, content, copyOpts); err != nil {
-			logrus.Fatal(err)
-		}
-	} else {
-		content, _, err := cl.CopyFromContainer(context.Background(), container.ID, srcPath)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		defer content.Close()
-		fromTarOpts := &archive.TarOptions{NoOverwriteDirNonDir: true, Compression: archive.Gzip}
-		if err := archive.Untar(content, dstPath, fromTarOpts); err != nil {
-			logrus.Fatal(err)
-		}
-	}
-
-	return nil
-}

cli/app/deploy.go

@@ -1,37 +0,0 @@
-package app
-
-import (
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"github.com/urfave/cli"
-)
-
-var appDeployCommand = cli.Command{
-	Name:      "deploy",
-	Aliases:   []string{"d"},
-	Usage:     "Deploy an app",
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.ForceFlag,
-		internal.ChaosFlag,
-		internal.NoDomainChecksFlag,
-		internal.DontWaitConvergeFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-This command deploys an app. It does not support incrementing the version of a
-deployed app, for this you need to look at the "abra app upgrade <domain>"
-command.
-
-You may pass "--force" to re-deploy the same version again. This can be useful
-if the container runtime has gotten into a weird state.
-
-Chas mode ("--chaos") will deploy your local checkout of a recipe as-is,
-including unstaged changes and can be useful for live hacking and testing new
-recipes.
-`,
-	Action:       internal.DeployAction,
-	BashComplete: autocomplete.AppNameComplete,
-}

cli/app/errors.go

@@ -1,143 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-	"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"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appErrorsCommand = cli.Command{
-	Name:      "errors",
-	Usage:     "List errors for a deployed app",
-	ArgsUsage: "<domain>",
-	Description: `
-This command lists errors for a deployed app.
-
-This is a best-effort implementation and an attempt to gather a number of tips
-& tricks for finding errors together into one convenient command. When an app
-is failing to deploy or having issues, it could be a lot of things.
-
-This command currently takes into account:
-
-    Is the service deployed?
-    Is the service killed by an OOM error?
-    Is the service reporting an error (like in "ps --no-trunc" output)
-    Is the service healthcheck failing? what are the healthcheck logs?
-
-Got any more ideas? Please let us know:
-
-    https://git.coopcloud.tech/coop-cloud/organising/issues/new/choose
-
-This command is best accompanied by "abra app logs <domain>" which may reveal
-further information which can help you debug the cause of an app failure via
-the logs.
-`,
-	Aliases: []string{"e"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.WatchFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		if !internal.Watch {
-			if err := checkErrors(c, cl, app); err != nil {
-				logrus.Fatal(err)
-			}
-			return nil
-		}
-
-		for {
-			if err := checkErrors(c, cl, app); err != nil {
-				logrus.Fatal(err)
-			}
-			time.Sleep(2 * time.Second)
-		}
-
-		return nil
-	},
-}
-
-func checkErrors(c *cli.Context, cl *dockerClient.Client, app config.App) error {
-	recipe, err := recipe.Get(app.Recipe)
-	if err != nil {
-		return err
-	}
-
-	for _, service := range recipe.Config.Services {
-		filters := filters.NewArgs()
-		filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), service.Name))
-
-		containers, err := cl.ContainerList(context.Background(), types.ContainerListOptions{Filters: filters})
-		if err != nil {
-			return err
-		}
-
-		if len(containers) == 0 {
-			logrus.Warnf("%s is not up, something seems wrong", service.Name)
-			continue
-		}
-
-		container := containers[0]
-		containerState, err := cl.ContainerInspect(context.Background(), container.ID)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if containerState.State.OOMKilled {
-			logrus.Warnf("%s has been killed due to an out of memory error", service.Name)
-		}
-
-		if containerState.State.Error != "" {
-			logrus.Warnf("%s reports this error: %s", service.Name, containerState.State.Error)
-		}
-
-		if containerState.State.Health != nil {
-			if containerState.State.Health.Status != "healthy" {
-				logrus.Warnf("%s healthcheck status is %s", service.Name, containerState.State.Health.Status)
-				logrus.Warnf("%s healthcheck has failed %s times", service.Name, strconv.Itoa(containerState.State.Health.FailingStreak))
-				for _, log := range containerState.State.Health.Log {
-					logrus.Warnf("%s healthcheck logs: %s", service.Name, strings.TrimSpace(log.Output))
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
-func getServiceName(names []string) string {
-	containerName := strings.Join(names, " ")
-	trimmed := strings.TrimPrefix(containerName, "/")
-	return strings.Split(trimmed, ".")[0]
-}

cli/app/list.go

@@ -1,264 +0,0 @@
-package app
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/abra/pkg/ssh"
-	"coopcloud.tech/tagcmp"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var status bool
-var statusFlag = &cli.BoolFlag{
-	Name:        "status, S",
-	Usage:       "Show app deployment status",
-	Destination: &status,
-}
-
-var appRecipe string
-var recipeFlag = &cli.StringFlag{
-	Name:        "recipe, r",
-	Value:       "",
-	Usage:       "Show apps of a specific recipe",
-	Destination: &appRecipe,
-}
-
-var listAppServer string
-var listAppServerFlag = &cli.StringFlag{
-	Name:        "server, s",
-	Value:       "",
-	Usage:       "Show apps of a specific server",
-	Destination: &listAppServer,
-}
-
-type appStatus struct {
-	server  string
-	recipe  string
-	appName string
-	domain  string
-	status  string
-	version string
-	upgrade string
-}
-
-type serverStatus struct {
-	apps             []appStatus
-	appCount         int
-	versionCount     int
-	unversionedCount int
-	latestCount      int
-	upgradeCount     int
-}
-
-var appListCommand = cli.Command{
-	Name:    "list",
-	Aliases: []string{"ls"},
-	Usage:   "List all managed apps",
-	Description: `
-This command looks at your local file system listing of apps and servers (e.g.
-in ~/.abra/) to generate a report of all your apps.
-
-By passing the "--status/-S" flag, you can query all your servers for the
-actual live deployment status. Depending on how many servers you manage, this
-can take some time.
-`,
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		statusFlag,
-		listAppServerFlag,
-		recipeFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		appFiles, err := config.LoadAppFiles(listAppServer)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		apps, err := config.GetApps(appFiles)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		sort.Sort(config.ByServerAndRecipe(apps))
-
-		statuses := make(map[string]map[string]string)
-		var catl recipe.RecipeCatalogue
-		if status {
-			alreadySeen := make(map[string]bool)
-			for _, app := range apps {
-				if _, ok := alreadySeen[app.Server]; !ok {
-					if err := ssh.EnsureHostKey(app.Server); err != nil {
-						logrus.Fatal(fmt.Sprintf(internal.SSHFailMsg, app.Server))
-					}
-					alreadySeen[app.Server] = true
-				}
-			}
-
-			statuses, err = config.GetAppStatuses(appFiles)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			var err error
-			catl, err = recipe.ReadRecipeCatalogue()
-			if err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		var totalServersCount int
-		var totalAppsCount int
-		allStats := make(map[string]serverStatus)
-		for _, app := range apps {
-			var stats serverStatus
-			var ok bool
-			if stats, ok = allStats[app.Server]; !ok {
-				stats = serverStatus{}
-				if appRecipe == "" {
-					// count server, no filtering
-					totalServersCount++
-				}
-			}
-
-			if app.Recipe == appRecipe || appRecipe == "" {
-				if appRecipe != "" {
-					// only count server if matches filter
-					totalServersCount++
-				}
-
-				appStats := appStatus{}
-				stats.appCount++
-				totalAppsCount++
-
-				if status {
-					status := "unknown"
-					version := "unknown"
-					if statusMeta, ok := statuses[app.StackName()]; ok {
-						if currentVersion, exists := statusMeta["version"]; exists {
-							if currentVersion != "" {
-								version = currentVersion
-							}
-						}
-						if statusMeta["status"] != "" {
-							status = statusMeta["status"]
-						}
-						stats.versionCount++
-					} else {
-						stats.unversionedCount++
-					}
-
-					appStats.status = status
-					appStats.version = version
-
-					var newUpdates []string
-					if version != "unknown" {
-						updates, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
-						if err != nil {
-							logrus.Fatal(err)
-						}
-
-						parsedVersion, err := tagcmp.Parse(version)
-						if err != nil {
-							logrus.Fatal(err)
-						}
-
-						for _, update := range updates {
-							parsedUpdate, err := tagcmp.Parse(update)
-							if err != nil {
-								logrus.Fatal(err)
-							}
-
-							if update != version && parsedUpdate.IsGreaterThan(parsedVersion) {
-								newUpdates = append(newUpdates, update)
-							}
-						}
-					}
-
-					if len(newUpdates) == 0 {
-						if version == "unknown" {
-							appStats.upgrade = "unknown"
-						} else {
-							appStats.upgrade = "latest"
-							stats.latestCount++
-						}
-					} else {
-						newUpdates = internal.ReverseStringList(newUpdates)
-						appStats.upgrade = strings.Join(newUpdates, "\n")
-						stats.upgradeCount++
-					}
-				}
-
-				appStats.server = app.Server
-				appStats.recipe = app.Recipe
-				appStats.appName = app.Name
-				appStats.domain = app.Domain
-
-				stats.apps = append(stats.apps, appStats)
-			}
-
-			allStats[app.Server] = stats
-		}
-
-		alreadySeen := make(map[string]bool)
-		for _, app := range apps {
-			if _, ok := alreadySeen[app.Server]; ok {
-				continue
-			}
-
-			serverStat := allStats[app.Server]
-
-			tableCol := []string{"recipe", "domain"}
-			if status {
-				tableCol = append(tableCol, []string{"status", "version", "upgrade"}...)
-			}
-
-			table := formatter.CreateTable(tableCol)
-
-			for _, appStat := range serverStat.apps {
-				tableRow := []string{appStat.recipe, appStat.domain}
-				if status {
-					tableRow = append(tableRow, []string{appStat.status, appStat.version, appStat.upgrade}...)
-				}
-				table.Append(tableRow)
-			}
-
-			if table.NumLines() > 0 {
-				table.Render()
-
-				if status {
-					fmt.Println(fmt.Sprintf(
-						"server: %s | total apps: %v | versioned: %v | unversioned: %v | latest: %v | upgrade: %v",
-						app.Server,
-						serverStat.appCount,
-						serverStat.versionCount,
-						serverStat.unversionedCount,
-						serverStat.latestCount,
-						serverStat.upgradeCount,
-					))
-				} else {
-					fmt.Println(fmt.Sprintf("server: %s | total apps: %v", app.Server, serverStat.appCount))
-				}
-			}
-
-			if len(allStats) > 1 && table.NumLines() > 0 {
-				fmt.Println() // newline separator for multiple servers
-			}
-
-			alreadySeen[app.Server] = true
-		}
-
-		if len(allStats) > 1 {
-			fmt.Println(fmt.Sprintf("total servers: %v | total apps: %v ", totalServersCount, totalAppsCount))
-		}
-
-		return nil
-	},
-}

cli/app/logs.go

@@ -1,129 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"sync"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/service"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var logOpts = types.ContainerLogsOptions{
-	Details:    false,
-	Follow:     true,
-	ShowStderr: true,
-	ShowStdout: true,
-	Tail:       "20",
-	Timestamps: true,
-}
-
-// stackLogs lists logs for all stack services
-func stackLogs(c *cli.Context, app config.App, client *dockerClient.Client) {
-	filters, err := app.Filters(true, false)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	serviceOpts := types.ServiceListOptions{Filters: filters}
-	services, err := client.ServiceList(context.Background(), serviceOpts)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	var wg sync.WaitGroup
-	for _, service := range services {
-		wg.Add(1)
-		go func(s string) {
-			if internal.StdErrOnly {
-				logOpts.ShowStdout = false
-			}
-
-			logs, err := client.ServiceLogs(context.Background(), s, logOpts)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			defer logs.Close()
-
-			_, err = io.Copy(os.Stdout, logs)
-			if err != nil && err != io.EOF {
-				logrus.Fatal(err)
-			}
-		}(service.ID)
-	}
-
-	wg.Wait()
-
-	os.Exit(0)
-}
-
-var appLogsCommand = cli.Command{
-	Name:      "logs",
-	Aliases:   []string{"l"},
-	ArgsUsage: "<domain> [<service>]",
-	Usage:     "Tail app logs",
-	Flags: []cli.Flag{
-		internal.StdErrOnlyFlag,
-		internal.DebugFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		serviceName := c.Args().Get(1)
-		if serviceName == "" {
-			logrus.Debugf("tailing logs for all %s services", app.Recipe)
-			stackLogs(c, app, cl)
-		} else {
-			logrus.Debugf("tailing logs for %s", serviceName)
-			if err := tailServiceLogs(c, cl, app, serviceName); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		return nil
-	},
-}
-
-func tailServiceLogs(c *cli.Context, cl *dockerClient.Client, app config.App, serviceName string) error {
-	filters := filters.NewArgs()
-	filters.Add("name", fmt.Sprintf("^%s_%s", app.StackName(), serviceName))
-
-	chosenService, err := service.GetService(context.Background(), cl, filters, internal.NoInput)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	if internal.StdErrOnly {
-		logOpts.ShowStdout = false
-	}
-
-	logs, err := cl.ServiceLogs(context.Background(), chosenService.ID, logOpts)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-	defer logs.Close()
-
-	_, err = io.Copy(os.Stdout, logs)
-	if err != nil && err != io.EOF {
-		logrus.Fatal(err)
-	}
-
-	return nil
-}

cli/app/new.go

@@ -1,46 +0,0 @@
-package app
-
-import (
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"github.com/urfave/cli"
-)
-
-var appNewDescription = `
-This command takes a recipe and uses it to create a new app. This new app
-configuration is stored in your ~/.abra directory under the appropriate server.
-
-This command does not deploy your app for you. You will need to run "abra app
-deploy <domain>" to do so.
-
-You can see what recipes are available (i.e. values for the <recipe> argument)
-by running "abra recipe ls".
-
-Passing the "--secrets/-S" flag will automatically generate secrets for your
-app and store them encrypted at rest on the chosen target server. These
-generated secrets are only visible at generation time, so please take care to
-store them somewhere safe.
-
-You can use the "--pass/-P" to store these generated passwords locally in a
-pass store (see passwordstore.org for more). The pass command must be available
-on your $PATH.
-`
-
-var appNewCommand = cli.Command{
-	Name:        "new",
-	Aliases:     []string{"n"},
-	Usage:       "Create a new app",
-	Description: appNewDescription,
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.NewAppServerFlag,
-		internal.DomainFlag,
-		internal.PassFlag,
-		internal.SecretsFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	ArgsUsage:    "[<recipe>]",
-	Action:       internal.NewAction,
-	BashComplete: autocomplete.RecipeNameComplete,
-}

cli/app/ps.go

@@ -1,101 +0,0 @@
-package app
-
-import (
-	"context"
-	"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/formatter"
-	"coopcloud.tech/abra/pkg/service"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/buger/goterm"
-	dockerFormatter "github.com/docker/cli/cli/command/formatter"
-	"github.com/docker/docker/api/types"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appPsCommand = cli.Command{
-	Name:        "ps",
-	Aliases:     []string{"p"},
-	Usage:       "Check app status",
-	ArgsUsage:   "<domain>",
-	Description: "This command shows a more detailed status output of a specific deployed app.",
-	Flags: []cli.Flag{
-		internal.WatchFlag,
-		internal.DebugFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		if !internal.Watch {
-			showPSOutput(c, app, cl)
-			return nil
-		}
-
-		goterm.Clear()
-		for {
-			goterm.MoveCursor(1, 1)
-			showPSOutput(c, app, cl)
-			goterm.Flush()
-			time.Sleep(2 * time.Second)
-		}
-	},
-}
-
-// showPSOutput renders ps output.
-func showPSOutput(c *cli.Context, app config.App, cl *dockerClient.Client) {
-	filters, err := app.Filters(true, true)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	containers, err := cl.ContainerList(context.Background(), types.ContainerListOptions{Filters: filters})
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	tableCol := []string{"service name", "image", "created", "status", "state", "ports"}
-	table := formatter.CreateTable(tableCol)
-
-	for _, container := range containers {
-		var containerNames []string
-		for _, containerName := range container.Names {
-			trimmed := strings.TrimPrefix(containerName, "/")
-			containerNames = append(containerNames, trimmed)
-		}
-
-		tableRow := []string{
-			service.ContainerToServiceName(container.Names, app.StackName()),
-			formatter.RemoveSha(container.Image),
-			formatter.HumanDuration(container.Created),
-			container.Status,
-			container.State,
-			dockerFormatter.DisplayablePorts(container.Ports),
-		}
-		table.Append(tableRow)
-	}
-
-	table.Render()
-}

cli/app/remove.go

@@ -1,174 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/client"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/docker/docker/api/types"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// Volumes stores the variable from VolumesFlag
-var Volumes bool
-
-// VolumesFlag is used to specify if volumes should be deleted when deleting an app
-var VolumesFlag = &cli.BoolFlag{
-	Name:        "volumes, V",
-	Destination: &Volumes,
-}
-
-var appRemoveCommand = cli.Command{
-	Name:      "remove",
-	Aliases:   []string{"rm"},
-	ArgsUsage: "<domain>",
-	Usage:     "Remove an already undeployed app",
-	Flags: []cli.Flag{
-		VolumesFlag,
-		internal.ForceFlag,
-		internal.DebugFlag,
-		internal.NoInputFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		if !internal.Force && !internal.NoInput {
-			response := false
-			prompt := &survey.Confirm{
-				Message: fmt.Sprintf("about to remove %s, are you sure?", app.Name),
-			}
-			if err := survey.AskOne(prompt, &response); err != nil {
-				logrus.Fatal(err)
-			}
-			if !response {
-				logrus.Fatal("aborting as requested")
-			}
-		}
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName())
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		if isDeployed {
-			logrus.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name)
-		}
-
-		fs, err := app.Filters(false, false)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: fs})
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		secrets := make(map[string]string)
-		var secretNames []string
-
-		for _, cont := range secretList {
-			secrets[cont.Spec.Annotations.Name] = cont.ID // we have to map the names to ID's
-			secretNames = append(secretNames, cont.Spec.Annotations.Name)
-		}
-
-		if len(secrets) > 0 {
-			var secretNamesToRemove []string
-
-			if !internal.Force && !internal.NoInput {
-				secretsPrompt := &survey.MultiSelect{
-					Message: "which secrets do you want to remove?",
-					Help:    "'x' indicates selected, enter / return to confirm, ctrl-c to exit, vim mode is enabled",
-					VimMode: true,
-					Options: secretNames,
-					Default: secretNames,
-				}
-				if err := survey.AskOne(secretsPrompt, &secretNamesToRemove); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-
-			if internal.Force || internal.NoInput {
-				secretNamesToRemove = secretNames
-			}
-
-			for _, name := range secretNamesToRemove {
-				err := cl.SecretRemove(context.Background(), secrets[name])
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				logrus.Info(fmt.Sprintf("secret: %s removed", name))
-			}
-		} else {
-			logrus.Info("no secrets to remove")
-		}
-
-		fs, err = app.Filters(false, true)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		volumeListOKBody, err := cl.VolumeList(context.Background(), fs)
-		volumeList := volumeListOKBody.Volumes
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		var vols []string
-		for _, vol := range volumeList {
-			vols = append(vols, vol.Name)
-		}
-
-		if len(vols) > 0 {
-			if Volumes {
-				var removeVols []string
-				if !internal.Force && !internal.NoInput {
-					volumesPrompt := &survey.MultiSelect{
-						Message: "which volumes do you want to remove?",
-						Help:    "'x' indicates selected, enter / return to confirm, ctrl-c to exit, vim mode is enabled",
-						VimMode: true,
-						Options: vols,
-						Default: vols,
-					}
-					if err := survey.AskOne(volumesPrompt, &removeVols); err != nil {
-						logrus.Fatal(err)
-					}
-				}
-
-				for _, vol := range removeVols {
-					err := cl.VolumeRemove(context.Background(), vol, internal.Force) // last argument is for force removing
-					if err != nil {
-						logrus.Fatal(err)
-					}
-					logrus.Info(fmt.Sprintf("volume %s removed", vol))
-				}
-			} else {
-				logrus.Info("no volumes were removed")
-			}
-		} else {
-			if Volumes {
-				logrus.Info("no volumes to remove")
-			}
-		}
-
-		err = os.Remove(app.Path)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		logrus.Info(fmt.Sprintf("file: %s removed", app.Path))
-
-		return nil
-	},
-	BashComplete: autocomplete.AppNameComplete,
-}

cli/app/restart.go

@@ -1,70 +0,0 @@
-package app
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/client"
-	upstream "coopcloud.tech/abra/pkg/upstream/service"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appRestartCommand = cli.Command{
-	Name:      "restart",
-	Aliases:   []string{"re"},
-	Usage:     "Restart an app",
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	Description:  `This command restarts a service within a deployed app.`,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		serviceNameShort := c.Args().Get(1)
-		if serviceNameShort == "" {
-			err := errors.New("missing service?")
-			internal.ShowSubcommandHelpAndError(c, err)
-		}
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		serviceName := fmt.Sprintf("%s_%s", app.StackName(), serviceNameShort)
-
-		logrus.Debugf("attempting to scale %s to 0 (restart logic)", serviceName)
-		if err := upstream.RunServiceScale(context.Background(), cl, serviceName, 0); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := stack.WaitOnService(context.Background(), cl, serviceName, app.Name); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("%s has been scaled to 0 (restart logic)", serviceName)
-
-		logrus.Debugf("attempting to scale %s to 1 (restart logic)", serviceName)
-		if err := upstream.RunServiceScale(context.Background(), cl, serviceName, 1); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := stack.WaitOnService(context.Background(), cl, serviceName, app.Name); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("%s has been scaled to 1 (restart logic)", serviceName)
-
-		logrus.Infof("%s service successfully restarted", serviceNameShort)
-
-		return nil
-	},
-}

cli/app/rollback.go

@@ -1,194 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/lint"
-	"coopcloud.tech/abra/pkg/recipe"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"coopcloud.tech/tagcmp"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/client"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appRollbackCommand = cli.Command{
-	Name:      "rollback",
-	Aliases:   []string{"rl"},
-	Usage:     "Roll an app back to a previous version",
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.ForceFlag,
-		internal.ChaosFlag,
-		internal.NoDomainChecksFlag,
-		internal.DontWaitConvergeFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-This command rolls an app back to a previous version if one exists.
-
-You may pass "--force/-f" to downgrade to the same version again. This can be
-useful if the container runtime has gotten into a weird state.
-
-This action could be destructive, please ensure you have a copy of your app
-data beforehand.
-
-Chas mode ("--chaos") will deploy your local checkout of a recipe as-is,
-including unstaged changes and can be useful for live hacking and testing new
-recipes.
-`,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-		stackName := app.StackName()
-
-		if !internal.Chaos {
-			if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := lint.LintForErrors(r); err != nil {
-			logrus.Fatal(err)
-		}
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("checking whether %s is already deployed", stackName)
-
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		catl, err := recipe.ReadRecipeCatalogue()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if len(versions) == 0 && !internal.Chaos {
-			logrus.Fatalf("no published releases for %s in the recipe catalogue?", app.Recipe)
-		}
-
-		var availableDowngrades []string
-		if deployedVersion == "unknown" {
-			availableDowngrades = versions
-			logrus.Warnf("failed to determine version of deployed %s", app.Name)
-		}
-
-		if deployedVersion != "unknown" && !internal.Chaos {
-			for _, version := range versions {
-				parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				parsedVersion, err := tagcmp.Parse(version)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				if parsedVersion != parsedDeployedVersion && parsedVersion.IsLessThan(parsedDeployedVersion) {
-					availableDowngrades = append(availableDowngrades, version)
-				}
-			}
-
-			if len(availableDowngrades) == 0 {
-				logrus.Info("no available downgrades, you're on oldest ✌️")
-				return nil
-			}
-		}
-
-		availableDowngrades = internal.ReverseStringList(availableDowngrades)
-
-		var chosenDowngrade string
-		if !internal.Chaos {
-			if internal.Force || internal.NoInput {
-				chosenDowngrade = availableDowngrades[0]
-				logrus.Debugf("choosing %s as version to downgrade to (--force)", chosenDowngrade)
-			} else {
-				prompt := &survey.Select{
-					Message: fmt.Sprintf("Please select a downgrade (current version: %s):", deployedVersion),
-					Options: availableDowngrades,
-				}
-				if err := survey.AskOne(prompt, &chosenDowngrade); err != nil {
-					return err
-				}
-			}
-		}
-
-		if !internal.Chaos {
-			if err := recipe.EnsureVersion(app.Recipe, chosenDowngrade); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if internal.Chaos {
-			logrus.Warn("chaos mode engaged")
-			var err error
-			chosenDowngrade, err = recipe.ChaosVersion(app.Recipe)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
-		abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		for k, v := range abraShEnv {
-			app.Env[k] = v
-		}
-
-		composeFiles, err := config.GetAppComposeFiles(app.Recipe, app.Env)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		deployOpts := stack.Deploy{
-			Composefiles: composeFiles,
-			Namespace:    stackName,
-			Prune:        false,
-			ResolveImage: stack.ResolveImageAlways,
-		}
-		compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Force {
-			if err := internal.NewVersionOverview(app, deployedVersion, chosenDowngrade, ""); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if err := stack.RunDeploy(cl, deployOpts, compose, app.StackName(), internal.DontWaitConverge); err != nil {
-			logrus.Fatal(err)
-		}
-
-		return nil
-	},
-}

cli/app/run.go

@@ -1,100 +0,0 @@
-package app
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/client"
-	containerPkg "coopcloud.tech/abra/pkg/container"
-	"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"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var user string
-var userFlag = &cli.StringFlag{
-	Name:        "user, u",
-	Value:       "",
-	Destination: &user,
-}
-
-var noTTY bool
-var noTTYFlag = &cli.BoolFlag{
-	Name:        "no-tty, t",
-	Destination: &noTTY,
-}
-
-var appRunCommand = cli.Command{
-	Name:    "run",
-	Aliases: []string{"r"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		noTTYFlag,
-		userFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	ArgsUsage:    "<domain> <service> <args>...",
-	Usage:        "Run a command in a service container",
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		if len(c.Args()) < 2 {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no <service> provided?"))
-		}
-
-		if len(c.Args()) < 3 {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no <args> provided?"))
-		}
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		serviceName := c.Args().Get(1)
-		stackAndServiceName := fmt.Sprintf("^%s_%s", app.StackName(), serviceName)
-		filters := filters.NewArgs()
-		filters.Add("name", stackAndServiceName)
-
-		targetContainer, err := containerPkg.GetContainer(context.Background(), cl, filters, false)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		cmd := c.Args()[2:]
-		execCreateOpts := types.ExecConfig{
-			AttachStderr: true,
-			AttachStdin:  true,
-			AttachStdout: true,
-			Cmd:          cmd,
-			Detach:       false,
-			Tty:          true,
-		}
-
-		if user != "" {
-			execCreateOpts.User = user
-		}
-		if noTTY {
-			execCreateOpts.Tty = false
-		}
-
-		// FIXME: avoid instantiating a new CLI
-		dcli, err := command.NewDockerCli()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil {
-			logrus.Fatal(err)
-		}
-
-		return nil
-	},
-}

cli/app/secret.go

@@ -1,348 +0,0 @@
-package app
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"strconv"
-
-	"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"
-	"coopcloud.tech/abra/pkg/secret"
-	"github.com/docker/docker/api/types"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var allSecrets bool
-var allSecretsFlag = &cli.BoolFlag{
-	Name:        "all, a",
-	Destination: &allSecrets,
-	Usage:       "Generate all secrets",
-}
-
-var rmAllSecrets bool
-var rmAllSecretsFlag = &cli.BoolFlag{
-	Name:        "all, a",
-	Destination: &rmAllSecrets,
-	Usage:       "Remove all secrets",
-}
-
-var appSecretGenerateCommand = cli.Command{
-	Name:      "generate",
-	Aliases:   []string{"g"},
-	Usage:     "Generate secrets",
-	ArgsUsage: "<domain> <secret> <version>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		allSecretsFlag,
-		internal.PassFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		if len(c.Args()) == 1 && !allSecrets {
-			err := errors.New("missing arguments <secret>/<version> or '--all'")
-			internal.ShowSubcommandHelpAndError(c, err)
-		}
-
-		if c.Args().Get(1) != "" && allSecrets {
-			err := errors.New("cannot use '<secret> <version>' and '--all' together")
-			internal.ShowSubcommandHelpAndError(c, err)
-		}
-
-		secretsToCreate := make(map[string]string)
-		secretEnvVars := secret.ReadSecretEnvVars(app.Env)
-		if allSecrets {
-			secretsToCreate = secretEnvVars
-		} else {
-			secretName := c.Args().Get(1)
-			secretVersion := c.Args().Get(2)
-			matches := false
-			for sec := range secretEnvVars {
-				parsed := secret.ParseSecretEnvVarName(sec)
-				if secretName == parsed {
-					secretsToCreate[sec] = secretVersion
-					matches = true
-				}
-			}
-
-			if !matches {
-				logrus.Fatalf("%s doesn't exist in the env config?", secretName)
-			}
-		}
-
-		secretVals, err := secret.GenerateSecrets(secretsToCreate, app.StackName(), app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if internal.Pass {
-			for name, data := range secretVals {
-				if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-		}
-
-		if len(secretVals) == 0 {
-			logrus.Warn("no secrets generated")
-			os.Exit(1)
-		}
-
-		tableCol := []string{"name", "value"}
-		table := formatter.CreateTable(tableCol)
-		for name, val := range secretVals {
-			table.Append([]string{name, val})
-		}
-		table.Render()
-		logrus.Warn("generated secrets are not shown again, please take note of them *now*")
-
-		return nil
-	},
-}
-
-var appSecretInsertCommand = cli.Command{
-	Name:    "insert",
-	Aliases: []string{"i"},
-	Usage:   "Insert secret",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.PassFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	ArgsUsage:    "<domain> <secret-name> <version> <data>",
-	BashComplete: autocomplete.AppNameComplete,
-	Description: `
-This command inserts a secret into an app environment.
-
-This can be useful when you want to manually generate secrets for an app
-environment. Typically, you can let Abra generate them for you on app creation
-(see "abra app new --secrets" for more).
-
-Example:
-
-    abra app secret insert myapp db_pass v1 mySecretPassword
-
-`,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		if len(c.Args()) != 4 {
-			internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments?"))
-		}
-
-		name := c.Args().Get(1)
-		version := c.Args().Get(2)
-		data := c.Args().Get(3)
-
-		secretName := fmt.Sprintf("%s_%s_%s", app.StackName(), name, version)
-		if err := client.StoreSecret(secretName, data, app.Server); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Infof("%s successfully stored on server", secretName)
-
-		if internal.Pass {
-			if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		return nil
-	},
-}
-
-// secretRm removes a secret.
-func secretRm(cl *dockerClient.Client, app config.App, secretName, parsed string) error {
-	if err := cl.SecretRemove(context.Background(), secretName); err != nil {
-		return err
-	}
-
-	logrus.Infof("deleted %s successfully from server", secretName)
-
-	if internal.PassRemove {
-		if err := secret.PassRmSecret(parsed, app.StackName(), app.Server); err != nil {
-			return err
-		}
-
-		logrus.Infof("deleted %s successfully from local pass store", secretName)
-	}
-
-	return nil
-}
-
-var appSecretRmCommand = cli.Command{
-	Name:    "remove",
-	Aliases: []string{"rm"},
-	Usage:   "Remove a secret",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		rmAllSecretsFlag,
-		internal.PassRemoveFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	ArgsUsage:    "<domain> [<secret-name>]",
-	BashComplete: autocomplete.AppNameComplete,
-	Description: `
-This command removes app secrets.
-
-Example:
-
-    abra app secret remove myapp db_pass
-`,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-		secrets := secret.ReadSecretEnvVars(app.Env)
-
-		if c.Args().Get(1) != "" && rmAllSecrets {
-			internal.ShowSubcommandHelpAndError(c, errors.New("cannot use '<secret-name>' and '--all' together"))
-		}
-
-		if c.Args().Get(1) == "" && !rmAllSecrets {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no secret(s) specified?"))
-		}
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		filters, err := app.Filters(false, false)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: filters})
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		remoteSecretNames := make(map[string]bool)
-		for _, cont := range secretList {
-			remoteSecretNames[cont.Spec.Annotations.Name] = true
-		}
-
-		match := false
-		secretToRm := c.Args().Get(1)
-		for sec := range secrets {
-			secretName := secret.ParseSecretEnvVarName(sec)
-
-			secVal, err := secret.ParseSecretEnvVarValue(secrets[sec])
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			secretRemoteName := fmt.Sprintf("%s_%s_%s", app.StackName(), secretName, secVal.Version)
-			if _, ok := remoteSecretNames[secretRemoteName]; ok {
-				if secretToRm != "" {
-					if secretName == secretToRm {
-						if err := secretRm(cl, app, secretRemoteName, secretName); err != nil {
-							logrus.Fatal(err)
-						}
-
-						return nil
-					}
-				} else {
-					match = true
-
-					if err := secretRm(cl, app, secretRemoteName, secretName); err != nil {
-						logrus.Fatal(err)
-					}
-				}
-			}
-		}
-
-		if !match && secretToRm != "" {
-			logrus.Fatalf("%s doesn't exist on server?", secretToRm)
-		}
-
-		if !match {
-			logrus.Fatal("no secrets to remove?")
-		}
-
-		return nil
-	},
-}
-
-var appSecretLsCommand = cli.Command{
-	Name:    "list",
-	Aliases: []string{"ls"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Usage:  "List all secrets",
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-		secrets := secret.ReadSecretEnvVars(app.Env)
-
-		tableCol := []string{"Name", "Version", "Generated Name", "Created On Server"}
-		table := formatter.CreateTable(tableCol)
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		filters, err := app.Filters(false, false)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: filters})
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		remoteSecretNames := make(map[string]bool)
-		for _, cont := range secretList {
-			remoteSecretNames[cont.Spec.Annotations.Name] = true
-		}
-
-		for sec := range secrets {
-			createdRemote := false
-			secretName := secret.ParseSecretEnvVarName(sec)
-			secVal, err := secret.ParseSecretEnvVarValue(secrets[sec])
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			secretRemoteName := fmt.Sprintf("%s_%s_%s", app.StackName(), secretName, secVal.Version)
-			if _, ok := remoteSecretNames[secretRemoteName]; ok {
-				createdRemote = true
-			}
-			tableRow := []string{secretName, secVal.Version, secretRemoteName, strconv.FormatBool(createdRemote)}
-			table.Append(tableRow)
-		}
-
-		if table.NumLines() > 0 {
-			table.Render()
-		} else {
-			logrus.Warnf("no secrets stored for %s", app.Name)
-		}
-
-		return nil
-	},
-	BashComplete: autocomplete.AppNameComplete,
-}
-
-var appSecretCommand = cli.Command{
-	Name:      "secret",
-	Aliases:   []string{"s"},
-	Usage:     "Manage app secrets",
-	ArgsUsage: "<domain>",
-	Subcommands: []cli.Command{
-		appSecretGenerateCommand,
-		appSecretInsertCommand,
-		appSecretRmCommand,
-		appSecretLsCommand,
-	},
-}

cli/app/undeploy.go

@@ -1,61 +0,0 @@
-package app
-
-import (
-	"context"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/client"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appUndeployCommand = cli.Command{
-	Name:      "undeploy",
-	Aliases:   []string{"un"},
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Usage:  "Undeploy an app",
-	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.
-`,
-	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)
-		}
-
-		logrus.Debugf("checking whether %s is already deployed", stackName)
-
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		if err := internal.DeployOverview(app, deployedVersion, "continue with undeploy?"); err != nil {
-			logrus.Fatal(err)
-		}
-
-		rmOpts := stack.Remove{Namespaces: []string{app.StackName()}}
-		if err := stack.RunRemove(context.Background(), cl, rmOpts); err != nil {
-			logrus.Fatal(err)
-		}
-
-		return nil
-	},
-	BashComplete: autocomplete.AppNameComplete,
-}

cli/app/upgrade.go

@@ -1,204 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/lint"
-	"coopcloud.tech/abra/pkg/recipe"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	"coopcloud.tech/tagcmp"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appUpgradeCommand = cli.Command{
-	Name:      "upgrade",
-	Aliases:   []string{"up"},
-	Usage:     "Upgrade an app",
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.ForceFlag,
-		internal.ChaosFlag,
-		internal.NoDomainChecksFlag,
-		internal.DontWaitConvergeFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-This command supports upgrading an app. You can use it to choose and roll out a
-new upgrade to an existing app.
-
-This command specifically supports incrementing the version of running apps, as
-opposed to "abra app deploy <domain>" which will not change the version of a
-deployed app.
-
-You may pass "--force/-f" to upgrade to the same version again. This can be
-useful if the container runtime has gotten into a weird state.
-
-This action could be destructive, please ensure you have a copy of your app
-data beforehand.
-
-Chas mode ("--chaos") will deploy your local checkout of a recipe as-is,
-including unstaged changes and can be useful for live hacking and testing new
-recipes.
-`,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-		stackName := app.StackName()
-
-		if !internal.Chaos {
-			if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		r, err := recipe.Get(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := lint.LintForErrors(r); err != nil {
-			logrus.Fatal(err)
-		}
-
-		cl, err := client.New(app.Server)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Debugf("checking whether %s is already deployed", stackName)
-
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		catl, err := recipe.ReadRecipeCatalogue()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if len(versions) == 0 && !internal.Chaos {
-			logrus.Fatalf("no published releases for %s in the recipe catalogue?", app.Recipe)
-		}
-
-		var availableUpgrades []string
-		if deployedVersion == "unknown" {
-			availableUpgrades = versions
-			logrus.Warnf("failed to determine version of deployed %s", app.Name)
-		}
-
-		if deployedVersion != "unknown" && !internal.Chaos {
-			for _, version := range versions {
-				parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				parsedVersion, err := tagcmp.Parse(version)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				if parsedVersion.IsGreaterThan(parsedDeployedVersion) {
-					availableUpgrades = append(availableUpgrades, version)
-				}
-			}
-
-			if len(availableUpgrades) == 0 && !internal.Force {
-				logrus.Infof("no available upgrades, you're on latest (%s) ✌️", deployedVersion)
-				return nil
-			}
-		}
-
-		availableUpgrades = internal.ReverseStringList(availableUpgrades)
-
-		var chosenUpgrade string
-		if len(availableUpgrades) > 0 && !internal.Chaos {
-			if internal.Force || internal.NoInput {
-				chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
-				logrus.Debugf("choosing %s as version to upgrade to", chosenUpgrade)
-			} else {
-				prompt := &survey.Select{
-					Message: fmt.Sprintf("Please select an upgrade (current version: %s):", deployedVersion),
-					Options: availableUpgrades,
-				}
-				if err := survey.AskOne(prompt, &chosenUpgrade); err != nil {
-					return err
-				}
-			}
-		}
-
-		// if release notes written after git tag published, read them before we
-		// check out the tag and then they'll appear to be missing. this covers
-		// when we obviously will forget to write release notes before publishing
-		releaseNotes, err := internal.GetReleaseNotes(app.Recipe, chosenUpgrade)
-		if err != nil {
-			return err
-		}
-
-		if !internal.Chaos {
-			if err := recipe.EnsureVersion(app.Recipe, chosenUpgrade); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if internal.Chaos {
-			logrus.Warn("chaos mode engaged")
-			var err error
-			chosenUpgrade, err = recipe.ChaosVersion(app.Recipe)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
-		abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		for k, v := range abraShEnv {
-			app.Env[k] = v
-		}
-
-		composeFiles, err := config.GetAppComposeFiles(app.Recipe, app.Env)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		deployOpts := stack.Deploy{
-			Composefiles: composeFiles,
-			Namespace:    stackName,
-			Prune:        false,
-			ResolveImage: stack.ResolveImageAlways,
-		}
-		compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := internal.NewVersionOverview(app, deployedVersion, chosenUpgrade, releaseNotes); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := stack.RunDeploy(cl, deployOpts, compose, app.StackName(), internal.DontWaitConverge); err != nil {
-			logrus.Fatal(err)
-		}
-
-		return nil
-	},
-	BashComplete: autocomplete.AppNameComplete,
-}

cli/app/version.go

@@ -1,101 +0,0 @@
-package app
-
-import (
-	"context"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/docker/distribution/reference"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// getImagePath returns the image name
-func getImagePath(image string) (string, error) {
-	img, err := reference.ParseNormalizedNamed(image)
-	if err != nil {
-		return "", err
-	}
-
-	path := reference.Path(img)
-
-	path = formatter.StripTagMeta(path)
-
-	logrus.Debugf("parsed %s from %s", path, image)
-
-	return path, nil
-}
-
-var appVersionCommand = cli.Command{
-	Name:      "version",
-	Aliases:   []string{"v"},
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Usage:  "Show app versions",
-	Description: `
-This command shows all information about versioning related to a deployed app.
-This includes the individual image names, tags and digests. But also the Co-op
-Cloud recipe version.
-`,
-	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)
-		}
-
-		logrus.Debugf("checking whether %s is already deployed", stackName)
-
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if deployedVersion == "unknown" {
-			logrus.Fatalf("failed to determine version of deployed %s", app.Name)
-		}
-
-		if !isDeployed {
-			logrus.Fatalf("%s is not deployed?", app.Name)
-		}
-
-		recipeMeta, err := recipe.GetRecipeMeta(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		versionsMeta := make(map[string]recipe.ServiceMeta)
-		for _, recipeVersion := range recipeMeta.Versions {
-			if currentVersion, exists := recipeVersion[deployedVersion]; exists {
-				versionsMeta = currentVersion
-			}
-		}
-
-		if len(versionsMeta) == 0 {
-			logrus.Fatalf("could not retrieve deployed version (%s) from recipe catalogue?", deployedVersion)
-		}
-
-		tableCol := []string{"version", "service", "image", "digest"}
-		table := formatter.CreateTable(tableCol)
-		table.SetAutoMergeCellsByColumnIndex([]int{0})
-
-		for serviceName, versionMeta := range versionsMeta {
-			table.Append([]string{deployedVersion, serviceName, versionMeta.Image, versionMeta.Digest})
-		}
-
-		table.Render()
-
-		return nil
-	},
-	BashComplete: autocomplete.AppNameComplete,
-}

cli/app/volume.go

@@ -1,133 +0,0 @@
-package app
-
-import (
-	"context"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/formatter"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var appVolumeListCommand = cli.Command{
-	Name:      "list",
-	Aliases:   []string{"ls"},
-	ArgsUsage: "<domain>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	Usage:        "List volumes associated with an app",
-	BashComplete: autocomplete.AppNameComplete,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		filters, err := app.Filters(false, true)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		volumeList, err := client.GetVolumes(context.Background(), app.Server, filters)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		table := formatter.CreateTable([]string{"name", "created", "mounted"})
-		var volTable [][]string
-		for _, volume := range volumeList {
-			volRow := []string{volume.Name, volume.CreatedAt, volume.Mountpoint}
-			volTable = append(volTable, volRow)
-		}
-
-		table.AppendBulk(volTable)
-
-		if table.NumLines() > 0 {
-			table.Render()
-		} else {
-			logrus.Warnf("no volumes created for %s", app.Name)
-		}
-
-		return nil
-	},
-}
-
-var appVolumeRemoveCommand = cli.Command{
-	Name:  "remove",
-	Usage: "Remove volume(s) associated with an app",
-	Description: `
-This command supports removing volumes associated with an app. The app in
-question must be undeployed before you try to remove volumes. See "abra app
-undeploy <domain>" for more.
-
-The command is interactive and will show a multiple select input which allows
-you to make a seclection. Use the "?" key to see more help on navigating this
-interface.
-
-Passing "--force/-f" will select all volumes for removal. Be careful.
-`,
-	ArgsUsage: "<domain>",
-	Aliases:   []string{"rm"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.ForceFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		app := internal.ValidateApp(c)
-
-		filters, err := app.Filters(false, true)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		volumeList, err := client.GetVolumes(context.Background(), app.Server, filters)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		volumeNames := client.GetVolumeNames(volumeList)
-
-		var volumesToRemove []string
-		if !internal.Force && !internal.NoInput {
-			volumesPrompt := &survey.MultiSelect{
-				Message: "which volumes do you want to remove?",
-				Help:    "'x' indicates selected, enter / return to confirm, ctrl-c to exit, vim mode is enabled",
-				VimMode: true,
-				Options: volumeNames,
-				Default: volumeNames,
-			}
-			if err := survey.AskOne(volumesPrompt, &volumesToRemove); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if internal.Force || internal.NoInput {
-			volumesToRemove = volumeNames
-		}
-
-		err = client.RemoveVolumes(context.Background(), app.Server, volumesToRemove, internal.Force)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Info("volumes removed successfully")
-
-		return nil
-	},
-	BashComplete: autocomplete.AppNameComplete,
-}
-
-var appVolumeCommand = cli.Command{
-	Name:      "volume",
-	Aliases:   []string{"vl"},
-	Usage:     "Manage app volumes",
-	ArgsUsage: "<domain>",
-	Subcommands: []cli.Command{
-		appVolumeListCommand,
-		appVolumeRemoveCommand,
-	},
-}

cli/catalogue/catalogue.go

@@ -1,317 +0,0 @@
-package catalogue
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"path"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/formatter"
-	gitPkg "coopcloud.tech/abra/pkg/git"
-	"coopcloud.tech/abra/pkg/limit"
-	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// CatalogueSkipList is all the repos that are not recipes.
-var CatalogueSkipList = map[string]bool{
-	"abra":                   true,
-	"abra-apps":              true,
-	"abra-aur":               true,
-	"abra-bash":              true,
-	"abra-capsul":            true,
-	"abra-gandi":             true,
-	"abra-hetzner":           true,
-	"apps":                   true,
-	"aur-abra-git":           true,
-	"auto-apps-json":         true,
-	"auto-mirror":            true,
-	"backup-bot":             true,
-	"backup-bot-two":         true,
-	"beta.coopcloud.tech":    true,
-	"comrade-renovate-bot":   true,
-	"coopcloud.tech":         true,
-	"coturn":                 true,
-	"docker-cp-deploy":       true,
-	"docker-dind-bats-kcov":  true,
-	"docs.coopcloud.tech":    true,
-	"drone-abra":             true,
-	"example":                true,
-	"gardening":              true,
-	"go-abra":                true,
-	"organising":             true,
-	"outline-with-patch":     true,
-	"pyabra":                 true,
-	"radicle-seed-node":      true,
-	"recipes-catalogue-json": true,
-	"recipes-wishlist":       true,
-	"recipes.coopcloud.tech": true,
-	"stack-ssh-deploy":       true,
-	"swarm-cronjob":          true,
-	"tagcmp":                 true,
-	"traefik-cert-dumper":    true,
-	"tyop":                   true,
-}
-
-var catalogueGenerateCommand = cli.Command{
-	Name:    "generate",
-	Aliases: []string{"g"},
-	Usage:   "Generate the recipe catalogue",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.PublishFlag,
-		internal.DryFlag,
-		internal.SkipUpdatesFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-This command generates a new copy of the recipe catalogue which can be found on:
-
-    https://recipes.coopcloud.tech
-
-It polls the entire git.coopcloud.tech/coop-cloud/... recipe repository
-listing, parses README.md and git tags of those repositories to produce recipe
-metadata and produces a recipes JSON file.
-
-It is possible to generate new metadata for a single recipe by passing
-<recipe>. The existing local catalogue will be updated, not overwritten.
-
-It is quite easy to get rate limited by Docker Hub when running this command.
-If you have a Hub account you can have Abra log you in to avoid this. Pass
-"--user" and "--pass".
-
-Push your new release git.coopcloud.tech with "-p/--publish". This requires
-that you have permission to git push to these repositories and have your SSH
-keys configured on your account.
-`,
-	ArgsUsage: "[<recipe>]",
-	Action: func(c *cli.Context) error {
-		recipeName := c.Args().First()
-		if recipeName != "" {
-			internal.ValidateRecipe(c, true)
-		}
-
-		repos, err := recipe.ReadReposMetadata()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		var barLength int
-		var logMsg string
-		if recipeName != "" {
-			barLength = 1
-			logMsg = fmt.Sprintf("ensuring %v recipe is cloned & up-to-date", barLength)
-		} else {
-			barLength = len(repos)
-			logMsg = fmt.Sprintf("ensuring %v recipes are cloned & up-to-date, this could take some time...", barLength)
-		}
-
-		if !internal.SkipUpdates {
-			logrus.Warn(logMsg)
-			if err := updateRepositories(repos, recipeName); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		catl := make(recipe.RecipeCatalogue)
-		catlBar := formatter.CreateProgressbar(barLength, "generating catalogue metadata...")
-		for _, recipeMeta := range repos {
-			if recipeName != "" && recipeName != recipeMeta.Name {
-				catlBar.Add(1)
-				continue
-			}
-
-			if _, exists := CatalogueSkipList[recipeMeta.Name]; exists {
-				catlBar.Add(1)
-				continue
-			}
-
-			versions, err := recipe.GetRecipeVersions(recipeMeta.Name)
-			if err != nil {
-				logrus.Warn(err)
-			}
-
-			features, category, err := recipe.GetRecipeFeaturesAndCategory(recipeMeta.Name)
-			if err != nil {
-				logrus.Warn(err)
-			}
-
-			catl[recipeMeta.Name] = recipe.RecipeMeta{
-				Name:          recipeMeta.Name,
-				Repository:    recipeMeta.CloneURL,
-				SSHURL:        recipeMeta.SSHURL,
-				Icon:          recipeMeta.AvatarURL,
-				DefaultBranch: recipeMeta.DefaultBranch,
-				Description:   recipeMeta.Description,
-				Website:       recipeMeta.Website,
-				Versions:      versions,
-				Category:      category,
-				Features:      features,
-			}
-
-			catlBar.Add(1)
-		}
-
-		recipesJSON, err := json.MarshalIndent(catl, "", "    ")
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if recipeName == "" {
-			if err := ioutil.WriteFile(config.RECIPES_JSON, recipesJSON, 0764); err != nil {
-				logrus.Fatal(err)
-			}
-		} else {
-			catlFS, err := recipe.ReadRecipeCatalogue()
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			catlFS[recipeName] = catl[recipeName]
-
-			updatedRecipesJSON, err := json.MarshalIndent(catlFS, "", "    ")
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			if err := ioutil.WriteFile(config.RECIPES_JSON, updatedRecipesJSON, 0764); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		logrus.Infof("generated new recipe catalogue in %s", config.RECIPES_JSON)
-
-		cataloguePath := path.Join(config.ABRA_DIR, "catalogue")
-		if internal.Publish {
-
-			isClean, err := gitPkg.IsClean(cataloguePath)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			if isClean {
-				if !internal.Dry {
-					logrus.Fatalf("no changes discovered in %s, nothing to publish?", cataloguePath)
-				}
-			}
-
-			msg := "chore: publish new catalogue release changes"
-			if err := gitPkg.Commit(cataloguePath, "**.json", msg, internal.Dry); err != nil {
-				logrus.Fatal(err)
-			}
-
-			repo, err := git.PlainOpen(cataloguePath)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			sshURL := fmt.Sprintf(config.SSH_URL_TEMPLATE, config.CATALOGUE_JSON_REPO_NAME)
-			if err := gitPkg.CreateRemote(repo, "origin-ssh", sshURL, internal.Dry); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if err := gitPkg.Push(cataloguePath, "origin-ssh", false, internal.Dry); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		repo, err := git.PlainOpen(cataloguePath)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		head, err := repo.Head()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !internal.Dry && internal.Publish {
-			url := fmt.Sprintf("%s/%s/commit/%s", config.REPOS_BASE_URL, config.CATALOGUE_JSON_REPO_NAME, head.Hash())
-			logrus.Infof("new changes published: %s", url)
-		}
-
-		if internal.Dry {
-			logrus.Info("dry run: no changes published")
-		}
-
-		return nil
-	},
-	BashComplete: autocomplete.RecipeNameComplete,
-}
-
-// CatalogueCommand defines the `abra catalogue` command and sub-commands.
-var CatalogueCommand = cli.Command{
-	Name:        "catalogue",
-	Usage:       "Manage the recipe catalogue",
-	Aliases:     []string{"c"},
-	ArgsUsage:   "<recipe>",
-	Description: "This command helps recipe packagers interact with the recipe catalogue",
-	Subcommands: []cli.Command{
-		catalogueGenerateCommand,
-	},
-}
-
-func updateRepositories(repos recipe.RepoCatalogue, recipeName string) error {
-	var barLength int
-	if recipeName != "" {
-		barLength = 1
-	} else {
-		barLength = len(repos)
-	}
-
-	cloneLimiter := limit.New(10)
-
-	retrieveBar := formatter.CreateProgressbar(barLength, "ensuring recipes are cloned & up-to-date...")
-	ch := make(chan string, barLength)
-	for _, repoMeta := range repos {
-		go func(rm recipe.RepoMeta) {
-			cloneLimiter.Begin()
-			defer cloneLimiter.End()
-
-			if recipeName != "" && recipeName != rm.Name {
-				ch <- rm.Name
-				retrieveBar.Add(1)
-				return
-			}
-			if _, exists := CatalogueSkipList[rm.Name]; exists {
-				ch <- rm.Name
-				retrieveBar.Add(1)
-				return
-			}
-
-			recipeDir := path.Join(config.RECIPES_DIR, rm.Name)
-
-			if err := gitPkg.Clone(recipeDir, rm.CloneURL); err != nil {
-				logrus.Fatal(err)
-			}
-
-			isClean, err := gitPkg.IsClean(recipeDir)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			if !isClean {
-				logrus.Fatalf("%s has locally unstaged changes", rm.Name)
-			}
-
-			if err := recipe.EnsureUpToDate(rm.Name); err != nil {
-				logrus.Fatal(err)
-			}
-
-			ch <- rm.Name
-			retrieveBar.Add(1)
-		}(repoMeta)
-	}
-
-	for range repos {
-		<-ch // wait for everything
-	}
-
-	return nil
-}

cli/cli.go

@@ -1,200 +0,0 @@
-// Package cli provides the interface for the command-line.
-package cli
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"os/exec"
-	"path"
-
-	"coopcloud.tech/abra/cli/app"
-	"coopcloud.tech/abra/cli/catalogue"
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/cli/recipe"
-	"coopcloud.tech/abra/cli/record"
-	"coopcloud.tech/abra/cli/server"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/web"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// AutoCompleteCommand helps people set up auto-complete in their shells
-var AutoCompleteCommand = cli.Command{
-	Name:    "autocomplete",
-	Aliases: []string{"ac"},
-	Usage:   "Configure shell autocompletion (recommended)",
-	Description: `
-This command helps set up autocompletion in your shell by downloading the
-relevant autocompletion files and laying out what additional information must
-be loaded.
-
-Example:
-
-    abra autocomplete bash
-
-Supported shells are as follows:
-
-		fizsh
-		zsh
-    bash
-`,
-	ArgsUsage: "<shell>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-	},
-	Action: func(c *cli.Context) error {
-		shellType := c.Args().First()
-
-		if shellType == "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no shell provided"))
-		}
-
-		supportedShells := map[string]bool{
-			"bash":  true,
-			"zsh":   true,
-			"fizsh": true,
-		}
-
-		if _, ok := supportedShells[shellType]; !ok {
-			logrus.Fatalf("%s is not a supported shell right now, sorry", shellType)
-		}
-
-		if shellType == "fizsh" {
-			shellType = "zsh" // handled the same on the autocompletion side
-		}
-
-		autocompletionDir := path.Join(config.ABRA_DIR, "autocompletion")
-		if err := os.Mkdir(autocompletionDir, 0764); err != nil {
-			if !os.IsExist(err) {
-				logrus.Fatal(err)
-			}
-			logrus.Debugf("%s already created", autocompletionDir)
-		}
-
-		autocompletionFile := path.Join(config.ABRA_DIR, "autocompletion", shellType)
-		if _, err := os.Stat(autocompletionFile); err != nil && os.IsNotExist(err) {
-			url := fmt.Sprintf("https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/autocomplete/%s", shellType)
-			logrus.Infof("fetching %s", url)
-			if err := web.GetFile(autocompletionFile, url); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		switch shellType {
-		case "bash":
-			fmt.Println(fmt.Sprintf(`
-# Run the following commands to install autocompletion
-sudo mkdir /etc/bash_completion.d/
-sudo cp %s /etc/bash_completion.d/abra
-echo "source /etc/bash_completion.d/abra" >> ~/.bashrc
-# And finally run "abra app ps <hit tab key>" to test things are working, you should see app domains listed!
-`, autocompletionFile))
-		case "zsh":
-			fmt.Println(fmt.Sprintf(`
-# Run the following commands to install autocompletion
-sudo mkdir /etc/zsh/completion.d/
-sudo cp %s /etc/zsh/completion.d/abra
-echo "PROG=abra\n_CLI_ZSH_AUTOCOMPLETE_HACK=1\nsource /etc/zsh/completion.d/abra" >> ~/.zshrc
-# And finally run "abra app ps <hit tab key>" to test things are working, you should see app domains listed!
-`, autocompletionFile))
-		}
-
-		return nil
-	},
-}
-
-// UpgradeCommand upgrades abra in-place.
-var UpgradeCommand = cli.Command{
-	Name:    "upgrade",
-	Aliases: []string{"u"},
-	Usage:   "Upgrade Abra itself",
-	Description: `
-This command allows you to upgrade Abra in-place with the latest stable or
-release candidate.
-
-If you would like to install the latest release candidate, please pass the
-"-r/--rc" option. Please bear in mind that the latest release candidate may
-have some catastrophic bugs contained in it. In any case, thank you very much
-for the testing efforts!
-`,
-	Flags: []cli.Flag{internal.RCFlag},
-	Action: func(c *cli.Context) error {
-		mainURL := "https://install.abra.coopcloud.tech"
-		cmd := exec.Command("bash", "-c", fmt.Sprintf("wget -q -O- %s | bash", mainURL))
-
-		if internal.RC {
-			releaseCandidateURL := "https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/installer/installer"
-			cmd = exec.Command("bash", "-c", fmt.Sprintf("wget -q -O- %s | bash -s -- --rc", releaseCandidateURL))
-		}
-
-		logrus.Debugf("attempting to run %s", cmd)
-
-		if err := internal.RunCmd(cmd); err != nil {
-			logrus.Fatal(err)
-		}
-
-		return nil
-	},
-}
-
-func newAbraApp(version, commit string) *cli.App {
-	app := &cli.App{
-		Name: "abra",
-		Usage: `The Co-op Cloud command-line utility belt 🎩🐇
-    ____                           ____ _                 _
-   / ___|___         ___  _ __    / ___| | ___  _   _  __| |
-  | |   / _ \ _____ / _ \| '_ \  | |   | |/ _ \| | | |/ _' |
-  | |__| (_) |_____| (_) | |_) | | |___| | (_) | |_| | (_| |
-   \____\___/       \___/| .__/   \____|_|\___/ \__,_|\__,_|
-                         |_|
-`,
-		Version: fmt.Sprintf("%s-%s", version, commit[:7]),
-		Commands: []cli.Command{
-			app.AppCommand,
-			server.ServerCommand,
-			recipe.RecipeCommand,
-			catalogue.CatalogueCommand,
-			record.RecordCommand,
-			UpgradeCommand,
-			AutoCompleteCommand,
-		},
-		BashComplete: autocomplete.SubcommandComplete,
-	}
-
-	app.EnableBashCompletion = true
-
-	app.Before = func(c *cli.Context) error {
-		paths := []string{
-			config.ABRA_DIR,
-			path.Join(config.SERVERS_DIR),
-			path.Join(config.RECIPES_DIR),
-			path.Join(config.VENDOR_DIR),
-		}
-
-		for _, path := range paths {
-			if err := os.Mkdir(path, 0764); err != nil {
-				if !os.IsExist(err) {
-					logrus.Fatal(err)
-				}
-				continue
-			}
-		}
-
-		logrus.Debugf("abra version %s, commit %s", version, commit)
-
-		return nil
-	}
-	return app
-}
-
-// RunApp runs CLI abra app.
-func RunApp(version, commit string) {
-	app := newAbraApp(version, commit)
-
-	if err := app.Run(os.Args); err != nil {
-		logrus.Fatal(err)
-	}
-}

cli/internal/cli.go

@@ -1,433 +0,0 @@
-package internal
-
-import (
-	"os"
-
-	logrusStack "github.com/Gurpartap/logrus-stack"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// Secrets stores the variable from SecretsFlag
-var Secrets bool
-
-// SecretsFlag turns on/off automatically generating secrets
-var SecretsFlag = &cli.BoolFlag{
-	Name:        "secrets, S",
-	Usage:       "Automatically generate secrets",
-	Destination: &Secrets,
-}
-
-// Pass stores the variable from PassFlag
-var Pass bool
-
-// PassFlag turns on/off storing generated secrets in pass
-var PassFlag = &cli.BoolFlag{
-	Name:        "pass, p",
-	Usage:       "Store the generated secrets in a local pass store",
-	Destination: &Pass,
-}
-
-// PassRemove stores the variable for PassRemoveFlag
-var PassRemove bool
-
-// PassRemoveFlag turns on/off removing generated secrets from pass
-var PassRemoveFlag = &cli.BoolFlag{
-	Name:        "pass, p",
-	Usage:       "Remove generated secrets from a local pass store",
-	Destination: &PassRemove,
-}
-
-// Force force functionality without asking.
-var Force bool
-
-// ForceFlag turns on/off force functionality.
-var ForceFlag = &cli.BoolFlag{
-	Name:        "force, f",
-	Usage:       "Perform action without further prompt. Use with care!",
-	Destination: &Force,
-}
-
-// Chaos engages chaos mode.
-var Chaos bool
-
-// ChaosFlag turns on/off chaos functionality.
-var ChaosFlag = &cli.BoolFlag{
-	Name:        "chaos, C",
-	Usage:       "Deploy uncommitted recipes changes. Use with care!",
-	Destination: &Chaos,
-}
-
-// DNSProvider specifies a DNS provider.
-var DNSProvider string
-
-// DNSProviderFlag selects a DNS provider.
-var DNSProviderFlag = &cli.StringFlag{
-	Name:        "provider, p",
-	Value:       "",
-	Usage:       "DNS provider",
-	Destination: &DNSProvider,
-}
-
-var NoInput bool
-var NoInputFlag = &cli.BoolFlag{
-	Name:        "no-input, n",
-	Usage:       "Toggle non-interactive mode",
-	Destination: &NoInput,
-}
-
-var DNSType string
-
-var DNSTypeFlag = &cli.StringFlag{
-	Name:        "record-type, rt",
-	Value:       "",
-	Usage:       "Domain name record type (e.g. A)",
-	Destination: &DNSType,
-}
-
-var DNSName string
-
-var DNSNameFlag = &cli.StringFlag{
-	Name:        "record-name, rn",
-	Value:       "",
-	Usage:       "Domain name record name (e.g. mysubdomain)",
-	Destination: &DNSName,
-}
-
-var DNSValue string
-
-var DNSValueFlag = &cli.StringFlag{
-	Name:        "record-value, rv",
-	Value:       "",
-	Usage:       "Domain name record value (e.g. 192.168.1.1)",
-	Destination: &DNSValue,
-}
-
-var DNSTTL string
-var DNSTTLFlag = &cli.StringFlag{
-	Name:        "record-ttl, rl",
-	Value:       "600s",
-	Usage:       "Domain name TTL value (seconds)",
-	Destination: &DNSTTL,
-}
-
-var DNSPriority int
-
-var DNSPriorityFlag = &cli.IntFlag{
-	Name:        "record-priority, rp",
-	Value:       10,
-	Usage:       "Domain name priority value",
-	Destination: &DNSPriority,
-}
-
-var ServerProvider string
-
-var ServerProviderFlag = &cli.StringFlag{
-	Name:        "provider, p",
-	Usage:       "3rd party server provider",
-	Destination: &ServerProvider,
-}
-
-var CapsulInstanceURL string
-
-var CapsulInstanceURLFlag = &cli.StringFlag{
-	Name:        "capsul-url, cu",
-	Value:       "yolo.servers.coop",
-	Usage:       "capsul instance URL",
-	Destination: &CapsulInstanceURL,
-}
-
-var CapsulName string
-
-var CapsulNameFlag = &cli.StringFlag{
-	Name:        "capsul-name, cn",
-	Value:       "",
-	Usage:       "capsul name",
-	Destination: &CapsulName,
-}
-
-var CapsulType string
-
-var CapsulTypeFlag = &cli.StringFlag{
-	Name:        "capsul-type, ct",
-	Value:       "f1-xs",
-	Usage:       "capsul type",
-	Destination: &CapsulType,
-}
-
-var CapsulImage string
-
-var CapsulImageFlag = &cli.StringFlag{
-	Name:        "capsul-image, ci",
-	Value:       "debian10",
-	Usage:       "capsul image",
-	Destination: &CapsulImage,
-}
-
-var CapsulSSHKeys cli.StringSlice
-var CapsulSSHKeysFlag = &cli.StringSliceFlag{
-	Name:  "capsul-ssh-keys, cs",
-	Usage: "capsul SSH key",
-	Value: &CapsulSSHKeys,
-}
-
-var CapsulAPIToken string
-
-var CapsulAPITokenFlag = &cli.StringFlag{
-	Name:        "capsul-token, ca",
-	Usage:       "capsul API token",
-	EnvVar:      "CAPSUL_TOKEN",
-	Destination: &CapsulAPIToken,
-}
-
-var HetznerCloudName string
-
-var HetznerCloudNameFlag = &cli.StringFlag{
-	Name:        "hetzner-name, hn",
-	Value:       "",
-	Usage:       "hetzner cloud name",
-	Destination: &HetznerCloudName,
-}
-
-var HetznerCloudType string
-
-var HetznerCloudTypeFlag = &cli.StringFlag{
-	Name:        "hetzner-type, ht",
-	Usage:       "hetzner cloud type",
-	Destination: &HetznerCloudType,
-	Value:       "cx11",
-}
-
-var HetznerCloudImage string
-
-var HetznerCloudImageFlag = &cli.StringFlag{
-	Name:        "hetzner-image, hi",
-	Usage:       "hetzner cloud image",
-	Value:       "debian-10",
-	Destination: &HetznerCloudImage,
-}
-
-var HetznerCloudSSHKeys cli.StringSlice
-
-var HetznerCloudSSHKeysFlag = &cli.StringSliceFlag{
-	Name:  "hetzner-ssh-keys, hs",
-	Usage: "hetzner cloud SSH keys (e.g. me@foo.com)",
-	Value: &HetznerCloudSSHKeys,
-}
-
-var HetznerCloudLocation string
-
-var HetznerCloudLocationFlag = &cli.StringFlag{
-	Name:        "hetzner-location, hl",
-	Usage:       "hetzner cloud server location",
-	Value:       "hel1",
-	Destination: &HetznerCloudLocation,
-}
-
-var HetznerCloudAPIToken string
-
-var HetznerCloudAPITokenFlag = &cli.StringFlag{
-	Name:        "hetzner-token, ha",
-	Usage:       "hetzner cloud API token",
-	EnvVar:      "HCLOUD_TOKEN",
-	Destination: &HetznerCloudAPIToken,
-}
-
-// 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",
-	Destination: &Debug,
-	Usage:       "Show DEBUG messages",
-}
-
-// RC signifies the latest release candidate
-var RC bool
-
-// RCFlag chooses the latest release candidate for install
-var RCFlag = &cli.BoolFlag{
-	Name:        "rc, r",
-	Destination: &RC,
-	Usage:       "Insatll the latest release candidate",
-}
-
-var Major bool
-var MajorFlag = &cli.BoolFlag{
-	Name:        "major, x",
-	Usage:       "Increase the major part of the version",
-	Destination: &Major,
-}
-
-var Minor bool
-var MinorFlag = &cli.BoolFlag{
-	Name:        "minor, y",
-	Usage:       "Increase the minor part of the version",
-	Destination: &Minor,
-}
-
-var Patch bool
-var PatchFlag = &cli.BoolFlag{
-	Name:        "patch, z",
-	Usage:       "Increase the patch part of the version",
-	Destination: &Patch,
-}
-
-var Dry bool
-var DryFlag = &cli.BoolFlag{
-	Name:        "dry-run, r",
-	Usage:       "Only reports changes that would be made",
-	Destination: &Dry,
-}
-
-var Publish bool
-var PublishFlag = &cli.BoolFlag{
-	Name:        "publish, p",
-	Usage:       "Publish changes to git.coopcloud.tech",
-	Destination: &Publish,
-}
-
-var Domain string
-var DomainFlag = &cli.StringFlag{
-	Name:        "domain, D",
-	Value:       "",
-	Usage:       "Choose a domain name",
-	Destination: &Domain,
-}
-
-var NewAppServer string
-var NewAppServerFlag = &cli.StringFlag{
-	Name:        "server, s",
-	Value:       "",
-	Usage:       "Show apps of a specific server",
-	Destination: &NewAppServer,
-}
-
-var NoDomainChecks bool
-var NoDomainChecksFlag = &cli.BoolFlag{
-	Name:        "no-domain-checks, D",
-	Usage:       "Disable app domain sanity checks",
-	Destination: &NoDomainChecks,
-}
-
-var StdErrOnly bool
-var StdErrOnlyFlag = &cli.BoolFlag{
-	Name:        "stderr, s",
-	Usage:       "Only tail stderr",
-	Destination: &StdErrOnly,
-}
-
-var DontWaitConverge bool
-var DontWaitConvergeFlag = &cli.BoolFlag{
-	Name:        "no-converge-checks, c",
-	Usage:       "Don't wait for converge logic checks",
-	Destination: &DontWaitConverge,
-}
-
-var Watch bool
-var WatchFlag = &cli.BoolFlag{
-	Name:        "watch, w",
-	Usage:       "Watch status by polling repeatedly",
-	Destination: &Watch,
-}
-
-var OnlyErrors bool
-var OnlyErrorFlag = &cli.BoolFlag{
-	Name:        "errors, e",
-	Usage:       "Only show errors",
-	Destination: &OnlyErrors,
-}
-
-var SkipUpdates bool
-var SkipUpdatesFlag = &cli.BoolFlag{
-	Name:        "skip-updates, s",
-	Usage:       "Skip updating recipe repositories",
-	Destination: &SkipUpdates,
-}
-
-var AllTags bool
-var AllTagsFlag = &cli.BoolFlag{
-	Name:        "all-tags, a",
-	Usage:       "List all tags, not just upgrades",
-	Destination: &AllTags,
-}
-
-// SSHFailMsg is a hopefully helpful SSH failure message
-var SSHFailMsg = `
-Woops, Abra is unable to connect to connect to %s.
-
-Here are a few tips for debugging your local SSH config. Abra uses plain 'ol
-SSH to make connections to servers, so if your SSH config is working, Abra is
-working.
-
-In the first place, Abra will always try to read your Docker context connection
-string for SSH connection details. You can view your server context configs
-with the following command. Are they correct?
-
-    abra server ls
-
-Is your ssh-agent running? You can start it by running the following command:
-
-    eval "$(ssh-agent)"
-
-If your SSH private key loaded? You can check by running the following command:
-
-    ssh-add -L
-
-If, you can add it with:
-
-    ssh-add ~/.ssh/<private-key-part>
-
-If you are using a non-default public/private key, you can configure this in
-your ~/.ssh/config file which Abra will read in order to figure out connection
-details:
-
-Host foo.coopcloud.tech
-  Hostname foo.coopcloud.tech
-  User bar
-  Port 12345
-  IdentityFile ~/.ssh/bar@foo.coopcloud.tech
-
-If you're only using password authentication, you can use the following config:
-
-Host foo.coopcloud.tech
-  Hostname foo.coopcloud.tech
-  User bar
-  Port 12345
-  PreferredAuthentications=password
-  PubkeyAuthentication=no
-
-Good luck!
-
-`
-
-var ServerAddFailMsg = `
-Failed to add server %s.
-
-This could be caused by two things.
-
-Abra isn't picking up your SSH configuration or you need to specify it on the
-command-line (e.g you use a non-standard port or username to connect). Run
-"server add" with "-d/--debug" to learn more about what Abra is doing under the
-hood.
-
-Docker is not installed on your server. You can pass "-p/--provision" to
-install Docker and initialise Docker Swarm mode. See help output for "server
-add"
-
-See "abra server add -h" for more.
-
-`
-
-// SubCommandBefore wires up pre-action machinery (e.g. --debug handling).
-func SubCommandBefore(c *cli.Context) error {
-	if Debug {
-		logrus.SetLevel(logrus.DebugLevel)
-		logrus.SetFormatter(&logrus.TextFormatter{})
-		logrus.SetOutput(os.Stderr)
-		logrus.AddHook(logrusStack.StandardHook())
-	}
-
-	return nil
-}

cli/internal/command.go

@@ -1,39 +0,0 @@
-package internal
-
-import (
-	"bufio"
-	"fmt"
-	"os/exec"
-)
-
-// RunCmd runs a shell command and streams stdout/stderr in real-time.
-func RunCmd(cmd *exec.Cmd) error {
-	r, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-
-	cmd.Stderr = cmd.Stdout
-	done := make(chan struct{})
-	scanner := bufio.NewScanner(r)
-
-	go func() {
-		for scanner.Scan() {
-			line := scanner.Text()
-			fmt.Println(line)
-		}
-		done <- struct{}{}
-	}()
-
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	<-done
-
-	if err := cmd.Wait(); err != nil {
-		return err
-	}
-
-	return nil
-}

cli/internal/deploy.go

@@ -1,266 +0,0 @@
-package internal
-
-import (
-	"context"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"strings"
-
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/dns"
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/git"
-	"coopcloud.tech/abra/pkg/lint"
-	"coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// DeployAction is the main command-line action for this package
-func DeployAction(c *cli.Context) error {
-	app := ValidateApp(c)
-
-	if !Chaos {
-		if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
-			logrus.Fatal(err)
-		}
-	}
-
-	r, err := recipe.Get(app.Recipe)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := lint.LintForErrors(r); err != nil {
-		logrus.Fatal(err)
-	}
-
-	cl, err := client.New(app.Server)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	logrus.Debugf("checking whether %s is already deployed", app.StackName())
-
-	isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, app.StackName())
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	if isDeployed {
-		if Force || Chaos {
-			logrus.Warnf("%s is already deployed but continuing (--force/--chaos)", app.Name)
-		} else {
-			logrus.Fatalf("%s is already deployed", app.Name)
-		}
-	}
-
-	version := deployedVersion
-	if version == "unknown" && !Chaos {
-		catl, err := recipe.ReadRecipeCatalogue()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-		if len(versions) > 0 {
-			version = versions[len(versions)-1]
-			logrus.Debugf("choosing %s as version to deploy", version)
-			if err := recipe.EnsureVersion(app.Recipe, version); err != nil {
-				logrus.Fatal(err)
-			}
-		} else {
-			head, err := git.GetRecipeHead(app.Recipe)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			version = formatter.SmallSHA(head.String())
-			logrus.Warn("no versions detected, using latest commit")
-			if err := recipe.EnsureLatest(app.Recipe); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-	}
-
-	if version == "unknown" && !Chaos {
-		logrus.Debugf("choosing %s as version to deploy", version)
-		if err := recipe.EnsureVersion(app.Recipe, version); err != nil {
-			logrus.Fatal(err)
-		}
-	}
-
-	if version != "unknown" && !Chaos {
-		if err := recipe.EnsureVersion(app.Recipe, version); err != nil {
-			logrus.Fatal(err)
-		}
-	}
-
-	if Chaos {
-		logrus.Warnf("chaos mode engaged")
-		var err error
-		version, err = recipe.ChaosVersion(app.Recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-	}
-
-	abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
-	abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-	for k, v := range abraShEnv {
-		app.Env[k] = v
-	}
-
-	composeFiles, err := config.GetAppComposeFiles(app.Recipe, app.Env)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-	deployOpts := stack.Deploy{
-		Composefiles: composeFiles,
-		Namespace:    app.StackName(),
-		Prune:        false,
-		ResolveImage: stack.ResolveImageAlways,
-	}
-	compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := DeployOverview(app, version, "continue with deployment?"); err != nil {
-		logrus.Fatal(err)
-	}
-
-	if !NoDomainChecks {
-		domainName := app.Env["DOMAIN"]
-		if _, err = dns.EnsureDomainsResolveSameIPv4(domainName, app.Server); err != nil {
-			logrus.Fatal(err)
-		}
-	} else {
-		logrus.Warn("skipping domain checks as requested")
-	}
-
-	if err := stack.RunDeploy(cl, deployOpts, compose, app.Name, DontWaitConverge); err != nil {
-		logrus.Fatal(err)
-	}
-
-	return nil
-}
-
-// DeployOverview shows a deployment overview
-func DeployOverview(app config.App, version, message string) error {
-	tableCol := []string{"server", "recipe", "config", "domain", "version"}
-	table := formatter.CreateTable(tableCol)
-
-	deployConfig := "compose.yml"
-	if composeFiles, ok := app.Env["COMPOSE_FILE"]; ok {
-		deployConfig = strings.Join(strings.Split(composeFiles, ":"), "\n")
-	}
-
-	server := app.Server
-	if app.Server == "default" {
-		server = "local"
-	}
-
-	table.Append([]string{server, app.Recipe, deployConfig, app.Domain, version})
-	table.Render()
-
-	if NoInput {
-		return nil
-	}
-
-	response := false
-	prompt := &survey.Confirm{
-		Message: message,
-	}
-
-	if err := survey.AskOne(prompt, &response); err != nil {
-		return err
-	}
-
-	if !response {
-		logrus.Fatal("exiting as requested")
-	}
-
-	return nil
-}
-
-// NewVersionOverview shows an upgrade or downgrade overview
-func NewVersionOverview(app config.App, currentVersion, newVersion, releaseNotes string) error {
-	tableCol := []string{"server", "recipe", "config", "domain", "current version", "to be deployed"}
-	table := formatter.CreateTable(tableCol)
-
-	deployConfig := "compose.yml"
-	if composeFiles, ok := app.Env["COMPOSE_FILE"]; ok {
-		deployConfig = strings.Join(strings.Split(composeFiles, ":"), "\n")
-	}
-
-	server := app.Server
-	if app.Server == "default" {
-		server = "local"
-	}
-
-	table.Append([]string{server, app.Recipe, deployConfig, app.Domain, currentVersion, newVersion})
-	table.Render()
-
-	if releaseNotes == "" {
-		var err error
-		releaseNotes, err = GetReleaseNotes(app.Recipe, newVersion)
-		if err != nil {
-			return err
-		}
-	}
-
-	if releaseNotes != "" && newVersion != "" {
-		fmt.Println()
-		fmt.Println(fmt.Sprintf("%s release notes:\n\n%s", newVersion, releaseNotes))
-	} else {
-		logrus.Warnf("no release notes available for %s", newVersion)
-	}
-
-	if NoInput {
-		return nil
-	}
-
-	response := false
-	prompt := &survey.Confirm{
-		Message: "continue with deployment?",
-	}
-
-	if err := survey.AskOne(prompt, &response); err != nil {
-		return err
-	}
-
-	if !response {
-		logrus.Fatal("exiting as requested")
-	}
-
-	return nil
-}
-
-// GetReleaseNotes prints release notes for a recipe version
-func GetReleaseNotes(recipeName, version string) (string, error) {
-	if version == "" {
-		return "", nil
-	}
-
-	fpath := path.Join(config.RECIPES_DIR, recipeName, "release", version)
-
-	if _, err := os.Stat(fpath); !os.IsNotExist(err) {
-		releaseNotes, err := ioutil.ReadFile(fpath)
-		if err != nil {
-			return "", err
-		}
-		return string(releaseNotes), nil
-	}
-
-	return "", nil
-}

cli/internal/errors.go

@@ -1,18 +0,0 @@
-package internal
-
-import (
-	"os"
-
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// ShowSubcommandHelpAndError exits the program on error, logs the error to the
-// terminal, and shows the help command.
-func ShowSubcommandHelpAndError(c *cli.Context, err interface{}) {
-	if err2 := cli.ShowSubcommandHelp(c); err2 != nil {
-		logrus.Error(err2)
-	}
-	logrus.Error(err)
-	os.Exit(1)
-}

cli/internal/list.go

@@ -1,10 +0,0 @@
-package internal
-
-// ReverseStringList reverses a list of a strings. Roll on Go generics.
-func ReverseStringList(strings []string) []string {
-	for i, j := 0, len(strings)-1; i < j; i, j = i+1, j-1 {
-		strings[i], strings[j] = strings[j], strings[i]
-	}
-
-	return strings
-}

cli/internal/new.go

@@ -1,196 +0,0 @@
-package internal
-
-import (
-	"fmt"
-	"path"
-
-	"coopcloud.tech/abra/pkg/app"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/abra/pkg/secret"
-	"coopcloud.tech/abra/pkg/ssh"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/olekukonko/tablewriter"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// AppSecrets represents all app secrest
-type AppSecrets map[string]string
-
-// RecipeName is used for configuring recipe name programmatically
-var RecipeName string
-
-// createSecrets creates all secrets for a new app.
-func createSecrets(sanitisedAppName string) (AppSecrets, error) {
-	appEnvPath := path.Join(config.ABRA_DIR, "servers", NewAppServer, fmt.Sprintf("%s.env", Domain))
-	appEnv, err := config.ReadEnv(appEnvPath)
-	if err != nil {
-		return nil, err
-	}
-
-	secretEnvVars := secret.ReadSecretEnvVars(appEnv)
-	secrets, err := secret.GenerateSecrets(secretEnvVars, sanitisedAppName, NewAppServer)
-	if err != nil {
-		return nil, err
-	}
-
-	if Pass {
-		for secretName := range secrets {
-			secretValue := secrets[secretName]
-			if err := secret.PassInsertSecret(secretValue, secretName, Domain, NewAppServer); err != nil {
-				return nil, err
-			}
-		}
-	}
-	return secrets, nil
-}
-
-// ensureDomainFlag checks if the domain flag was used. if not, asks the user for it/
-func ensureDomainFlag(recipe recipe.Recipe, server string) error {
-	if Domain == "" && !NoInput {
-		prompt := &survey.Input{
-			Message: "Specify app domain",
-			Default: fmt.Sprintf("%s.%s", recipe.Name, server),
-		}
-		if err := survey.AskOne(prompt, &Domain); err != nil {
-			return err
-		}
-	}
-
-	if Domain == "" {
-		return fmt.Errorf("no domain provided")
-	}
-
-	return nil
-}
-
-// promptForSecrets asks if we should generate secrets for a new app.
-func promptForSecrets(appName string) error {
-	app, err := app.Get(appName)
-	if err != nil {
-		return err
-	}
-
-	secretEnvVars := secret.ReadSecretEnvVars(app.Env)
-	if len(secretEnvVars) == 0 {
-		logrus.Debugf("%s has no secrets to generate, skipping...", app.Recipe)
-		return nil
-	}
-
-	if !Secrets && !NoInput {
-		prompt := &survey.Confirm{
-			Message: "Generate app secrets?",
-		}
-		if err := survey.AskOne(prompt, &Secrets); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// ensureServerFlag checks if the server flag was used. if not, asks the user for it.
-func ensureServerFlag() error {
-	servers, err := config.GetServers()
-	if err != nil {
-		return err
-	}
-
-	if NewAppServer == "" && !NoInput {
-		prompt := &survey.Select{
-			Message: "Select app server:",
-			Options: servers,
-		}
-		if err := survey.AskOne(prompt, &NewAppServer); err != nil {
-			return err
-		}
-	}
-
-	if NewAppServer == "" {
-		return fmt.Errorf("no server provided")
-	}
-
-	return nil
-}
-
-// NewAction is the new app creation logic
-func NewAction(c *cli.Context) error {
-	recipe := ValidateRecipeWithPrompt(c, false)
-
-	if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := ensureServerFlag(); err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := ensureDomainFlag(recipe, NewAppServer); err != nil {
-		logrus.Fatal(err)
-	}
-
-	sanitisedAppName := config.SanitiseAppName(Domain)
-	logrus.Debugf("%s sanitised as %s for new app", Domain, sanitisedAppName)
-
-	if err := config.TemplateAppEnvSample(recipe.Name, Domain, NewAppServer, Domain); err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := promptForSecrets(Domain); err != nil {
-		logrus.Fatal(err)
-	}
-
-	var secrets AppSecrets
-	var secretTable *tablewriter.Table
-	if Secrets {
-		if err := ssh.EnsureHostKey(NewAppServer); err != nil {
-			logrus.Fatal(err)
-		}
-
-		var err error
-		secrets, err = createSecrets(sanitisedAppName)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		secretCols := []string{"Name", "Value"}
-		secretTable = formatter.CreateTable(secretCols)
-		for secret := range secrets {
-			secretTable.Append([]string{secret, secrets[secret]})
-		}
-
-	}
-
-	if NewAppServer == "default" {
-		NewAppServer = "local"
-	}
-
-	tableCol := []string{"server", "recipe", "domain"}
-	table := formatter.CreateTable(tableCol)
-	table.Append([]string{NewAppServer, recipe.Name, Domain})
-
-	fmt.Println("")
-	fmt.Println(fmt.Sprintf("A new %s app has been created! Here is an overview:", recipe.Name))
-	fmt.Println("")
-	table.Render()
-	fmt.Println("")
-	fmt.Println("You can configure this app by running the following:")
-	fmt.Println(fmt.Sprintf("\n    abra app config %s", Domain))
-	fmt.Println("")
-	fmt.Println("You can deploy this app by running the following:")
-	fmt.Println(fmt.Sprintf("\n    abra app deploy %s", Domain))
-	fmt.Println("")
-
-	if len(secrets) > 0 {
-		fmt.Println("Here are your generated secrets:")
-		fmt.Println("")
-		secretTable.Render()
-		fmt.Println("")
-		logrus.Warn("generated secrets are not shown again, please take note of them *now*")
-	}
-
-	return nil
-}

cli/internal/recipe.go

@@ -1,110 +0,0 @@
-package internal
-
-import (
-	"fmt"
-
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/docker/distribution/reference"
-	"github.com/sirupsen/logrus"
-)
-
-// PromptBumpType prompts for version bump type
-func PromptBumpType(tagString, latestRelease string) error {
-	if (!Major && !Minor && !Patch) && tagString == "" {
-		fmt.Printf(`
-You need to make a decision about what kind of an update this new recipe
-version is. If someone else performs this upgrade, do they have to do some
-migration work or take care of some breaking changes? This can be signaled in
-the version you specify on the recipe deploy label and is called a semantic
-version.
-
-The latest published version is %s.
-
-Here is a semver cheat sheet (more on https://semver.org):
-
-    major: new features/bug fixes, backwards incompatible (e.g 1.0.0 -> 2.0.0).
-           the upgrade won't work without some preparation work and others need
-           to take care when performing it. "it could go wrong".
-
-    minor: new features/bug fixes, backwards compatible (e.g. 0.1.0 -> 0.2.0).
-           the upgrade should Just Work and there are no breaking changes in
-           the app and the recipe config. "it should go fine".
-
-    patch: bug fixes, backwards compatible (e.g. 0.0.1 -> 0.0.2). this upgrade
-           should also Just Work and is mostly to do with minor bug fixes
-           and/or security patches. "nothing to worry about".
-
-`, latestRelease)
-
-		var chosenBumpType string
-		prompt := &survey.Select{
-			Message: fmt.Sprintf("select recipe version increment type"),
-			Options: []string{"major", "minor", "patch"},
-		}
-
-		if err := survey.AskOne(prompt, &chosenBumpType); err != nil {
-			return err
-		}
-
-		SetBumpType(chosenBumpType)
-	}
-
-	return nil
-}
-
-// GetBumpType figures out which bump type is specified
-func GetBumpType() string {
-	var bumpType string
-
-	if Major {
-		bumpType = "major"
-	} else if Minor {
-		bumpType = "minor"
-	} else if Patch {
-		bumpType = "patch"
-	} else {
-		logrus.Fatal("no version bump type specififed?")
-	}
-
-	return bumpType
-}
-
-// SetBumpType figures out which bump type is specified
-func SetBumpType(bumpType string) {
-	if bumpType == "major" {
-		Major = true
-	} else if bumpType == "minor" {
-		Minor = true
-	} else if bumpType == "patch" {
-		Patch = true
-	} else {
-		logrus.Fatal("no version bump type specififed?")
-	}
-}
-
-// GetMainAppImage retrieves the main 'app' image name
-func GetMainAppImage(recipe recipe.Recipe) (string, error) {
-	var path string
-
-	for _, service := range recipe.Config.Services {
-		if service.Name == "app" {
-			img, err := reference.ParseNormalizedNamed(service.Image)
-			if err != nil {
-				return "", err
-			}
-
-			path = reference.Path(img)
-			path = formatter.StripTagMeta(path)
-
-			return path, nil
-		}
-	}
-
-	if path == "" {
-		return path, fmt.Errorf("%s has no main 'app' service?", recipe.Name)
-	}
-
-	return path, nil
-}

cli/internal/validate.go

@@ -1,518 +0,0 @@
-package internal
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"strings"
-
-	"coopcloud.tech/abra/pkg/app"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/abra/pkg/ssh"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// AppName is used for configuring app name programmatically
-var AppName string
-
-// ValidateRecipe ensures the recipe arg is valid.
-func ValidateRecipe(c *cli.Context, ensureLatest bool) recipe.Recipe {
-	recipeName := c.Args().First()
-
-	if recipeName == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
-	}
-
-	chosenRecipe, err := recipe.Get(recipeName)
-	if err != nil {
-		if c.Command.Name == "generate" {
-			if strings.Contains(err.Error(), "missing a compose") {
-				logrus.Fatal(err)
-			}
-			logrus.Warn(err)
-		} else {
-			logrus.Fatal(err)
-		}
-	}
-
-	if ensureLatest {
-		if err := recipe.EnsureLatest(recipeName); err != nil {
-			logrus.Fatal(err)
-		}
-	}
-
-	logrus.Debugf("validated %s as recipe argument", recipeName)
-
-	return chosenRecipe
-}
-
-// ValidateRecipeWithPrompt ensures a recipe argument is present before
-// validating, asking for input if required.
-func ValidateRecipeWithPrompt(c *cli.Context, ensureLatest bool) recipe.Recipe {
-	recipeName := c.Args().First()
-
-	if recipeName == "" && !NoInput {
-		var recipes []string
-
-		catl, err := recipe.ReadRecipeCatalogue()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		knownRecipes := make(map[string]bool)
-		for name := range catl {
-			knownRecipes[name] = true
-		}
-
-		localRecipes, err := recipe.GetRecipesLocal()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		for _, recipeLocal := range localRecipes {
-			if _, ok := knownRecipes[recipeLocal]; !ok {
-				knownRecipes[recipeLocal] = true
-			}
-		}
-
-		for recipeName := range knownRecipes {
-			recipes = append(recipes, recipeName)
-		}
-
-		prompt := &survey.Select{
-			Message: "Select recipe",
-			Options: recipes,
-		}
-		if err := survey.AskOne(prompt, &recipeName); err != nil {
-			logrus.Fatal(err)
-		}
-	}
-
-	if RecipeName != "" {
-		recipeName = RecipeName
-		logrus.Debugf("programmatically setting recipe name to %s", recipeName)
-	}
-
-	if recipeName == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
-	}
-
-	chosenRecipe, err := recipe.Get(recipeName)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	if ensureLatest {
-		if err := recipe.EnsureLatest(recipeName); err != nil {
-			logrus.Fatal(err)
-		}
-	}
-
-	logrus.Debugf("validated %s as recipe argument", recipeName)
-
-	return chosenRecipe
-}
-
-// ValidateApp ensures the app name arg is valid.
-func ValidateApp(c *cli.Context) config.App {
-	appName := c.Args().First()
-
-	if AppName != "" {
-		appName = AppName
-		logrus.Debugf("programmatically setting app name to %s", appName)
-	}
-
-	if appName == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no app provided"))
-	}
-
-	app, err := app.Get(appName)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := recipe.EnsureExists(app.Recipe); err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := ssh.EnsureHostKey(app.Server); err != nil {
-		logrus.Fatal(err)
-	}
-
-	logrus.Debugf("validated %s as app argument", appName)
-
-	return app
-}
-
-// ValidateDomain ensures the domain name arg is valid.
-func ValidateDomain(c *cli.Context) string {
-	domainName := c.Args().First()
-
-	if domainName == "" && !NoInput {
-		prompt := &survey.Input{
-			Message: "Specify a domain name",
-			Default: "example.com",
-		}
-		if err := survey.AskOne(prompt, &domainName); err != nil {
-			logrus.Fatal(err)
-		}
-	}
-
-	if domainName == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no domain provided"))
-	}
-
-	logrus.Debugf("validated %s as domain argument", domainName)
-
-	return domainName
-}
-
-// ValidateSubCmdFlags ensures flag order conforms to correct order
-func ValidateSubCmdFlags(c *cli.Context) bool {
-	for argIdx, arg := range c.Args() {
-		if !strings.HasPrefix(arg, "--") {
-			for _, flag := range c.Args()[argIdx:] {
-				if strings.HasPrefix(flag, "--") {
-					return false
-				}
-			}
-		}
-	}
-	return true
-}
-
-// ValidateServer ensures the server name arg is valid.
-func ValidateServer(c *cli.Context) string {
-	serverName := c.Args().First()
-
-	serverNames, err := config.ReadServerNames()
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	if serverName == "" && !NoInput {
-		prompt := &survey.Select{
-			Message: "Specify a server name",
-			Options: serverNames,
-		}
-		if err := survey.AskOne(prompt, &serverName); err != nil {
-			logrus.Fatal(err)
-		}
-	}
-
-	matched := false
-	for _, name := range serverNames {
-		if name == serverName {
-			matched = true
-		}
-	}
-
-	if !matched {
-		ShowSubcommandHelpAndError(c, errors.New("server doesn't exist?"))
-	}
-
-	if serverName == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no server provided"))
-	}
-
-	logrus.Debugf("validated %s as server argument", serverName)
-
-	return serverName
-}
-
-// EnsureDNSProvider ensures a DNS provider is chosen.
-func EnsureDNSProvider() error {
-	if DNSProvider == "" && !NoInput {
-		prompt := &survey.Select{
-			Message: "Select DNS provider",
-			Options: []string{"gandi"},
-		}
-
-		if err := survey.AskOne(prompt, &DNSProvider); err != nil {
-			return err
-		}
-	}
-
-	if DNSProvider == "" {
-		return fmt.Errorf("missing DNS provider?")
-	}
-
-	return nil
-}
-
-// EnsureDNSTypeFlag ensures a DNS type flag is present.
-func EnsureDNSTypeFlag(c *cli.Context) error {
-	if DNSType == "" && !NoInput {
-		prompt := &survey.Input{
-			Message: "Specify DNS record type",
-			Default: "A",
-		}
-		if err := survey.AskOne(prompt, &DNSType); err != nil {
-			return err
-		}
-	}
-
-	if DNSType == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no record type provided"))
-	}
-
-	return nil
-}
-
-// EnsureDNSNameFlag ensures a DNS name flag is present.
-func EnsureDNSNameFlag(c *cli.Context) error {
-	if DNSName == "" && !NoInput {
-		prompt := &survey.Input{
-			Message: "Specify DNS record name",
-			Default: "mysubdomain",
-		}
-		if err := survey.AskOne(prompt, &DNSName); err != nil {
-			return err
-		}
-	}
-
-	if DNSName == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no record name provided"))
-	}
-
-	return nil
-}
-
-// EnsureDNSValueFlag ensures a DNS value flag is present.
-func EnsureDNSValueFlag(c *cli.Context) error {
-	if DNSValue == "" && !NoInput {
-		prompt := &survey.Input{
-			Message: "Specify DNS record value",
-			Default: "192.168.1.2",
-		}
-		if err := survey.AskOne(prompt, &DNSValue); err != nil {
-			return err
-		}
-	}
-
-	if DNSValue == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no record value provided"))
-	}
-
-	return nil
-}
-
-// EnsureZoneArgument ensures a zone argument is present.
-func EnsureZoneArgument(c *cli.Context) (string, error) {
-	zone := c.Args().First()
-
-	if zone == "" && !NoInput {
-		prompt := &survey.Input{
-			Message: "Specify a domain name zone",
-			Default: "example.com",
-		}
-
-		if err := survey.AskOne(prompt, &zone); err != nil {
-			return zone, err
-		}
-	}
-
-	if zone == "" {
-		ShowSubcommandHelpAndError(c, errors.New("no zone value provided"))
-	}
-
-	return zone, nil
-}
-
-// EnsureServerProvider ensures a 3rd party server provider is chosen.
-func EnsureServerProvider() error {
-	if ServerProvider == "" && !NoInput {
-		prompt := &survey.Select{
-			Message: "Select server provider",
-			Options: []string{"capsul", "hetzner-cloud"},
-		}
-
-		if err := survey.AskOne(prompt, &ServerProvider); err != nil {
-			return err
-		}
-	}
-
-	if ServerProvider == "" {
-		return fmt.Errorf("missing server provider?")
-	}
-
-	return nil
-}
-
-// EnsureNewCapsulVPSFlags ensure all flags are present.
-func EnsureNewCapsulVPSFlags(c *cli.Context) error {
-	if CapsulName == "" && !NoInput {
-		prompt := &survey.Input{
-			Message: "specify capsul name",
-		}
-		if err := survey.AskOne(prompt, &CapsulName); err != nil {
-			return err
-		}
-	}
-
-	if !NoInput {
-		prompt := &survey.Input{
-			Message: "specify capsul instance URL",
-			Default: CapsulInstanceURL,
-		}
-		if err := survey.AskOne(prompt, &CapsulInstanceURL); err != nil {
-			return err
-		}
-	}
-
-	if !NoInput {
-		prompt := &survey.Input{
-			Message: "specify capsul type",
-			Default: CapsulType,
-		}
-		if err := survey.AskOne(prompt, &CapsulType); err != nil {
-			return err
-		}
-	}
-
-	if !NoInput {
-		prompt := &survey.Input{
-			Message: "specify capsul image",
-			Default: CapsulImage,
-		}
-		if err := survey.AskOne(prompt, &CapsulImage); err != nil {
-			return err
-		}
-	}
-
-	if len(CapsulSSHKeys.Value()) == 0 && !NoInput {
-		var sshKeys string
-		prompt := &survey.Input{
-			Message: "specify capsul SSH keys (e.g. me@foo.com)",
-			Default: "",
-		}
-		if err := survey.AskOne(prompt, &CapsulSSHKeys); err != nil {
-			return err
-		}
-		CapsulSSHKeys = cli.StringSlice(strings.Split(sshKeys, ","))
-	}
-
-	if CapsulAPIToken == "" && !NoInput {
-		token, ok := os.LookupEnv("CAPSUL_TOKEN")
-		if !ok {
-			prompt := &survey.Input{
-				Message: "specify capsul API token",
-			}
-			if err := survey.AskOne(prompt, &CapsulAPIToken); err != nil {
-				return err
-			}
-		} else {
-			CapsulAPIToken = token
-		}
-	}
-
-	if CapsulName == "" {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing capsul name?"))
-	}
-	if CapsulInstanceURL == "" {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing capsul instance url?"))
-	}
-	if CapsulType == "" {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing capsul type?"))
-	}
-	if CapsulImage == "" {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing capsul image?"))
-	}
-	if len(CapsulSSHKeys.Value()) == 0 {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing capsul ssh keys?"))
-	}
-	if CapsulAPIToken == "" {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing capsul API token?"))
-	}
-
-	return nil
-}
-
-// EnsureNewHetznerCloudVPSFlags ensure all flags are present.
-func EnsureNewHetznerCloudVPSFlags(c *cli.Context) error {
-	if HetznerCloudName == "" && !NoInput {
-		prompt := &survey.Input{
-			Message: "specify hetzner cloud VPS name",
-		}
-		if err := survey.AskOne(prompt, &HetznerCloudName); err != nil {
-			return err
-		}
-	}
-
-	if !NoInput {
-		prompt := &survey.Input{
-			Message: "specify hetzner cloud VPS type",
-			Default: HetznerCloudType,
-		}
-		if err := survey.AskOne(prompt, &HetznerCloudType); err != nil {
-			return err
-		}
-	}
-
-	if !NoInput {
-		prompt := &survey.Input{
-			Message: "specify hetzner cloud VPS image",
-			Default: HetznerCloudImage,
-		}
-		if err := survey.AskOne(prompt, &HetznerCloudImage); err != nil {
-			return err
-		}
-	}
-
-	if len(HetznerCloudSSHKeys.Value()) == 0 && !NoInput {
-		var sshKeys string
-		prompt := &survey.Input{
-			Message: "specify hetzner cloud SSH keys (e.g. me@foo.com)",
-			Default: "",
-		}
-		if err := survey.AskOne(prompt, &sshKeys); err != nil {
-			return err
-		}
-		HetznerCloudSSHKeys = cli.StringSlice(strings.Split(sshKeys, ","))
-	}
-
-	if !NoInput {
-		prompt := &survey.Input{
-			Message: "specify hetzner cloud VPS location",
-			Default: HetznerCloudLocation,
-		}
-		if err := survey.AskOne(prompt, &HetznerCloudLocation); err != nil {
-			return err
-		}
-	}
-
-	if HetznerCloudAPIToken == "" && !NoInput {
-		token, ok := os.LookupEnv("HCLOUD_TOKEN")
-		if !ok {
-			prompt := &survey.Input{
-				Message: "specify hetzner cloud API token",
-			}
-			if err := survey.AskOne(prompt, &HetznerCloudAPIToken); err != nil {
-				return err
-			}
-		} else {
-			HetznerCloudAPIToken = token
-		}
-	}
-
-	if HetznerCloudName == "" {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing hetzner cloud VPS name?"))
-	}
-	if HetznerCloudType == "" {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing hetzner cloud VPS type?"))
-	}
-	if HetznerCloudImage == "" {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing hetzner cloud image?"))
-	}
-	if HetznerCloudLocation == "" {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing hetzner cloud VPS location?"))
-	}
-	if HetznerCloudAPIToken == "" {
-		ShowSubcommandHelpAndError(c, fmt.Errorf("missing hetzner cloud API token?"))
-	}
-
-	return nil
-}

cli/recipe/lint.go

@@ -1,79 +0,0 @@
-package recipe
-
-import (
-	"fmt"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/lint"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var recipeLintCommand = cli.Command{
-	Name:      "lint",
-	Usage:     "Lint a recipe",
-	Aliases:   []string{"l"},
-	ArgsUsage: "<recipe>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.OnlyErrorFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipe(c, true)
-
-		if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil {
-			logrus.Fatal(err)
-		}
-
-		tableCol := []string{"ref", "rule", "satisfied", "severity", "resolve"}
-		table := formatter.CreateTable(tableCol)
-
-		hasError := false
-		bar := formatter.CreateProgressbar(-1, "running recipe lint rules...")
-		for level := range lint.LintRules {
-			for _, rule := range lint.LintRules[level] {
-				ok, err := rule.Function(recipe)
-				if err != nil {
-					logrus.Warn(err)
-				}
-
-				if !ok && rule.Level == "error" {
-					hasError = true
-				}
-
-				var result string
-				if ok {
-					result = "yes"
-				} else {
-					result = "NO"
-				}
-
-				if internal.OnlyErrors {
-					if !ok && rule.Level == "error" {
-						table.Append([]string{rule.Ref, rule.Description, result, rule.Level, rule.HowToResolve})
-						bar.Add(1)
-					}
-				} else {
-					table.Append([]string{rule.Ref, rule.Description, result, rule.Level, rule.HowToResolve})
-					bar.Add(1)
-				}
-			}
-		}
-
-		if table.NumLines() > 0 {
-			fmt.Println()
-			table.Render()
-		}
-
-		if hasError {
-			logrus.Warn("watch out, some critical errors are present in your recipe config")
-		}
-
-		return nil
-	},
-}

cli/recipe/list.go

@@ -1,77 +0,0 @@
-package recipe
-
-import (
-	"fmt"
-	"sort"
-	"strconv"
-	"strings"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var pattern string
-var patternFlag = &cli.StringFlag{
-	Name:        "pattern, p",
-	Value:       "",
-	Usage:       "Simple string to filter recipes",
-	Destination: &pattern,
-}
-
-var recipeListCommand = cli.Command{
-	Name:    "list",
-	Usage:   "List available recipes",
-	Aliases: []string{"ls"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		patternFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		catl, err := recipe.ReadRecipeCatalogue()
-		if err != nil {
-			logrus.Fatal(err.Error())
-		}
-
-		recipes := catl.Flatten()
-		sort.Sort(recipe.ByRecipeName(recipes))
-
-		tableCol := []string{"name", "category", "status", "healthcheck", "backups", "email", "tests", "SSO"}
-		table := formatter.CreateTable(tableCol)
-
-		len := 0
-		for _, recipe := range recipes {
-			tableRow := []string{
-				recipe.Name,
-				recipe.Category,
-				strconv.Itoa(recipe.Features.Status),
-				recipe.Features.Healthcheck,
-				recipe.Features.Backups,
-				recipe.Features.Email,
-				recipe.Features.Tests,
-				recipe.Features.SSO,
-			}
-
-			if pattern != "" {
-				if strings.Contains(recipe.Name, pattern) {
-					table.Append(tableRow)
-					len++
-				}
-			} else {
-				table.Append(tableRow)
-				len++
-			}
-		}
-
-		table.SetCaption(true, fmt.Sprintf("total recipes: %v", len))
-
-		if table.NumLines() > 0 {
-			table.Render()
-		}
-
-		return nil
-	},
-}

cli/recipe/new.go

@@ -1,140 +0,0 @@
-package recipe
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"text/template"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/git"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// recipeMetadata is the recipe metadata for the README.md
-type recipeMetadata struct {
-	Name        string
-	Description string
-	Category    string
-	Status      string
-	Image       string
-	Healthcheck string
-	Backups     string
-	Email       string
-	Tests       string
-	SSO         string
-}
-
-var recipeNewCommand = cli.Command{
-	Name:    "new",
-	Aliases: []string{"n"},
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-	},
-	Before:    internal.SubCommandBefore,
-	Usage:     "Create a new recipe",
-	ArgsUsage: "<recipe>",
-	Description: `
-This command creates a new recipe.
-
-Abra uses our built-in example repository which is available here:
-
-    https://git.coopcloud.tech/coop-cloud/example
-
-Files within the example repository make use of the Golang templating system
-which Abra uses to inject values into the generated recipe folder (e.g. name of
-recipe and domain in the sample environment config).
-`,
-	Action: func(c *cli.Context) error {
-		recipeName := c.Args().First()
-
-		if recipeName == "" {
-			internal.ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
-		}
-
-		directory := path.Join(config.RECIPES_DIR, recipeName)
-		if _, err := os.Stat(directory); !os.IsNotExist(err) {
-			logrus.Fatalf("%s recipe directory already exists?", directory)
-		}
-
-		url := fmt.Sprintf("%s/example.git", config.REPOS_BASE_URL)
-		if err := git.Clone(directory, url); err != nil {
-			logrus.Fatal(err)
-		}
-
-		gitRepo := path.Join(config.RECIPES_DIR, recipeName, ".git")
-		if err := os.RemoveAll(gitRepo); err != nil {
-			logrus.Fatal(err)
-		}
-		logrus.Debugf("removed example git repo in %s", gitRepo)
-
-		meta := newRecipeMeta(recipeName)
-
-		toParse := []string{
-			path.Join(config.RECIPES_DIR, recipeName, "README.md"),
-			path.Join(config.RECIPES_DIR, recipeName, ".env.sample"),
-		}
-		for _, path := range toParse {
-			tpl, err := template.ParseFiles(path)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			var templated bytes.Buffer
-			if err := tpl.Execute(&templated, meta); err != nil {
-				logrus.Fatal(err)
-			}
-
-			if err := ioutil.WriteFile(path, templated.Bytes(), 0644); err != nil {
-				logrus.Fatal(err)
-			}
-
-		}
-
-		newGitRepo := path.Join(config.RECIPES_DIR, recipeName)
-		if err := git.Init(newGitRepo, true); err != nil {
-			logrus.Fatal(err)
-		}
-
-		fmt.Print(fmt.Sprintf(`
-Your new %s recipe has been created in %s.
-
-In order to share your recipe, you can upload it the git repository to:
-
-    https://git.coopcloud.tech/coop-cloud/%s
-
-If you're not sure how to do that, come chat with us:
-
-    https://docs.coopcloud.tech/contact
-
-See "abra recipe -h" for additional recipe maintainer commands.
-
-Happy Hacking!
-
-`, recipeName, path.Join(config.RECIPES_DIR, recipeName), recipeName))
-
-		return nil
-	},
-}
-
-// newRecipeMeta creates a new recipeMetadata instance with defaults
-func newRecipeMeta(recipeName string) recipeMetadata {
-	return recipeMetadata{
-		Name:        recipeName,
-		Description: "> One line description of the recipe",
-		Category:    "Apps",
-		Status:      "0",
-		Image:       fmt.Sprintf("[`%s`](https://hub.docker.com/r/%s), 4, upstream", recipeName, recipeName),
-		Healthcheck: "No",
-		Backups:     "No",
-		Email:       "No",
-		Tests:       "No",
-		SSO:         "No",
-	}
-}

cli/recipe/recipe.go

@@ -1,32 +0,0 @@
-package recipe
-
-import (
-	"github.com/urfave/cli"
-)
-
-// RecipeCommand defines all recipe related sub-commands.
-var RecipeCommand = cli.Command{
-	Name:      "recipe",
-	Aliases:   []string{"r"},
-	Usage:     "Manage recipes",
-	ArgsUsage: "<recipe>",
-	Description: `
-A recipe is a blueprint for an app. It is a bunch of config files which
-describe how to deploy and maintain an app. Recipes are maintained by the Co-op
-Cloud community and you can use Abra to read them and create apps for you.
-
-Anyone who uses a recipe can become a maintainer. Maintainers typically make
-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{
-		recipeListCommand,
-		recipeVersionCommand,
-		recipeReleaseCommand,
-		recipeNewCommand,
-		recipeUpgradeCommand,
-		recipeSyncCommand,
-		recipeLintCommand,
-	},
-}

cli/recipe/release.go

@@ -1,454 +0,0 @@
-package recipe
-
-import (
-	"fmt"
-	"path"
-	"strconv"
-	"strings"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/formatter"
-	gitPkg "coopcloud.tech/abra/pkg/git"
-	"coopcloud.tech/abra/pkg/recipe"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/tagcmp"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/docker/distribution/reference"
-	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var recipeReleaseCommand = cli.Command{
-	Name:      "release",
-	Aliases:   []string{"rl"},
-	Usage:     "Release a new recipe version",
-	ArgsUsage: "<recipe> [<version>]",
-	Description: `
-This command is used to specify a new version of a recipe. These versions are
-then published on the Co-op Cloud recipe catalogue. These versions take the
-following form:
-
-    a.b.c+x.y.z
-
-Where the "a.b.c" part is a semantic version determined by the maintainer. And
-the "x.y.z" part is the image tag of the recipe "app" service (the main
-container which contains the software to be used).
-
-We maintain a semantic versioning scheme ("a.b.c") alongside the libre app
-versioning scheme ("x.y.z") in order to maximise the chances that the nature of
-recipe updates are properly communicated. I.e. developers of an app might
-publish a minor version but that might lead to changes in the recipe which are
-major and therefore require intervention while doing the upgrade work.
-
-Publish your new release to git.coopcloud.tech with "-p/--publish". This
-requires that you have permission to git push to these repositories and have
-your SSH keys configured on your account.
-`,
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.DryFlag,
-		internal.MajorFlag,
-		internal.MinorFlag,
-		internal.PatchFlag,
-		internal.PublishFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipeWithPrompt(c, false)
-
-		imagesTmp, err := getImageVersions(recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		mainApp, err := internal.GetMainAppImage(recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		mainAppVersion := imagesTmp[mainApp]
-		if mainAppVersion == "" {
-			logrus.Fatalf("main app service version for %s is empty?", recipe.Name)
-		}
-
-		tagString := c.Args().Get(1)
-		if tagString != "" {
-			if _, err := tagcmp.Parse(tagString); err != nil {
-				logrus.Fatalf("cannot parse %s, invalid tag specified?", tagString)
-			}
-		}
-
-		if (internal.Major || internal.Minor || internal.Patch) && tagString != "" {
-			logrus.Fatal("cannot specify tag and bump type at the same time")
-		}
-
-		if tagString != "" {
-			if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		tags, err := recipe.Tags()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if tagString == "" && (!internal.Major && !internal.Minor && !internal.Patch) {
-			var err error
-			tagString, err = getLabelVersion(recipe, false)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if len(tags) > 0 {
-			logrus.Warnf("previous git tags detected, assuming this is a new semver release")
-			if err := createReleaseFromPreviousTag(tagString, mainAppVersion, recipe, tags); err != nil {
-				logrus.Fatal(err)
-			}
-		} else {
-			logrus.Warnf("no tag specified and no previous tag available for %s, assuming this is the initial release", recipe.Name)
-
-			if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
-				if cleanUpErr := cleanUpTag(tagString, recipe.Name); err != nil {
-					logrus.Fatal(cleanUpErr)
-				}
-				logrus.Fatal(err)
-			}
-		}
-
-		return nil
-	},
-}
-
-// getImageVersions retrieves image versions for a recipe
-func getImageVersions(recipe recipe.Recipe) (map[string]string, error) {
-	var services = make(map[string]string)
-
-	missingTag := false
-	for _, service := range recipe.Config.Services {
-		if service.Image == "" {
-			continue
-		}
-
-		img, err := reference.ParseNormalizedNamed(service.Image)
-		if err != nil {
-			return services, err
-		}
-
-		path := reference.Path(img)
-
-		path = formatter.StripTagMeta(path)
-
-		var tag string
-		switch img.(type) {
-		case reference.NamedTagged:
-			tag = img.(reference.NamedTagged).Tag()
-		case reference.Named:
-			if service.Name == "app" {
-				missingTag = true
-			}
-			continue
-		}
-
-		services[path] = tag
-	}
-
-	if missingTag {
-		return services, fmt.Errorf("app service is missing image tag?")
-	}
-
-	return services, nil
-}
-
-// createReleaseFromTag creates a new release based on a supplied recipe version string
-func createReleaseFromTag(recipe recipe.Recipe, tagString, mainAppVersion string) error {
-	var err error
-
-	directory := path.Join(config.RECIPES_DIR, recipe.Name)
-	repo, err := git.PlainOpen(directory)
-	if err != nil {
-		return err
-	}
-
-	tag, err := tagcmp.Parse(tagString)
-	if err != nil {
-		return err
-	}
-
-	if tag.MissingMinor {
-		tag.Minor = "0"
-		tag.MissingMinor = false
-	}
-
-	if tag.MissingPatch {
-		tag.Patch = "0"
-		tag.MissingPatch = false
-	}
-
-	if tagString == "" {
-		tagString = fmt.Sprintf("%s+%s", tag.String(), mainAppVersion)
-	}
-
-	if err := commitRelease(recipe, tagString); err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := tagRelease(tagString, repo); err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := pushRelease(recipe, tagString); err != nil {
-		logrus.Fatal(err)
-	}
-
-	return nil
-}
-
-// btoi converts a boolean value into an integer
-func btoi(b bool) int {
-	if b {
-		return 1
-	}
-
-	return 0
-}
-
-// getTagCreateOptions constructs git tag create options
-func getTagCreateOptions(tag string) (git.CreateTagOptions, error) {
-	msg := fmt.Sprintf("chore: publish %s release", tag)
-	return git.CreateTagOptions{Message: msg}, nil
-}
-
-func commitRelease(recipe recipe.Recipe, tag string) error {
-	if internal.Dry {
-		logrus.Debugf("dry run: no changes committed")
-		return nil
-	}
-
-	isClean, err := gitPkg.IsClean(recipe.Dir())
-	if err != nil {
-		return err
-	}
-
-	if isClean {
-		if !internal.Dry {
-			return fmt.Errorf("no changes discovered in %s, nothing to publish?", recipe.Dir())
-		}
-	}
-
-	msg := fmt.Sprintf("chore: publish %s release", tag)
-	repoPath := path.Join(config.RECIPES_DIR, recipe.Name)
-	if err := gitPkg.Commit(repoPath, ".", msg, internal.Dry); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func tagRelease(tagString string, repo *git.Repository) error {
-	if internal.Dry {
-		logrus.Debugf("dry run: no git tag created (%s)", tagString)
-		return nil
-	}
-
-	head, err := repo.Head()
-	if err != nil {
-		return err
-	}
-
-	createTagOptions, err := getTagCreateOptions(tagString)
-	if err != nil {
-		return err
-	}
-
-	_, err = repo.CreateTag(tagString, head.Hash(), &createTagOptions)
-	if err != nil {
-		return err
-	}
-
-	hash := formatter.SmallSHA(head.Hash().String())
-	logrus.Debugf(fmt.Sprintf("created tag %s at %s", tagString, hash))
-
-	return nil
-}
-
-func pushRelease(recipe recipe.Recipe, tagString string) error {
-	if internal.Dry {
-		logrus.Info("dry run: no changes published")
-		return nil
-	}
-
-	if !internal.Publish && !internal.NoInput {
-		prompt := &survey.Confirm{
-			Message: "publish new release?",
-		}
-
-		if err := survey.AskOne(prompt, &internal.Publish); err != nil {
-			return err
-		}
-	}
-
-	if internal.Publish {
-		if err := recipe.Push(internal.Dry); err != nil {
-			return err
-		}
-		url := fmt.Sprintf("%s/%s/src/tag/%s", config.REPOS_BASE_URL, recipe.Name, tagString)
-		logrus.Infof("new release published: %s", url)
-	} else {
-		logrus.Info("no -p/--publish passed, not publishing")
-	}
-
-	return nil
-}
-
-func createReleaseFromPreviousTag(tagString, mainAppVersion string, recipe recipe.Recipe, tags []string) error {
-	directory := path.Join(config.RECIPES_DIR, recipe.Name)
-	repo, err := git.PlainOpen(directory)
-	if err != nil {
-		return err
-	}
-
-	bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
-	if bumpType != 0 {
-		if (bumpType & (bumpType - 1)) != 0 {
-			return fmt.Errorf("you can only use one of: --major, --minor, --patch")
-		}
-	}
-
-	var lastGitTag tagcmp.Tag
-	for _, tag := range tags {
-		parsed, err := tagcmp.Parse(tag)
-		if err != nil {
-			return err
-		}
-
-		if (lastGitTag == tagcmp.Tag{}) {
-			lastGitTag = parsed
-		} else if parsed.IsGreaterThan(lastGitTag) {
-			lastGitTag = parsed
-		}
-	}
-
-	newTag := lastGitTag
-	if internal.Patch {
-		now, err := strconv.Atoi(newTag.Patch)
-		if err != nil {
-			return err
-		}
-
-		newTag.Patch = strconv.Itoa(now + 1)
-	} else if internal.Minor {
-		now, err := strconv.Atoi(newTag.Minor)
-		if err != nil {
-			return err
-		}
-
-		newTag.Patch = "0"
-		newTag.Minor = strconv.Itoa(now + 1)
-	} else if internal.Major {
-		now, err := strconv.Atoi(newTag.Major)
-		if err != nil {
-			return err
-		}
-
-		newTag.Patch = "0"
-		newTag.Minor = "0"
-		newTag.Major = strconv.Itoa(now + 1)
-	}
-
-	if tagString == "" {
-		if err := internal.PromptBumpType(tagString, lastGitTag.String()); err != nil {
-			return err
-		}
-	}
-
-	if internal.Major || internal.Minor || internal.Patch {
-		newTag.Metadata = mainAppVersion
-		tagString = newTag.String()
-	}
-
-	if lastGitTag.String() == tagString {
-		logrus.Fatalf("latest git tag (%s) and synced lable (%s) are the same?", lastGitTag, tagString)
-	}
-
-	if !internal.NoInput {
-		prompt := &survey.Confirm{
-			Message: fmt.Sprintf("current: %s, new: %s, correct?", lastGitTag, tagString),
-		}
-
-		var ok bool
-		if err := survey.AskOne(prompt, &ok); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if !ok {
-			logrus.Fatal("exiting as requested")
-		}
-	}
-
-	if err := commitRelease(recipe, tagString); err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := tagRelease(tagString, repo); err != nil {
-		logrus.Fatal(err)
-	}
-
-	if err := pushRelease(recipe, tagString); err != nil {
-		logrus.Fatal(err)
-	}
-
-	return nil
-}
-
-// cleanUpTag removes a freshly created tag
-func cleanUpTag(tag, recipeName string) error {
-	directory := path.Join(config.RECIPES_DIR, recipeName)
-	repo, err := git.PlainOpen(directory)
-	if err != nil {
-		return err
-	}
-
-	if err := repo.DeleteTag(tag); err != nil {
-		if !strings.Contains(err.Error(), "not found") {
-			return err
-		}
-	}
-
-	logrus.Debugf("removed freshly created tag %s", tag)
-
-	return nil
-}
-
-func getLabelVersion(recipe recipe.Recipe, prompt bool) (string, error) {
-	initTag, err := recipePkg.GetVersionLabelLocal(recipe)
-	if err != nil {
-		return "", err
-	}
-
-	if initTag == "" {
-		logrus.Fatalf("unable to read version for %s from synced label. Did you try running \"abra recipe sync %s\" already?", recipe.Name, recipe.Name)
-	}
-
-	logrus.Warnf("discovered %s as currently synced recipe label", initTag)
-
-	if prompt && !internal.NoInput {
-		var response bool
-		prompt := &survey.Confirm{Message: fmt.Sprintf("use %s as the new version?", initTag)}
-		if err := survey.AskOne(prompt, &response); err != nil {
-			return "", err
-		}
-
-		if !response {
-			return "", fmt.Errorf("please fix your synced label for %s and re-run this command", recipe.Name)
-		}
-	}
-
-	return initTag, nil
-}

cli/recipe/sync.go

@@ -1,199 +0,0 @@
-package recipe
-
-import (
-	"fmt"
-	"path"
-	"strconv"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/tagcmp"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var recipeSyncCommand = cli.Command{
-	Name:      "sync",
-	Aliases:   []string{"s"},
-	Usage:     "Sync recipe version label",
-	ArgsUsage: "<recipe> [<version>]",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.DryFlag,
-		internal.MajorFlag,
-		internal.MinorFlag,
-		internal.PatchFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-This command will generate labels for the main recipe service (i.e. by
-convention, the service named 'app') which corresponds to the following format:
-
-    coop-cloud.${STACK_NAME}.version=<version>
-
-Where <version> can be specifed on the command-line or Abra can attempt to
-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)
-
-		mainApp, err := internal.GetMainAppImage(recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		imagesTmp, err := getImageVersions(recipe)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		mainAppVersion := imagesTmp[mainApp]
-
-		tags, err := recipe.Tags()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		nextTag := c.Args().Get(1)
-		if len(tags) == 0 && nextTag == "" {
-			logrus.Warnf("no git tags found for %s", recipe.Name)
-			fmt.Println(fmt.Sprintf(`
-The following options are two types of initial semantic version that you can
-pick for %s that will be published in the recipe catalogue. This follows the
-semver convention (more on https://semver.org), here is a short cheatsheet
-
-    0.1.0: development release, still hacking. when you make a major upgrade
-           you increment the "y" part (i.e. 0.1.0 -> 0.2.0) and only move to
-           using the "x" part when things are stable.
-
-    1.0.0: public release, assumed to be working. you already have a stable
-           and reliable deployment of this app and feel relatively confident
-           about it.
-
-If you want people to be able alpha test your current config for %s but don't
-think it is quite reliable, go with 0.1.0 and people will know that things are
-likely to change.
-
-`, recipe.Name, recipe.Name))
-			var chosenVersion string
-			edPrompt := &survey.Select{
-				Message: "which version do you want to begin with?",
-				Options: []string{"0.1.0", "1.0.0"},
-			}
-
-			if err := survey.AskOne(edPrompt, &chosenVersion); err != nil {
-				logrus.Fatal(err)
-			}
-
-			nextTag = fmt.Sprintf("%s+%s", chosenVersion, mainAppVersion)
-		}
-
-		if nextTag == "" && (!internal.Major && !internal.Minor && !internal.Patch) {
-			latestRelease := tags[len(tags)-1]
-			if err := internal.PromptBumpType("", latestRelease); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if nextTag == "" {
-			recipeDir := path.Join(config.RECIPES_DIR, recipe.Name)
-			repo, err := git.PlainOpen(recipeDir)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			var lastGitTag tagcmp.Tag
-			iter, err := repo.Tags()
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			if err := iter.ForEach(func(ref *plumbing.Reference) error {
-				obj, err := repo.TagObject(ref.Hash())
-				if err != nil {
-					return err
-				}
-
-				tagcmpTag, err := tagcmp.Parse(obj.Name)
-				if err != nil {
-					return err
-				}
-
-				if (lastGitTag == tagcmp.Tag{}) {
-					lastGitTag = tagcmpTag
-				} else if tagcmpTag.IsGreaterThan(lastGitTag) {
-					lastGitTag = tagcmpTag
-				}
-
-				return nil
-			}); err != nil {
-				logrus.Fatal(err)
-			}
-
-			// bumpType is used to decide what part of the tag should be incremented
-			bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
-			if bumpType != 0 {
-				// a bitwise check if the number is a power of 2
-				if (bumpType & (bumpType - 1)) != 0 {
-					logrus.Fatal("you can only use one version flag: --major, --minor or --patch")
-				}
-			}
-
-			newTag := lastGitTag
-			if bumpType > 0 {
-				if internal.Patch {
-					now, err := strconv.Atoi(newTag.Patch)
-					if err != nil {
-						logrus.Fatal(err)
-					}
-
-					newTag.Patch = strconv.Itoa(now + 1)
-				} else if internal.Minor {
-					now, err := strconv.Atoi(newTag.Minor)
-					if err != nil {
-						logrus.Fatal(err)
-					}
-
-					newTag.Patch = "0"
-					newTag.Minor = strconv.Itoa(now + 1)
-				} else if internal.Major {
-					now, err := strconv.Atoi(newTag.Major)
-					if err != nil {
-						logrus.Fatal(err)
-					}
-
-					newTag.Patch = "0"
-					newTag.Minor = "0"
-					newTag.Major = strconv.Itoa(now + 1)
-				}
-			}
-
-			newTag.Metadata = mainAppVersion
-			logrus.Debugf("choosing %s as new version for %s", newTag.String(), recipe.Name)
-			nextTag = newTag.String()
-		}
-
-		if _, err := tagcmp.Parse(nextTag); err != nil {
-			logrus.Fatalf("invalid version %s specified", nextTag)
-		}
-
-		mainService := "app"
-		label := fmt.Sprintf("coop-cloud.${STACK_NAME}.version=%s", nextTag)
-		if !internal.Dry {
-			if err := recipe.UpdateLabel("compose.y*ml", mainService, label); err != nil {
-				logrus.Fatal(err)
-			}
-		} else {
-			logrus.Infof("dry run: not syncing label %s for recipe %s", nextTag, recipe.Name)
-		}
-
-		return nil
-	},
-	BashComplete: autocomplete.RecipeNameComplete,
-}

cli/recipe/upgrade.go

@@ -1,264 +0,0 @@
-package recipe
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-	"path"
-	"sort"
-	"strings"
-
-	"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"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/tagcmp"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/docker/distribution/reference"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-type imgPin struct {
-	image   string
-	version tagcmp.Tag
-}
-
-var recipeUpgradeCommand = cli.Command{
-	Name:    "upgrade",
-	Aliases: []string{"u"},
-	Usage:   "Upgrade recipe image tags",
-	Description: `
-This command reads and attempts to parse all image tags within the given
-<recipe> configuration and prompt with more recent tags to upgrade to. It will
-update the relevant compose file tags on the local file system.
-
-Some image tags cannot be parsed because they do not follow some sort of
-semver-like convention. In this case, all possible tags will be listed and it
-is up to the end-user to decide.
-
-The command is interactive and will show a select input which allows you to
-make a seclection. Use the "?" key to see more help on navigating this
-interface.
-
-You may invoke this command in "wizard" mode and be prompted for input:
-
-    abra recipe upgrade
-`,
-	BashComplete: autocomplete.RecipeNameComplete,
-	ArgsUsage:    "<recipe>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.PatchFlag,
-		internal.MinorFlag,
-		internal.MajorFlag,
-		internal.AllTagsFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipeWithPrompt(c, true)
-
-		bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
-		if bumpType != 0 {
-			// a bitwise check if the number is a power of 2
-			if (bumpType & (bumpType - 1)) != 0 {
-				logrus.Fatal("you can only use one of: --major, --minor, --patch.")
-			}
-		}
-
-		// check for versions file and load pinned versions
-		versionsPresent := false
-		recipeDir := path.Join(config.RECIPES_DIR, recipe.Name)
-		versionsPath := path.Join(recipeDir, "versions")
-		var servicePins = make(map[string]imgPin)
-		if _, err := os.Stat(versionsPath); err == nil {
-			logrus.Debugf("found versions file for %s", recipe.Name)
-			file, err := os.Open(versionsPath)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-			scanner := bufio.NewScanner(file)
-			for scanner.Scan() {
-				line := scanner.Text()
-				splitLine := strings.Split(line, " ")
-				if splitLine[0] != "pin" || len(splitLine) != 3 {
-					logrus.Fatalf("malformed version pin specification: %s", line)
-				}
-				pinSlice := strings.Split(splitLine[2], ":")
-				pinTag, err := tagcmp.Parse(pinSlice[1])
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				pin := imgPin{
-					image:   pinSlice[0],
-					version: pinTag,
-				}
-				servicePins[splitLine[1]] = pin
-			}
-			if err := scanner.Err(); err != nil {
-				logrus.Error(err)
-			}
-			versionsPresent = true
-		} else {
-			logrus.Debugf("did not find versions file for %s", recipe.Name)
-		}
-
-		for _, service := range recipe.Config.Services {
-			img, err := reference.ParseNormalizedNamed(service.Image)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			regVersions, err := client.GetRegistryTags(img)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			image := reference.Path(img)
-			logrus.Debugf("retrieved %s from remote registry for %s", regVersions, image)
-			image = formatter.StripTagMeta(image)
-
-			switch img.(type) {
-			case reference.NamedTagged:
-				if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) {
-					logrus.Debugf("%s not considered semver-like", img.(reference.NamedTagged).Tag())
-				}
-			default:
-				logrus.Warnf("unable to read tag for image %s, is it missing? skipping upgrade for %s", image, service.Name)
-				continue
-			}
-
-			tag, err := tagcmp.Parse(img.(reference.NamedTagged).Tag())
-			if err != nil {
-				logrus.Warnf("unable to parse %s, error was: %s, skipping upgrade for %s", image, err.Error(), service.Name)
-				continue
-			}
-
-			logrus.Debugf("parsed %s for %s", tag, service.Name)
-
-			var compatible []tagcmp.Tag
-			for _, regVersion := range regVersions {
-				other, err := tagcmp.Parse(regVersion)
-				if err != nil {
-					continue // skip tags that cannot be parsed
-				}
-
-				if tag.IsCompatible(other) && tag.IsLessThan(other) && !tag.Equals(other) {
-					compatible = append(compatible, other)
-				}
-			}
-
-			logrus.Debugf("detected potential upgradable tags %s for %s", compatible, service.Name)
-
-			sort.Sort(tagcmp.ByTagDesc(compatible))
-
-			if len(compatible) == 0 && !internal.AllTags {
-				logrus.Info(fmt.Sprintf("no new versions available for %s, assuming %s is the latest (use -a/--all-tags to see all anyway)", image, tag))
-				continue // skip on to the next tag and don't update any compose files
-			}
-
-			catlVersions, err := recipePkg.VersionsOfService(recipe.Name, service.Name)
-			if err != nil {
-				logrus.Fatal(err)
-			}
-
-			compatibleStrings := []string{"skip"}
-			for _, compat := range compatible {
-				skip := false
-				for _, catlVersion := range catlVersions {
-					if compat.String() == catlVersion {
-						skip = true
-					}
-				}
-				if !skip {
-					compatibleStrings = append(compatibleStrings, compat.String())
-				}
-			}
-
-			logrus.Debugf("detected compatible upgradable tags %s for %s", compatibleStrings, service.Name)
-
-			var upgradeTag string
-			_, ok := servicePins[service.Name]
-			if versionsPresent && ok {
-				pinnedTag := servicePins[service.Name].version
-				if tag.IsLessThan(pinnedTag) {
-					pinnedTagString := pinnedTag.String()
-					contains := false
-					for _, v := range compatible {
-						if pinnedTag.IsUpgradeCompatible(v) {
-							contains = true
-							upgradeTag = v.String()
-							break
-						}
-					}
-					if contains {
-						logrus.Infof("upgrading service %s from %s to %s (pinned tag: %s)", service.Name, tag.String(), upgradeTag, pinnedTagString)
-					} else {
-						logrus.Infof("service %s, image %s pinned to %s, no compatible upgrade found", service.Name, servicePins[service.Name].image, pinnedTagString)
-						continue
-					}
-				} else {
-					logrus.Fatalf("service %s is at version %s, but pinned to %s, please correct your compose.yml file manually!", service.Name, tag.String(), pinnedTag.String())
-					continue
-				}
-			} else {
-				if bumpType != 0 {
-					for _, upTag := range compatible {
-						upElement, err := tag.UpgradeDelta(upTag)
-						if err != nil {
-							return err
-						}
-						delta := upElement.UpgradeType()
-						if delta <= bumpType {
-							upgradeTag = upTag.String()
-							break
-						}
-					}
-					if upgradeTag == "" {
-						logrus.Warnf("not upgrading from %s to %s for %s, because the upgrade type is more serious than what user wants", tag.String(), compatible[0].String(), image)
-						continue
-					}
-				} else {
-					msg := fmt.Sprintf("upgrade to which tag? (service: %s, image: %s, tag: %s)", service.Name, image, tag)
-					if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) || internal.AllTags {
-						tag := img.(reference.NamedTagged).Tag()
-						if !internal.AllTags {
-							logrus.Warning(fmt.Sprintf("unable to determine versioning semantics of %s, listing all tags", tag))
-						}
-						msg = fmt.Sprintf("upgrade to which tag? (service: %s, tag: %s)", service.Name, tag)
-						compatibleStrings = []string{"skip"}
-						for _, regVersion := range regVersions {
-							compatibleStrings = append(compatibleStrings, regVersion)
-						}
-					}
-
-					prompt := &survey.Select{
-						Message: msg,
-						Help:    "enter / return to confirm, choose 'skip' to not upgrade this tag, vim mode is enabled",
-						VimMode: true,
-						Options: compatibleStrings,
-					}
-					if err := survey.AskOne(prompt, &upgradeTag); err != nil {
-						logrus.Fatal(err)
-					}
-				}
-			}
-			if upgradeTag != "skip" {
-				ok, err := recipe.UpdateTag(image, upgradeTag)
-				if err != nil {
-					logrus.Fatal(err)
-				}
-				if ok {
-					logrus.Infof("tag upgraded from %s to %s for %s", tag.String(), upgradeTag, image)
-				}
-			} else {
-				logrus.Warnf("not upgrading %s, skipping as requested", image)
-			}
-		}
-
-		return nil
-	},
-}

cli/recipe/version.go

@@ -1,56 +0,0 @@
-package recipe
-
-import (
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/autocomplete"
-	"coopcloud.tech/abra/pkg/formatter"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var recipeVersionCommand = cli.Command{
-	Name:      "versions",
-	Aliases:   []string{"v"},
-	Usage:     "List recipe versions",
-	ArgsUsage: "<recipe>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-	},
-	Before:       internal.SubCommandBefore,
-	BashComplete: autocomplete.RecipeNameComplete,
-	Action: func(c *cli.Context) error {
-		recipe := internal.ValidateRecipe(c, false)
-
-		catalogue, err := recipePkg.ReadRecipeCatalogue()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		recipeMeta, ok := catalogue[recipe.Name]
-		if !ok {
-			logrus.Fatalf("%s recipe doesn't exist?", recipe.Name)
-		}
-
-		tableCol := []string{"Version", "Service", "Image", "Tag", "Digest"}
-		table := formatter.CreateTable(tableCol)
-
-		for i := len(recipeMeta.Versions) - 1; i >= 0; i-- {
-			for tag, meta := range recipeMeta.Versions[i] {
-				for service, serviceMeta := range meta {
-					table.Append([]string{tag, service, serviceMeta.Image, serviceMeta.Tag, serviceMeta.Digest})
-				}
-			}
-		}
-
-		table.SetAutoMergeCells(true)
-
-		if table.NumLines() > 0 {
-			table.Render()
-		} else {
-			logrus.Fatalf("%s has no published versions?", recipe.Name)
-		}
-
-		return nil
-	},
-}

cli/record/list.go

@@ -1,82 +0,0 @@
-package record
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-
-	"coopcloud.tech/abra/cli/internal"
-	gandiPkg "coopcloud.tech/abra/pkg/dns/gandi"
-	"coopcloud.tech/abra/pkg/formatter"
-	"github.com/libdns/gandi"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// RecordListCommand lists domains.
-var RecordListCommand = cli.Command{
-	Name:      "list",
-	Usage:     "List domain name records",
-	Aliases:   []string{"ls"},
-	ArgsUsage: "<zone>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.DNSProviderFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-This command lists all domain name records managed by a 3rd party provider for
-a specific zone.
-
-You must specify a zone (e.g. example.com) under which your domain name records
-are listed. This zone must already be created on your provider account.
-`,
-	Action: func(c *cli.Context) error {
-		if err := internal.EnsureDNSProvider(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		zone, err := internal.EnsureZoneArgument(c)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		var provider gandi.Provider
-		switch internal.DNSProvider {
-		case "gandi":
-			provider, err = gandiPkg.New()
-			if err != nil {
-				logrus.Fatal(err)
-			}
-		default:
-			logrus.Fatalf("%s is not a supported DNS provider", internal.DNSProvider)
-		}
-
-		records, err := provider.GetRecords(context.Background(), zone)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		tableCol := []string{"type", "name", "value", "TTL", "priority"}
-		table := formatter.CreateTable(tableCol)
-
-		for _, record := range records {
-			value := record.Value
-			if len(record.Value) > 30 {
-				value = fmt.Sprintf("%s...", record.Value[:30])
-			}
-
-			table.Append([]string{
-				record.Type,
-				record.Name,
-				value,
-				record.TTL.String(),
-				strconv.Itoa(record.Priority),
-			})
-		}
-
-		table.Render()
-
-		return nil
-	},
-}

cli/record/new.go

@@ -1,148 +0,0 @@
-package record
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/dns"
-	gandiPkg "coopcloud.tech/abra/pkg/dns/gandi"
-	"coopcloud.tech/abra/pkg/formatter"
-	"github.com/libdns/gandi"
-	"github.com/libdns/libdns"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// RecordNewCommand creates a new domain name record.
-var RecordNewCommand = cli.Command{
-	Name:      "new",
-	Usage:     "Create a new domain record",
-	Aliases:   []string{"n"},
-	ArgsUsage: "<zone>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.DNSProviderFlag,
-		internal.DNSTypeFlag,
-		internal.DNSNameFlag,
-		internal.DNSValueFlag,
-		internal.DNSTTLFlag,
-		internal.DNSPriorityFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-This command creates a new domain name record for a specific zone.
-
-You must specify a zone (e.g. example.com) under which your domain name records
-are listed. This zone must already be created on your provider account.
-
-Example:
-
-    abra record new foo.com -p gandi -t A -n myapp -v 192.168.178.44
-
-You may also invoke this command in "wizard" mode and be prompted for input:
-
-    abra record new
-`,
-	Action: func(c *cli.Context) error {
-		zone, err := internal.EnsureZoneArgument(c)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := internal.EnsureDNSProvider(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		var provider gandi.Provider
-		switch internal.DNSProvider {
-		case "gandi":
-			provider, err = gandiPkg.New()
-			if err != nil {
-				logrus.Fatal(err)
-			}
-		default:
-			logrus.Fatalf("%s is not a supported DNS provider", internal.DNSProvider)
-		}
-
-		if err := internal.EnsureDNSTypeFlag(c); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := internal.EnsureDNSNameFlag(c); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := internal.EnsureDNSValueFlag(c); err != nil {
-			logrus.Fatal(err)
-		}
-
-		ttl, err := dns.GetTTL(internal.DNSTTL)
-		if err != nil {
-			return err
-		}
-
-		record := libdns.Record{
-			Type:  internal.DNSType,
-			Name:  internal.DNSName,
-			Value: internal.DNSValue,
-			TTL:   ttl,
-		}
-
-		if internal.DNSType == "MX" || internal.DNSType == "SRV" || internal.DNSType == "URI" {
-			record.Priority = internal.DNSPriority
-		}
-
-		records, err := provider.GetRecords(context.Background(), zone)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		for _, existingRecord := range records {
-			if existingRecord.Type == record.Type &&
-				existingRecord.Name == record.Name &&
-				existingRecord.Value == record.Value {
-				logrus.Fatalf("%s record for %s already exists?", record.Type, zone)
-			}
-		}
-
-		createdRecords, err := provider.SetRecords(
-			context.Background(),
-			zone,
-			[]libdns.Record{record},
-		)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if len(createdRecords) == 0 {
-			logrus.Fatal("provider library reports that no record was created?")
-		}
-
-		createdRecord := createdRecords[0]
-
-		tableCol := []string{"type", "name", "value", "TTL", "priority"}
-		table := formatter.CreateTable(tableCol)
-
-		value := createdRecord.Value
-		if len(createdRecord.Value) > 30 {
-			value = fmt.Sprintf("%s...", createdRecord.Value[:30])
-		}
-
-		table.Append([]string{
-			createdRecord.Type,
-			createdRecord.Name,
-			value,
-			createdRecord.TTL.String(),
-			strconv.Itoa(createdRecord.Priority),
-		})
-
-		table.Render()
-
-		logrus.Info("record created")
-
-		return nil
-	},
-}

cli/record/record.go

@@ -1,37 +0,0 @@
-package record
-
-import (
-	"github.com/urfave/cli"
-)
-
-// RecordCommand supports managing DNS entries.
-var RecordCommand = cli.Command{
-	Name:      "record",
-	Usage:     "Manage domain name records",
-	Aliases:   []string{"rc"},
-	ArgsUsage: "<record>",
-	Description: `
-This command supports managing domain name records via 3rd party providers such
-as Gandi DNS. It supports listing, creating and removing all types of records
-that you might need for managing Co-op Cloud apps.
-
-The following providers are supported:
-
-    Gandi DNS https://www.gandi.net
-
-You need an account with such a provider already. Typically, you need to
-provide an API token on the Abra command-line when using these commands so that
-you can authenticate with your provider account.
-
-New providers can be integrated, we welcome change sets. See the underlying DNS
-library documentation for more. It supports many existing providers and allows
-to implement new provider support easily.
-
-    https://pkg.go.dev/github.com/libdns/libdns
-`,
-	Subcommands: []cli.Command{
-		RecordListCommand,
-		RecordNewCommand,
-		RecordRemoveCommand,
-	},
-}

cli/record/remove.go

@@ -1,136 +0,0 @@
-package record
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-
-	"coopcloud.tech/abra/cli/internal"
-	gandiPkg "coopcloud.tech/abra/pkg/dns/gandi"
-	"coopcloud.tech/abra/pkg/formatter"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/libdns/gandi"
-	"github.com/libdns/libdns"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// RecordRemoveCommand lists domains.
-var RecordRemoveCommand = cli.Command{
-	Name:      "remove",
-	Usage:     "Remove a domain name record",
-	Aliases:   []string{"rm"},
-	ArgsUsage: "<zone>",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.DNSProviderFlag,
-		internal.DNSTypeFlag,
-		internal.DNSNameFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Description: `
-This command removes a domain name record for a specific zone.
-
-It uses the type of record and name to match existing records and choose one
-for deletion. You must specify a zone (e.g. example.com) under which your
-domain name records are listed. This zone must already be created on your
-provider account.
-
-Example:
-
-    abra record remove foo.com -p gandi -t A -n myapp
-
-You may also invoke this command in "wizard" mode and be prompted for input:
-
-    abra record rm
-`,
-	Action: func(c *cli.Context) error {
-		zone, err := internal.EnsureZoneArgument(c)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := internal.EnsureDNSProvider(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		var provider gandi.Provider
-		switch internal.DNSProvider {
-		case "gandi":
-			provider, err = gandiPkg.New()
-			if err != nil {
-				logrus.Fatal(err)
-			}
-		default:
-			logrus.Fatalf("%s is not a supported DNS provider", internal.DNSProvider)
-		}
-
-		if err := internal.EnsureDNSTypeFlag(c); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := internal.EnsureDNSNameFlag(c); err != nil {
-			logrus.Fatal(err)
-		}
-
-		records, err := provider.GetRecords(context.Background(), zone)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		var toDelete libdns.Record
-		for _, record := range records {
-			if record.Type == internal.DNSType && record.Name == internal.DNSName {
-				toDelete = record
-				break
-			}
-		}
-
-		if (libdns.Record{}) == toDelete {
-			logrus.Fatal("provider library reports no matching record?")
-		}
-
-		tableCol := []string{"type", "name", "value", "TTL", "priority"}
-		table := formatter.CreateTable(tableCol)
-
-		value := toDelete.Value
-		if len(toDelete.Value) > 30 {
-			value = fmt.Sprintf("%s...", toDelete.Value[:30])
-		}
-
-		table.Append([]string{
-			toDelete.Type,
-			toDelete.Name,
-			value,
-			toDelete.TTL.String(),
-			strconv.Itoa(toDelete.Priority),
-		})
-
-		table.Render()
-
-		if !internal.NoInput {
-			response := false
-			prompt := &survey.Confirm{
-				Message: "continue with record deletion?",
-			}
-
-			if err := survey.AskOne(prompt, &response); err != nil {
-				return err
-			}
-
-			if !response {
-				logrus.Fatal("exiting as requested")
-			}
-		}
-
-		_, err = provider.DeleteRecords(context.Background(), zone, []libdns.Record{toDelete})
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Info("record successfully deleted")
-
-		return nil
-	},
-}

cli/server/add.go

@@ -1,511 +0,0 @@
-package server
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"os/exec"
-	"os/user"
-	"path/filepath"
-	"strings"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
-	contextPkg "coopcloud.tech/abra/pkg/context"
-	"coopcloud.tech/abra/pkg/dns"
-	"coopcloud.tech/abra/pkg/server"
-	"coopcloud.tech/abra/pkg/ssh"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/swarm"
-	dockerClient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var (
-	dockerInstallMsg = `
-A docker installation cannot be found on %s. This is a required system
-dependency for running Co-op Cloud on your server. If you would like, Abra can
-attempt to install Docker for you using the upstream non-interactive
-installation script.
-
-See the following documentation for more:
-
-    https://docs.docker.com/engine/install/debian/#install-using-the-convenience-script
-
-N.B Docker doesn't recommend it for production environments but many use it for
-such purposes. Docker stable is now installed by default by this script. The
-source for this script can be seen here:
-
-    https://github.com/docker/docker-install
-`
-)
-
-var local bool
-var localFlag = &cli.BoolFlag{
-	Name:        "local, l",
-	Usage:       "Use local server",
-	Destination: &local,
-}
-
-var provision bool
-var provisionFlag = &cli.BoolFlag{
-	Name:        "provision, p",
-	Usage:       "Provision server so it can deploy apps",
-	Destination: &provision,
-}
-
-var sshAuth string
-var sshAuthFlag = &cli.StringFlag{
-	Name:        "ssh-auth, s",
-	Value:       "identity-file",
-	Usage:       "Select SSH authentication method (identity-file, password)",
-	Destination: &sshAuth,
-}
-
-var askSudoPass bool
-var askSudoPassFlag = &cli.BoolFlag{
-	Name:        "ask-sudo-pass, a",
-	Usage:       "Ask for sudo password",
-	Destination: &askSudoPass,
-}
-
-func cleanUp(domainName string) {
-	logrus.Warnf("cleaning up context for %s", domainName)
-	if err := client.DeleteContext(domainName); err != nil {
-		logrus.Fatal(err)
-	}
-
-	logrus.Warnf("cleaning up server directory for %s", domainName)
-	if err := os.RemoveAll(filepath.Join(config.SERVERS_DIR, domainName)); err != nil {
-		logrus.Fatal(err)
-	}
-}
-
-func installDockerLocal(c *cli.Context) error {
-	fmt.Println(fmt.Sprintf(dockerInstallMsg, "this local server"))
-
-	response := false
-	prompt := &survey.Confirm{
-		Message: fmt.Sprintf("attempt install docker on local server?"),
-	}
-	if err := survey.AskOne(prompt, &response); err != nil {
-		return err
-	}
-	if !response {
-		logrus.Fatal("exiting as requested")
-	}
-
-	for _, exe := range []string{"wget", "bash"} {
-		exists, err := ensureLocalExecutable(exe)
-		if err != nil {
-			return err
-		}
-		if !exists {
-			return fmt.Errorf("%s missing, please install it", exe)
-		}
-	}
-
-	cmd := exec.Command("bash", "-c", "wget -O- https://get.docker.com | bash")
-	if err := internal.RunCmd(cmd); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func newLocalServer(c *cli.Context, domainName string) error {
-	if err := createServerDir(domainName); err != nil {
-		return err
-	}
-
-	cl, err := newClient(c, domainName)
-	if err != nil {
-		return err
-	}
-
-	if provision {
-		exists, err := ensureLocalExecutable("docker")
-		if err != nil {
-			return err
-		}
-
-		if !exists {
-			if err := installDockerLocal(c); err != nil {
-				return err
-			}
-		}
-
-		if err := initSwarmLocal(c, cl, domainName); err != nil {
-			if !strings.Contains(err.Error(), "proxy already exists") {
-				logrus.Fatal(err)
-			}
-		}
-	}
-
-	logrus.Info("local server has been added")
-
-	return nil
-}
-
-func newContext(c *cli.Context, domainName, username, port string) error {
-	store := contextPkg.NewDefaultDockerContextStore()
-	contexts, err := store.Store.List()
-	if err != nil {
-		return err
-	}
-
-	for _, context := range contexts {
-		if context.Name == domainName {
-			logrus.Debugf("context for %s already exists", domainName)
-			return nil
-		}
-	}
-
-	logrus.Debugf("creating context with domain %s, username %s and port %s", domainName, username, port)
-
-	if err := client.CreateContext(domainName, username, port); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func newClient(c *cli.Context, domainName string) (*dockerClient.Client, error) {
-	cl, err := client.New(domainName)
-	if err != nil {
-		return &dockerClient.Client{}, err
-	}
-	return cl, nil
-}
-
-func installDocker(c *cli.Context, cl *dockerClient.Client, sshCl *ssh.Client, domainName string) error {
-	exists, err := ensureRemoteExecutable("docker", sshCl)
-	if err != nil {
-		return err
-	}
-
-	if !exists {
-		fmt.Println(fmt.Sprintf(dockerInstallMsg, domainName))
-
-		response := false
-		prompt := &survey.Confirm{
-			Message: fmt.Sprintf("attempt install docker on %s?", domainName),
-		}
-
-		if err := survey.AskOne(prompt, &response); err != nil {
-			return err
-		}
-
-		if !response {
-			logrus.Fatal("exiting as requested")
-		}
-
-		exes := []string{"wget", "bash"}
-		if askSudoPass {
-			exes = append(exes, "ssh-askpass")
-		}
-
-		for _, exe := range exes {
-			exists, err := ensureRemoteExecutable(exe, sshCl)
-			if err != nil {
-				return err
-			}
-			if !exists {
-				return fmt.Errorf("%s missing on remote, please install it", exe)
-			}
-		}
-
-		var sudoPass string
-		if askSudoPass {
-			cmd := "wget -O- https://get.docker.com | bash"
-
-			prompt := &survey.Password{
-				Message: "sudo password?",
-			}
-
-			if err := survey.AskOne(prompt, &sudoPass); err != nil {
-				return err
-			}
-
-			logrus.Debugf("running %s on %s now with sudo password", cmd, domainName)
-
-			if sudoPass == "" {
-				return fmt.Errorf("missing sudo password but requested --ask-sudo-pass?")
-			}
-
-			logrus.Warn("installing docker, this could take some time...")
-
-			if err := ssh.RunSudoCmd(cmd, sudoPass, sshCl); err != nil {
-				fmt.Print(fmt.Sprintf(`
-Abra was unable to bootstrap Docker, see below for logs:
-
-
-%s
-
-If nothing works, you try running the Docker install script manually on your server:
-
-    wget -O- https://get.docker.com | bash
-
-`, string(err.Error())))
-				logrus.Fatal("Process exited with status 1")
-			}
-
-			logrus.Infof("docker is installed on %s", domainName)
-
-			remoteUser := sshCl.SSHClient.Conn.User()
-			logrus.Infof("adding %s to docker group", remoteUser)
-			permsCmd := fmt.Sprintf("sudo usermod -aG docker %s", remoteUser)
-			if err := ssh.RunSudoCmd(permsCmd, sudoPass, sshCl); err != nil {
-				return err
-			}
-		} else {
-			cmd := "wget -O- https://get.docker.com | bash"
-
-			logrus.Debugf("running %s on %s now without sudo password", cmd, domainName)
-
-			logrus.Warn("installing docker, this could take some time...")
-
-			if out, err := sshCl.Exec(cmd); err != nil {
-				fmt.Print(fmt.Sprintf(`
-Abra was unable to bootstrap Docker, see below for logs:
-
-
-%s
-
-This could be due to a number of things but one of the most common is that your
-server user account does not have sudo access, and if it does, you need to pass
-"--ask-sudo-pass" in order to supply Abra with your password.
-
-If nothing works, you try running the Docker install script manually on your server:
-
-    wget -O- https://get.docker.com | bash
-
-`, string(out)))
-				logrus.Fatal(err)
-			}
-
-			logrus.Infof("docker is installed on %s", domainName)
-		}
-	}
-
-	return nil
-}
-
-func initSwarmLocal(c *cli.Context, cl *dockerClient.Client, domainName string) error {
-	initReq := swarm.InitRequest{ListenAddr: "0.0.0.0:2377"}
-	if _, err := cl.SwarmInit(context.Background(), initReq); err != nil {
-		if strings.Contains(err.Error(), "is already part of a swarm") ||
-			strings.Contains(err.Error(), "must specify a listening address") {
-			logrus.Infof("swarm mode already initialised on %s", domainName)
-		} else {
-			return err
-		}
-	} else {
-		logrus.Infof("initialised swarm mode on local server")
-	}
-
-	netOpts := types.NetworkCreate{Driver: "overlay", Scope: "swarm"}
-	if _, err := cl.NetworkCreate(context.Background(), "proxy", netOpts); err != nil {
-		if !strings.Contains(err.Error(), "proxy already exists") {
-			return err
-		}
-		logrus.Info("swarm overlay network already created on local server")
-	} else {
-		logrus.Infof("swarm overlay network created on local server")
-	}
-
-	return nil
-}
-
-func initSwarm(c *cli.Context, cl *dockerClient.Client, domainName string) error {
-	ipv4, err := dns.EnsureIPv4(domainName)
-	if err != nil {
-		return err
-	}
-
-	initReq := swarm.InitRequest{
-		ListenAddr:    "0.0.0.0:2377",
-		AdvertiseAddr: ipv4,
-	}
-	if _, err := cl.SwarmInit(context.Background(), initReq); err != nil {
-		if strings.Contains(err.Error(), "is already part of a swarm") ||
-			strings.Contains(err.Error(), "must specify a listening address") {
-			logrus.Infof("swarm mode already initialised on %s", domainName)
-		} else {
-			return err
-		}
-	} else {
-		logrus.Infof("initialised swarm mode on %s", domainName)
-	}
-
-	netOpts := types.NetworkCreate{Driver: "overlay", Scope: "swarm"}
-	if _, err := cl.NetworkCreate(context.Background(), "proxy", netOpts); err != nil {
-		if !strings.Contains(err.Error(), "proxy already exists") {
-			return err
-		}
-		logrus.Infof("swarm overlay network already created on %s", domainName)
-	} else {
-		logrus.Infof("swarm overlay network created on %s", domainName)
-	}
-
-	return nil
-}
-
-func createServerDir(domainName string) error {
-	if err := server.CreateServerDir(domainName); err != nil {
-		if !os.IsExist(err) {
-			return err
-		}
-		logrus.Debugf("server dir for %s already created", domainName)
-	}
-	return nil
-}
-
-var serverAddCommand = cli.Command{
-	Name:    "add",
-	Aliases: []string{"a"},
-	Usage:   "Add a server to your configuration",
-	Description: `
-This command adds a new server to your configuration so that it can be managed
-by Abra. This command can also provision your server ("--provision/-p") with a
-Docker installation so that it is capable of hosting Co-op Cloud apps.
-
-Abra will default to expecting that you have a running ssh-agent and are using
-SSH keys to connect to your new server. Abra will also read your SSH config
-(matching "Host" as <domain>). SSH connection details precedence follows as
-such: command-line > SSH config > guessed defaults.
-
-If you have no SSH key configured for this host and are instead using password
-authentication, you may pass "--ssh-auth password" to have Abra ask you for the
-password. "--ask-sudo-pass" may be passed if you run your provisioning commands
-via sudo privilege escalation.
-
-The <domain> argument must be a publicy accessible domain name which points to
-your server. You should working SSH access to this server already, Abra will
-assume port 22 and will use your current system username to make an initial
-connection. You can use the <user> and <port> arguments to adjust this.
-
-Example:
-
-    abra server add varia.zone glodemodem 12345 -p
-
-Abra will construct the following SSH connection and Docker context:
-
-    ssh://globemodem@varia.zone:12345
-
-All communication between Abra and the server will use this SSH connection.
-
-If "--local" is passed, then Abra assumes that the current local server is
-intended as the target server. This is useful when you want to have your entire
-Co-op Cloud config located on the server itself, and not on your local
-developer machine.
-`,
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		localFlag,
-		provisionFlag,
-		sshAuthFlag,
-		askSudoPassFlag,
-	},
-	Before:    internal.SubCommandBefore,
-	ArgsUsage: "<domain> [<user>] [<port>]",
-	Action: func(c *cli.Context) error {
-		if len(c.Args()) > 0 && local || !internal.ValidateSubCmdFlags(c) {
-			err := errors.New("cannot use <domain> and --local together")
-			internal.ShowSubcommandHelpAndError(c, err)
-		}
-
-		if sshAuth != "password" && sshAuth != "identity-file" {
-			err := errors.New("--ssh-auth only accepts identity-file or password")
-			internal.ShowSubcommandHelpAndError(c, err)
-		}
-
-		domainName := internal.ValidateDomain(c)
-
-		if local {
-			if err := newLocalServer(c, "default"); err != nil {
-				logrus.Fatal(err)
-			}
-			return nil
-		}
-
-		username := c.Args().Get(1)
-		if username == "" {
-			systemUser, err := user.Current()
-			if err != nil {
-				return err
-			}
-			username = systemUser.Username
-		}
-
-		port := c.Args().Get(2)
-		if port == "" {
-			port = "22"
-		}
-
-		if err := createServerDir(domainName); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := newContext(c, domainName, username, port); err != nil {
-			logrus.Fatal(err)
-		}
-
-		cl, err := newClient(c, domainName)
-		if err != nil {
-			cleanUp(domainName)
-			logrus.Debugf("failed to construct client for %s, saw %s", domainName, err.Error())
-			logrus.Fatalf(fmt.Sprintf(internal.ServerAddFailMsg, domainName))
-		}
-
-		if provision {
-			logrus.Debugf("attempting to construct SSH client for %s", domainName)
-			sshCl, err := ssh.New(domainName, sshAuth, username, port)
-			if err != nil {
-				cleanUp(domainName)
-				logrus.Fatalf(fmt.Sprintf(internal.ServerAddFailMsg, domainName))
-			}
-			defer sshCl.Close()
-			logrus.Debugf("successfully created SSH client for %s", domainName)
-
-			if err := installDocker(c, cl, sshCl, domainName); err != nil {
-				logrus.Fatal(err)
-			}
-			if err := initSwarm(c, cl, domainName); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		if _, err := cl.Info(context.Background()); err != nil {
-			cleanUp(domainName)
-			logrus.Fatalf(fmt.Sprintf(internal.ServerAddFailMsg, domainName))
-		}
-
-		return nil
-	},
-}
-
-// ensureLocalExecutable ensures that an executable is present on the local machine
-func ensureLocalExecutable(exe string) (bool, error) {
-	out, err := exec.Command("which", exe).Output()
-	if err != nil {
-		return false, err
-	}
-
-	return string(out) != "", nil
-}
-
-// ensureRemoteExecutable ensures that an executable is present on a remote machine
-func ensureRemoteExecutable(exe string, sshCl *ssh.Client) (bool, error) {
-	out, err := sshCl.Exec(fmt.Sprintf("which %s", exe))
-	if err != nil && string(out) != "" {
-		return false, err
-	}
-
-	return string(out) != "", nil
-}

cli/server/list.go

@@ -1,67 +0,0 @@
-package server
-
-import (
-	"strings"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/context"
-	"coopcloud.tech/abra/pkg/formatter"
-	"github.com/docker/cli/cli/connhelper/ssh"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var serverListCommand = cli.Command{
-	Name:    "list",
-	Aliases: []string{"ls"},
-	Usage:   "List managed servers",
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		dockerContextStore := context.NewDefaultDockerContextStore()
-		contexts, err := dockerContextStore.Store.List()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		tableColumns := []string{"name", "host", "user", "port"}
-		table := formatter.CreateTable(tableColumns)
-		defer table.Render()
-
-		serverNames, err := config.ReadServerNames()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		for _, serverName := range serverNames {
-			var row []string
-			for _, ctx := range contexts {
-				endpoint, err := context.GetContextEndpoint(ctx)
-				if err != nil && strings.Contains(err.Error(), "does not exist") {
-					// No local context found, we can continue safely
-					continue
-				}
-				if ctx.Name == serverName {
-					sp, err := ssh.ParseURL(endpoint)
-					if err != nil {
-						logrus.Fatal(err)
-					}
-					row = []string{serverName, sp.Host, sp.User, sp.Port}
-				}
-			}
-			if len(row) == 0 {
-				if serverName == "default" {
-					row = []string{serverName, "local", "n/a", "n/a"}
-				} else {
-					row = []string{serverName, "unknown", "unknown", "unknown"}
-				}
-			}
-			table.Append(row)
-		}
-
-		return nil
-	},
-}

cli/server/new.go

@@ -1,262 +0,0 @@
-package server
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/libcapsul"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/hetznercloud/hcloud-go/hcloud"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-func newHetznerCloudVPS(c *cli.Context) error {
-	if err := internal.EnsureNewHetznerCloudVPSFlags(c); err != nil {
-		return err
-	}
-
-	client := hcloud.NewClient(hcloud.WithToken(internal.HetznerCloudAPIToken))
-
-	var sshKeysRaw []string
-	var sshKeys []*hcloud.SSHKey
-	for _, sshKey := range c.StringSlice("hetzner-ssh-keys") {
-		if sshKey == "" {
-			continue
-		}
-
-		sshKey, _, err := client.SSHKey.GetByName(context.Background(), sshKey)
-		if err != nil {
-			return err
-		}
-		sshKeys = append(sshKeys, sshKey)
-		sshKeysRaw = append(sshKeysRaw, sshKey.Name)
-	}
-
-	serverOpts := hcloud.ServerCreateOpts{
-		Name:       internal.HetznerCloudName,
-		ServerType: &hcloud.ServerType{Name: internal.HetznerCloudType},
-		Image:      &hcloud.Image{Name: internal.HetznerCloudImage},
-		SSHKeys:    sshKeys,
-		Location:   &hcloud.Location{Name: internal.HetznerCloudLocation},
-	}
-
-	sshKeyIDs := strings.Join(sshKeysRaw, "\n")
-	if sshKeyIDs == "" {
-		sshKeyIDs = "N/A (password auth)"
-	}
-
-	tableColumns := []string{"name", "type", "image", "ssh-keys", "location"}
-	table := formatter.CreateTable(tableColumns)
-	table.Append([]string{
-		internal.HetznerCloudName,
-		internal.HetznerCloudType,
-		internal.HetznerCloudImage,
-		sshKeyIDs,
-		internal.HetznerCloudLocation,
-	})
-	table.Render()
-
-	response := false
-	prompt := &survey.Confirm{
-		Message: "continue with hetzner cloud VPS creation?",
-	}
-
-	if err := survey.AskOne(prompt, &response); err != nil {
-		return err
-	}
-
-	if !response {
-		logrus.Fatal("exiting as requested")
-	}
-
-	res, _, err := client.Server.Create(context.Background(), serverOpts)
-	if err != nil {
-		return err
-	}
-
-	var rootPassword string
-	if len(sshKeys) > 0 {
-		rootPassword = "N/A (using SSH keys)"
-	} else {
-		rootPassword = res.RootPassword
-	}
-
-	ip := res.Server.PublicNet.IPv4.IP.String()
-
-	fmt.Println(fmt.Sprintf(`
-Your new Hetzner Cloud VPS has successfully been created! Here are the details:
-
-    name: %s
-    IP address: %s
-    root password: %s
-
-You can access this new VPS via SSH using the following command:
-
-    ssh root@%s
-
-Please note, this server is not managed by Abra yet (i.e. "abra server ls" will
-not list this server)! You will need to assign a domain name record ("abra
-record new") and add the server to your Abra configuration ("abra server add")
-to have a working server that you can deploy Co-op Cloud apps to.
-
-When setting up domain name records, you probably want to set up the following
-2 A records. This supports deploying apps to your root domain (e.g.
-example.com) and other apps on sub-domains (e.g. foo.example.com,
-bar.example.com).
-
-    @  1800 IN A %s
-    *  1800 IN A %s
-
-	`,
-		internal.HetznerCloudName, ip, rootPassword,
-		ip, ip, ip,
-	))
-
-	return nil
-}
-
-func newCapsulVPS(c *cli.Context) error {
-	if err := internal.EnsureNewCapsulVPSFlags(c); err != nil {
-		return err
-	}
-
-	capsulCreateURL := fmt.Sprintf("https://%s/api/capsul/create", internal.CapsulInstanceURL)
-
-	var sshKeys []string
-	for _, sshKey := range c.StringSlice("capsul-ssh-keys") {
-		if sshKey == "" {
-			continue
-		}
-		sshKeys = append(sshKeys, sshKey)
-	}
-
-	tableColumns := []string{"instance", "name", "type", "image", "ssh-keys"}
-	table := formatter.CreateTable(tableColumns)
-	table.Append([]string{
-		internal.CapsulInstanceURL,
-		internal.CapsulName,
-		internal.CapsulType,
-		internal.CapsulImage,
-		strings.Join(sshKeys, "\n"),
-	})
-	table.Render()
-
-	response := false
-	prompt := &survey.Confirm{
-		Message: "continue with capsul creation?",
-	}
-
-	if err := survey.AskOne(prompt, &response); err != nil {
-		return err
-	}
-
-	if !response {
-		logrus.Fatal("exiting as requested")
-	}
-
-	capsulClient := libcapsul.New(capsulCreateURL, internal.CapsulAPIToken)
-	resp, err := capsulClient.Create(
-		internal.CapsulName,
-		internal.CapsulType,
-		internal.CapsulImage,
-		sshKeys,
-	)
-	if err != nil {
-		return err
-	}
-
-	fmt.Println(fmt.Sprintf(`
-Your new Capsul has successfully been created! Here are the details:
-
-    Capsul name: %s
-    Capsul ID:   %v
-
-You will need to log into your Capsul instance web interface to retrieve the IP
-address. You can learn all about how to get SSH access to your new Capsul on:
-
-    %s/about-ssh
-
-Please note, this server is not managed by Abra yet (i.e. "abra server ls" will
-not list this server)! You will need to assign a domain name record ("abra
-record new") and add the server to your Abra configuration ("abra server add")
-to have a working server that you can deploy Co-op Cloud apps to.
-
-When setting up domain name records, you probably want to set up the following
-2 A records. This supports deploying apps to your root domain (e.g.
-example.com) and other apps on sub-domains (e.g. foo.example.com,
-bar.example.com).
-
-    @  1800 IN A <your-capsul-ip>
-    *  1800 IN A <your-capsul-ip>
-
-	`, internal.CapsulName, resp.ID, internal.CapsulInstanceURL))
-
-	return nil
-}
-
-var serverNewCommand = cli.Command{
-	Name:    "new",
-	Aliases: []string{"n"},
-	Usage:   "Create a new server using a 3rd party provider",
-	Description: `
-This command creates a new server via a 3rd party provider.
-
-The following providers are supported:
-
-		Capsul https://git.cyberia.club/Cyberia/capsul-flask
-    Hetzner Cloud https://docs.hetzner.com/cloud
-
-You may invoke this command in "wizard" mode and be prompted for input:
-
-    abra record new
-
-API tokens are read from the environment if specified, e.g.
-
-    export HCLOUD_TOKEN=...
-
-Where "$provider_TOKEN" is the expected env var format.
-`,
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		internal.ServerProviderFlag,
-
-		// Capsul
-		internal.CapsulInstanceURLFlag,
-		internal.CapsulTypeFlag,
-		internal.CapsulImageFlag,
-		internal.CapsulSSHKeysFlag,
-		internal.CapsulAPITokenFlag,
-
-		// Hetzner
-		internal.HetznerCloudNameFlag,
-		internal.HetznerCloudTypeFlag,
-		internal.HetznerCloudImageFlag,
-		internal.HetznerCloudSSHKeysFlag,
-		internal.HetznerCloudLocationFlag,
-		internal.HetznerCloudAPITokenFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		if err := internal.EnsureServerProvider(); err != nil {
-			logrus.Fatal(err)
-		}
-
-		switch internal.ServerProvider {
-		case "capsul":
-			if err := newCapsulVPS(c); err != nil {
-				logrus.Fatal(err)
-			}
-		case "hetzner-cloud":
-			if err := newHetznerCloudVPS(c); err != nil {
-				logrus.Fatal(err)
-			}
-		}
-
-		return nil
-	},
-}

cli/server/remove.go

@@ -1,184 +0,0 @@
-package server
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"coopcloud.tech/abra/cli/internal"
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/formatter"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/hetznercloud/hcloud-go/hcloud"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var rmServer bool
-var rmServerFlag = &cli.BoolFlag{
-	Name:        "server, s",
-	Usage:       "remove the actual server also",
-	Destination: &rmServer,
-}
-
-func rmHetznerCloudVPS(c *cli.Context) error {
-	if internal.HetznerCloudName == "" && !internal.NoInput {
-		prompt := &survey.Input{
-			Message: "specify hetzner cloud VPS name",
-		}
-		if err := survey.AskOne(prompt, &internal.HetznerCloudName); err != nil {
-			return err
-		}
-	}
-
-	if internal.HetznerCloudAPIToken == "" && !internal.NoInput {
-		token, ok := os.LookupEnv("HCLOUD_TOKEN")
-		if !ok {
-			prompt := &survey.Input{
-				Message: "specify hetzner cloud API token",
-			}
-			if err := survey.AskOne(prompt, &internal.HetznerCloudAPIToken); err != nil {
-				return err
-			}
-		} else {
-			internal.HetznerCloudAPIToken = token
-		}
-	}
-
-	client := hcloud.NewClient(hcloud.WithToken(internal.HetznerCloudAPIToken))
-
-	server, _, err := client.Server.Get(context.Background(), internal.HetznerCloudName)
-	if err != nil {
-		return err
-	}
-
-	if server == nil {
-		logrus.Fatalf("library provider reports that %s doesn't exist?", internal.HetznerCloudName)
-	}
-
-	fmt.Println(fmt.Sprintf(`
-You have requested that Abra delete the following server (%s). Please be
-absolutely sure that this is indeed the server that you would like to have
-removed. There will be no going back once you confirm, the server will be
-destroyed.
-`, server.Name))
-
-	tableColumns := []string{"name", "type", "image", "location"}
-	table := formatter.CreateTable(tableColumns)
-	table.Append([]string{
-		server.Name,
-		server.ServerType.Name,
-		server.Image.Name,
-		server.Datacenter.Name,
-	})
-	table.Render()
-
-	response := false
-	prompt := &survey.Confirm{
-		Message: "continue with hetzner cloud VPS removal?",
-	}
-
-	if err := survey.AskOne(prompt, &response); err != nil {
-		return err
-	}
-
-	if !response {
-		logrus.Fatal("exiting as requested")
-	}
-
-	_, err = client.Server.Delete(context.Background(), server)
-	if err != nil {
-		return err
-	}
-
-	logrus.Infof("%s has been deleted from your hetzner cloud account", internal.HetznerCloudName)
-
-	return nil
-}
-
-var serverRemoveCommand = cli.Command{
-	Name:      "remove",
-	Aliases:   []string{"rm"},
-	ArgsUsage: "[<server>]",
-	Usage:     "Remove a managed server",
-	Description: `
-This command removes a server from Abra management.
-
-Depending on whether you used a 3rd party provider to create this server ("abra
-server new"), you can also destroy the virtual server as well. Pass
-"--server/-s" to tell Abra to try to delete this VPS.
-
-Otherwise, Abra will remove the internal bookkeeping (~/.abra/servers/...) and
-underlying client connection context. This server will then be lost in time,
-like tears in rain.
-`,
-	Flags: []cli.Flag{
-		internal.DebugFlag,
-		internal.NoInputFlag,
-		rmServerFlag,
-		internal.ServerProviderFlag,
-
-		// Hetzner
-		internal.HetznerCloudNameFlag,
-		internal.HetznerCloudAPITokenFlag,
-	},
-	Before: internal.SubCommandBefore,
-	Action: func(c *cli.Context) error {
-		serverName := internal.ValidateServer(c)
-
-		warnMsg := `Did not pass -s/--server for actual server deletion, prompting!
-
-Abra doesn't currently know if it helped you create this server with one of the
-3rd party integrations (e.g. Capsul). You have a choice here to actually,
-really and finally destroy this server using those integrations. If you want to
-do this, choose Yes.
-
-If you just want to remove the server config files & context, choose No.
-`
-
-		if !rmServer {
-			logrus.Warn(fmt.Sprintf(warnMsg))
-
-			response := false
-			prompt := &survey.Confirm{
-				Message: "delete actual live server?",
-			}
-			if err := survey.AskOne(prompt, &response); err != nil {
-				logrus.Fatal(err)
-			}
-			if response {
-				logrus.Info("setting -s/--server and attempting to remove actual server")
-				rmServer = true
-			}
-		}
-
-		if rmServer {
-			if err := internal.EnsureServerProvider(); err != nil {
-				logrus.Fatal(err)
-			}
-
-			switch internal.ServerProvider {
-			case "capsul":
-				logrus.Warn("capsul provider does not support automatic removal yet, sorry!")
-			case "hetzner-cloud":
-				if err := rmHetznerCloudVPS(c); err != nil {
-					logrus.Fatal(err)
-				}
-			}
-		}
-
-		if err := client.DeleteContext(serverName); err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := os.RemoveAll(filepath.Join(config.SERVERS_DIR, serverName)); err != nil {
-			logrus.Fatal(err)
-		}
-
-		logrus.Infof("server at %s has been lost in time, like tears in rain", serverName)
-
-		return nil
-	},
-}

cli/server/server.go

@@ -1,27 +0,0 @@
-package server
-
-import (
-	"github.com/urfave/cli"
-)
-
-// ServerCommand defines the `abra server` command and its subcommands
-var ServerCommand = cli.Command{
-	Name:    "server",
-	Aliases: []string{"s"},
-	Usage:   "Manage servers",
-	Description: `
-These commands support creating, managing and removing servers using 3rd party
-integrations. 
-
-Servers can be created from scratch using the "abra server new" command. If you
-already have a server, you can add it to your configuration using "abra server
-add". Abra can provision servers so that they are ready to deploy Co-op Cloud
-apps, see available flags on "server add" for more.
-`,
-	Subcommands: []cli.Command{
-		serverNewCommand,
-		serverAddCommand,
-		serverListCommand,
-		serverRemoveCommand,
-	},
-}

cmd/abra/main.go

@@ -1,23 +0,0 @@
-// Package main provides the command-line entrypoint.
-package main
-
-import (
-	"coopcloud.tech/abra/cli"
-)
-
-// Version is the current version of Abra
-var Version string
-
-// Commit is the current git commit of Abra
-var Commit string
-
-func main() {
-	if Version == "" {
-		Version = "dev"
-	}
-	if Commit == "" {
-		Commit = "       "
-	}
-
-	cli.RunApp(Version, Commit)
-}

completion/_abra

@@ -0,0 +1,52 @@
+#compdef abra
+
+_abra () {
+	local context state line curcontext="$curcontext" ret=1
+	_arguments -n : \
+		{-h,--help}'[Help message]' \
+		'1:commands:(app server)' \
+		'*::arguments:->arguments' \
+		&& ret=0
+
+	case $state in
+		(arguments)
+			curcontext="${curcontext%:*:*}:abra-arguments-$words[1]:"
+			case $words[1] in
+				(app)
+					_arguments \
+						'1: :_abra_apps' \
+					&& ret=0
+				;;
+				(server)
+					_arguments \
+						'1:servers:_abra_servers' \
+					&& ret=0
+				;;
+			esac
+		;;
+	esac
+
+	return ret
+}
+
+_abra_servers() {
+	_path_files -/W $HOME/.abra/servers
+}
+
+_abra_apps()
+{
+	local newapps apps=($HOME/.abra/servers/*/*.env)
+	typeset -a apps
+	newapps=()
+	for app in $apps; do
+		newapps+=($(_abra_basename "${app}"))
+	done
+	_describe -t apps 'app' newapps
+}
+
+_abra_basename()
+{
+    printf -- "${1##*/}"
+}
+
+_abra "$@"

completion/abra.bash

@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+
+_abra_basename()
+{
+    echo "${1##*/}"
+}
+
+_abra_servers()
+{
+    # FIXME 3wc: copied from abra/get_servers()
+    shopt -s nullglob dotglob
+    local SERVERS=(~/.abra/servers/*)
+    shopt -u nullglob dotglob
+
+    for SERVER in "${SERVERS[@]}"; do
+        _abra_basename "${SERVER}"
+    done
+}
+
+_abra_complete_servers()
+{
+    mapfile -t COMPREPLY < <(compgen -W "$(_abra_servers)" -- "$1")
+}
+
+_abra_apps()
+{
+    shopt -s nullglob dotglob
+    local APPS=(~/.abra/servers/*/*.env)
+    shopt -u nullglob dotglob
+
+    for APP in "${APPS[@]}"; do
+        _abra_basename "${APP%.env}"
+    done
+}
+
+_abra_complete_apps()
+{
+    mapfile -t COMPREPLY < <(compgen -W "$(_abra_apps)" -- "$1")
+}
+
+_abra_complete()
+{
+    compopt +o default +o nospace
+    COMPREPLY=()
+
+    local -r cmds='
+        app
+        server
+    '
+    local -r short_opts='-e      -h     -s      -v'
+    local -r long_opts='--env --help --stack --version'
+
+    # Scan through the command line and find the abra command
+    # (if present), as well as its expected position.
+    local cmd
+    local cmd_index=1 # Expected index of the command token.
+    local i
+    for (( i = 1; i < ${#COMP_WORDS[@]}; i++ )); do
+        local word="${COMP_WORDS[i]}"
+        case "$word" in
+            -*)
+                ((cmd_index++))
+                ;;
+            *)
+                cmd="$word"
+                break
+                ;;
+        esac
+    done
+
+    local cur="${COMP_WORDS[COMP_CWORD]}"
+
+    if (( COMP_CWORD < cmd_index )); then
+        # Offer option completions.
+        case "$cur" in
+            --*)
+                mapfile -t COMPREPLY < <(compgen -W "$long_opts" -- "$cur")
+                ;;
+            -*)
+                mapfile -t COMPREPLY < <(compgen -W "$short_opts" -- "$cur")
+                ;;
+            *)
+                # Skip completion; we should never get here.
+                ;;
+        esac
+    elif (( COMP_CWORD == cmd_index )); then
+        # Offer command name completions.
+        mapfile -t COMPREPLY < <(compgen -W "$cmds" -- "$cur")
+    else
+        # Offer command argument completions.
+        case "$cmd" in
+            server)
+                # Offer exactly one server name completion.
+                if (( COMP_CWORD == cmd_index + 2 )); then
+                    _abra_complete_servers "$cur"
+                fi
+                ;;
+            app)
+                # Offer exactly one app completion.
+                if (( COMP_CWORD == cmd_index + 1 )); then
+                    _abra_complete_apps "$cur"
+                fi
+                ;;
+            #help)
+            #    # Offer exactly one command name completion.
+            #    if (( COMP_CWORD == cmd_index + 1 )); then
+            #        COMPREPLY=($(compgen -W "$cmds" -- "$cur"))
+            #    fi
+            #    ;;
+            *)
+                # Unknown command or unknowable argument.
+                ;;
+        esac
+    fi
+}
+
+complete -o default -F _abra_complete abra

go.mod

@@ -1,53 +0,0 @@
-module coopcloud.tech/abra
-
-go 1.16
-
-require (
-	coopcloud.tech/tagcmp v0.0.0-20211103052201-885b22f77d52
-	github.com/AlecAivazis/survey/v2 v2.3.4
-	github.com/Autonomic-Cooperative/godotenv v1.3.1-0.20210731094149-b031ea1211e7
-	github.com/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4
-	github.com/docker/cli v20.10.14+incompatible
-	github.com/docker/distribution v2.8.1+incompatible
-	github.com/docker/docker v20.10.14+incompatible
-	github.com/docker/go-units v0.4.0
-	github.com/go-git/go-git/v5 v5.4.2
-	github.com/hetznercloud/hcloud-go v1.33.1
-	github.com/moby/sys/signal v0.7.0
-	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6
-	github.com/olekukonko/tablewriter v0.0.5
-	github.com/pkg/errors v0.9.1
-	github.com/schollz/progressbar/v3 v3.8.6
-	github.com/schultz-is/passgen v1.0.1
-	github.com/sirupsen/logrus v1.8.1
-	gotest.tools/v3 v3.1.0
-)
-
-require (
-	coopcloud.tech/libcapsul v0.0.0-20211022074848-c35e78fe3f3e
-	github.com/ProtonMail/go-crypto v0.0.0-20211112122917-428f8eabeeb3 // indirect
-	github.com/buger/goterm v1.0.4
-	github.com/containerd/containerd v1.5.9 // indirect
-	github.com/containers/image v3.0.2+incompatible
-	github.com/containers/storage v1.38.2 // indirect
-	github.com/docker/docker-credential-helpers v0.6.4 // indirect
-	github.com/facebookgo/stack v0.0.0-20160209184415-751773369052 // indirect
-	github.com/fvbommel/sortorder v1.0.2 // indirect
-	github.com/gliderlabs/ssh v0.3.3
-	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
-	github.com/gorilla/mux v1.8.0 // indirect
-	github.com/hashicorp/go-retryablehttp v0.7.0
-	github.com/kevinburke/ssh_config v1.1.0
-	github.com/libdns/gandi v1.0.2
-	github.com/libdns/libdns v0.2.1
-	github.com/moby/sys/mount v0.2.0 // indirect
-	github.com/opencontainers/image-spec v1.0.3-0.20211202193544-a5463b7f9c84 // indirect
-	github.com/sergi/go-diff v1.2.0 // indirect
-	github.com/spf13/cobra v1.3.0 // indirect
-	github.com/theupdateframework/notary v0.7.0 // indirect
-	github.com/urfave/cli v1.22.5
-	github.com/xanzy/ssh-agent v0.3.1 // indirect
-	github.com/xeipuuv/gojsonpointer v0.0.0-20190809123943-df4f5c81cb3b // indirect
-	golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838
-	golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27
-)

installer/compose.yml

@@ -2,7 +2,7 @@
 version: "3.8"
 
 services:
-  app:
+  abra_installer:
     image: "nginx:stable"
     configs:
       - source: abra_conf
@@ -20,14 +20,16 @@ services:
       labels:
         - "traefik.enable=true"
         - "traefik.http.services.abra-installer.loadbalancer.server.port=80"
-        - "traefik.http.routers.abra-installer.rule=Host(`install.abra.autonomic.zone`,`install.abra.coopcloud.tech`)"
+        - "traefik.http.routers.abra-installer.rule=Host(`install.abra.autonomic.zone`)"
         - "traefik.http.routers.abra-installer.entrypoints=web-secure"
         - "traefik.http.routers.abra-installer.tls.certresolver=production"
 
 configs:
   abra_installer:
+    name: abra_installer_v1
     file: installer
   abra_conf:
+    name: abra_conf_v1
     file: nginx.conf
 
 networks:

installer/installer

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+ABRA_VERSION="0.4.1"
+ABRA_SRC="https://git.autonomic.zone/coop-cloud/abra/raw/tag/$ABRA_VERSION/abra"
+
+function install_abra {
+  mkdir -p "$HOME/.local/bin"
+	curl "$ABRA_SRC" > "$HOME/.local/bin/abra"
+  chmod +x "$HOME/.local/bin/abra"
+  echo "abra installed to $HOME/.loca/bin/abra"
+}
+
+function run_installation {
+  install_abra
+}
+
+run_installation
+exit 0

installer/nginx.conf

@@ -1,6 +1,6 @@
 server {
   listen         80 default_server;
-  server_name    install.abra.autonomic.zone install.abra.coopcloud.tech;
+  server_name    install.abra.autonomic.zone;
 
   location / {
     root /var/www/abra-installer;

pkg/app/app.go

@@ -1,85 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/upstream/stack"
-	apiclient "github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-)
-
-// Get retrieves an app
-func Get(appName string) (config.App, error) {
-	files, err := config.LoadAppFiles("")
-	if err != nil {
-		return config.App{}, err
-	}
-
-	app, err := config.GetApp(files, appName)
-	if err != nil {
-		return config.App{}, err
-	}
-
-	logrus.Debugf("retrieved %s for %s", app, appName)
-
-	return app, nil
-}
-
-// deployedServiceSpec represents a deployed service of an app.
-type deployedServiceSpec struct {
-	Name    string
-	Version string
-}
-
-// VersionSpec represents a deployed app and associated metadata.
-type VersionSpec map[string]deployedServiceSpec
-
-// DeployedVersions lists metadata (e.g. versions) for deployed
-func DeployedVersions(ctx context.Context, cl *apiclient.Client, app config.App) (VersionSpec, bool, error) {
-	services, err := stack.GetStackServices(ctx, cl, app.StackName())
-	if err != nil {
-		return VersionSpec{}, false, err
-	}
-
-	appSpec := make(VersionSpec)
-	for _, service := range services {
-		serviceName := ParseServiceName(service.Spec.Name)
-		label := fmt.Sprintf("coop-cloud.%s.%s.version", app.StackName(), serviceName)
-		if deployLabel, ok := service.Spec.Labels[label]; ok {
-			version, _ := ParseVersionLabel(deployLabel)
-			appSpec[serviceName] = deployedServiceSpec{Name: serviceName, Version: version}
-		}
-	}
-
-	deployed := len(services) > 0
-
-	if deployed {
-		logrus.Debugf("detected %s as deployed versions of %s", appSpec, app.Name)
-	} else {
-		logrus.Debugf("detected %s as not deployed", app.Name)
-	}
-
-	return appSpec, len(services) > 0, nil
-}
-
-// ParseVersionLabel parses a $VERSION-$DIGEST app service label.
-func ParseVersionLabel(label string) (string, string) {
-	// versions may look like v4.2-abcd or v4.2-alpine-abcd
-	idx := strings.LastIndex(label, "-")
-	version := label[:idx]
-	digest := label[idx+1:]
-	logrus.Debugf("parsed %s as version from %s", version, label)
-	logrus.Debugf("parsed %s as digest from %s", digest, label)
-	return version, digest
-}
-
-// ParseServiceName parses a $STACK_NAME_$SERVICE_NAME service label.
-func ParseServiceName(label string) string {
-	idx := strings.LastIndex(label, "_")
-	serviceName := label[idx+1:]
-	logrus.Debugf("parsed %s as service name from %s", serviceName, label)
-	return serviceName
-}

pkg/autocomplete/autocomplete.go

@@ -1,63 +0,0 @@
-package autocomplete
-
-import (
-	"fmt"
-
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/recipe"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-// AppNameComplete copletes app names
-func AppNameComplete(c *cli.Context) {
-	appNames, err := config.GetAppNames()
-	if err != nil {
-		logrus.Warn(err)
-	}
-
-	if c.NArg() > 0 {
-		return
-	}
-
-	for _, a := range appNames {
-		fmt.Println(a)
-	}
-}
-
-// RecipeNameComplete completes recipe names
-func RecipeNameComplete(c *cli.Context) {
-	catl, err := recipe.ReadRecipeCatalogue()
-	if err != nil {
-		logrus.Warn(err)
-	}
-
-	if c.NArg() > 0 {
-		return
-	}
-
-	for name := range catl {
-		fmt.Println(name)
-	}
-}
-
-// SubcommandComplete completes subcommands.
-func SubcommandComplete(c *cli.Context) {
-	if c.NArg() > 0 {
-		return
-	}
-
-	subcmds := []string{
-		"app",
-		"autocomplete",
-		"catalogue",
-		"recipe",
-		"record",
-		"server",
-		"upgrade",
-	}
-
-	for _, cmd := range subcmds {
-		fmt.Println(cmd)
-	}
-}

pkg/client/client.go

@@ -1,65 +0,0 @@
-// Package client provides Docker client initiatialisation functions.
-package client
-
-import (
-	"net/http"
-	"os"
-	"time"
-
-	contextPkg "coopcloud.tech/abra/pkg/context"
-	commandconnPkg "coopcloud.tech/abra/pkg/upstream/commandconn"
-	"github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-)
-
-// New initiates a new Docker client.
-func New(contextName string) (*client.Client, error) {
-	var clientOpts []client.Opt
-
-	if contextName != "default" {
-		context, err := GetContext(contextName)
-		if err != nil {
-			return nil, err
-		}
-
-		ctxEndpoint, err := contextPkg.GetContextEndpoint(context)
-		if err != nil {
-			return nil, err
-		}
-
-		helper, err := commandconnPkg.NewConnectionHelper(ctxEndpoint)
-		if err != nil {
-			return nil, err
-		}
-
-		httpClient := &http.Client{
-			// No tls, no proxy
-			Transport: &http.Transport{
-				DialContext:     helper.Dialer,
-				IdleConnTimeout: 30 * time.Second,
-			},
-		}
-
-		clientOpts = append(clientOpts,
-			client.WithHTTPClient(httpClient),
-			client.WithHost(helper.Host),
-			client.WithDialContext(helper.Dialer),
-		)
-	}
-
-	version := os.Getenv("DOCKER_API_VERSION")
-	if version != "" {
-		clientOpts = append(clientOpts, client.WithVersion(version))
-	} else {
-		clientOpts = append(clientOpts, client.WithAPIVersionNegotiation())
-	}
-
-	cl, err := client.NewClientWithOpts(clientOpts...)
-	if err != nil {
-		return nil, err
-	}
-
-	logrus.Debugf("created client for %s", contextName)
-
-	return cl, nil
-}

pkg/client/context.go

@@ -1,91 +0,0 @@
-package client
-
-import (
-	"errors"
-	"fmt"
-
-	"coopcloud.tech/abra/pkg/context"
-	commandconnPkg "coopcloud.tech/abra/pkg/upstream/commandconn"
-	dConfig "github.com/docker/cli/cli/config"
-	"github.com/docker/cli/cli/context/docker"
-	contextStore "github.com/docker/cli/cli/context/store"
-	"github.com/sirupsen/logrus"
-)
-
-type Context = contextStore.Metadata
-
-func CreateContext(contextName string, user string, port string) error {
-	host := contextName
-	if user != "" {
-		host = fmt.Sprintf("%s@%s", user, host)
-	}
-	if port != "" {
-		host = fmt.Sprintf("%s:%s", host, port)
-	}
-	host = fmt.Sprintf("ssh://%s", host)
-	if err := createContext(contextName, host); err != nil {
-		return err
-	}
-	logrus.Debugf("created the %s context", contextName)
-	return nil
-}
-
-// createContext interacts with Docker Context to create a Docker context config
-func createContext(name string, host string) error {
-	s := context.NewDefaultDockerContextStore()
-	contextMetadata := contextStore.Metadata{
-		Endpoints: make(map[string]interface{}),
-		Name:      name,
-	}
-
-	contextTLSData := contextStore.ContextTLSData{
-		Endpoints: make(map[string]contextStore.EndpointTLSData),
-	}
-
-	dockerEP, dockerTLS, err := commandconnPkg.GetDockerEndpointMetadataAndTLS(host)
-	if err != nil {
-		return err
-	}
-
-	contextMetadata.Endpoints[docker.DockerEndpoint] = dockerEP
-	if dockerTLS != nil {
-		contextTLSData.Endpoints[docker.DockerEndpoint] = *dockerTLS
-	}
-
-	if err := s.CreateOrUpdate(contextMetadata); err != nil {
-		return err
-	}
-
-	if err := s.ResetTLSMaterial(name, &contextTLSData); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func DeleteContext(name string) error {
-	if name == "default" {
-		return errors.New("context 'default' cannot be removed")
-	}
-
-	if _, err := GetContext(name); err != nil {
-		return err
-	}
-
-	cfg := dConfig.LoadDefaultConfigFile(nil)
-	cfg.CurrentContext = ""
-	if err := cfg.Save(); err != nil {
-		return err
-	}
-
-	return context.NewDefaultDockerContextStore().Remove(name)
-}
-
-func GetContext(contextName string) (contextStore.Metadata, error) {
-	ctx, err := context.NewDefaultDockerContextStore().GetMetadata(contextName)
-	if err != nil {
-		return contextStore.Metadata{}, err
-	}
-
-	return ctx, nil
-}

pkg/client/registry.go

@@ -1,57 +0,0 @@
-package client
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/containers/image/docker"
-	"github.com/containers/image/types"
-	"github.com/docker/distribution/reference"
-	"github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-)
-
-// GetRegistryTags retrieves all tags of an image from a container registry.
-func GetRegistryTags(img reference.Named) ([]string, error) {
-	var tags []string
-
-	ref, err := docker.ParseReference(fmt.Sprintf("//%s", img))
-	if err != nil {
-		return tags, fmt.Errorf("failed to parse image %s, saw: %s", img, err.Error())
-	}
-
-	ctx := context.Background()
-	tags, err = docker.GetRepositoryTags(ctx, &types.SystemContext{}, ref)
-	if err != nil {
-		return tags, err
-	}
-
-	return tags, nil
-}
-
-// GetTagDigest retrieves an image digest from a container registry.
-func GetTagDigest(cl *client.Client, image reference.Named) (string, error) {
-	target := fmt.Sprintf("//%s", reference.Path(image))
-
-	ref, err := docker.ParseReference(target)
-	if err != nil {
-		return "", fmt.Errorf("failed to parse image %s, saw: %s", image, err.Error())
-	}
-
-	ctx := context.Background()
-	img, err := ref.NewImage(ctx, nil)
-	if err != nil {
-		logrus.Debugf("failed to query remote registry for %s, saw: %s", image, err.Error())
-		return "", fmt.Errorf("unable to read digest for %s", image)
-	}
-	defer img.Close()
-
-	digest := img.ConfigInfo().Digest.String()
-
-	if digest == "" {
-		return digest, fmt.Errorf("unable to read digest for %s", image)
-	}
-
-	return strings.Split(digest, ":")[1][:7], nil
-}

pkg/client/secret.go

@@ -1,25 +0,0 @@
-package client
-
-import (
-	"context"
-
-	"github.com/docker/docker/api/types/swarm"
-)
-
-func StoreSecret(secretName, secretValue, server string) error {
-	cl, err := New(server)
-	if err != nil {
-		return err
-	}
-
-	ctx := context.Background()
-	ann := swarm.Annotations{Name: secretName}
-	spec := swarm.SecretSpec{Annotations: ann, Data: []byte(secretValue)}
-
-	// We don't bother with the secret IDs for now
-	if _, err := cl.SecretCreate(ctx, spec); err != nil {
-		return err
-	}
-
-	return nil
-}

pkg/client/volumes.go

@@ -1,49 +0,0 @@
-package client
-
-import (
-	"context"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-)
-
-func GetVolumes(ctx context.Context, server string, fs filters.Args) ([]*types.Volume, error) {
-	cl, err := New(server)
-	if err != nil {
-		return nil, err
-	}
-
-	volumeListOKBody, err := cl.VolumeList(ctx, fs)
-	volumeList := volumeListOKBody.Volumes
-	if err != nil {
-		return volumeList, err
-	}
-
-	return volumeList, nil
-}
-
-func GetVolumeNames(volumes []*types.Volume) []string {
-	var volumeNames []string
-
-	for _, vol := range volumes {
-		volumeNames = append(volumeNames, vol.Name)
-	}
-
-	return volumeNames
-}
-
-func RemoveVolumes(ctx context.Context, server string, volumeNames []string, force bool) error {
-	cl, err := New(server)
-	if err != nil {
-		return err
-	}
-
-	for _, volName := range volumeNames {
-		err := cl.VolumeRemove(ctx, volName, force)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

pkg/compose/compose.go

@@ -1,158 +0,0 @@
-package compose
-
-import (
-	"fmt"
-	"io/ioutil"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/upstream/stack"
-	loader "coopcloud.tech/abra/pkg/upstream/stack"
-	composetypes "github.com/docker/cli/cli/compose/types"
-	"github.com/docker/distribution/reference"
-	"github.com/sirupsen/logrus"
-)
-
-// UpdateTag updates an image tag in-place on file system local compose files.
-func UpdateTag(pattern, image, tag, recipeName string) (bool, error) {
-	composeFiles, err := filepath.Glob(pattern)
-	if err != nil {
-		return false, err
-	}
-
-	logrus.Debugf("considering %s config(s) for tag update", strings.Join(composeFiles, ", "))
-
-	for _, composeFile := range composeFiles {
-		opts := stack.Deploy{Composefiles: []string{composeFile}}
-
-		envSamplePath := path.Join(config.RECIPES_DIR, recipeName, ".env.sample")
-		sampleEnv, err := config.ReadEnv(envSamplePath)
-		if err != nil {
-			return false, err
-		}
-
-		compose, err := loader.LoadComposefile(opts, sampleEnv)
-		if err != nil {
-			return false, err
-		}
-
-		for _, service := range compose.Services {
-			if service.Image == "" {
-				continue // may be a compose.$optional.yml file
-			}
-
-			img, _ := reference.ParseNormalizedNamed(service.Image)
-			if err != nil {
-				return false, err
-			}
-
-			var composeTag string
-			switch img.(type) {
-			case reference.NamedTagged:
-				composeTag = img.(reference.NamedTagged).Tag()
-			default:
-				logrus.Debugf("unable to parse %s, skipping", img)
-				continue
-			}
-
-			composeImage := formatter.StripTagMeta(reference.Path(img))
-
-			logrus.Debugf("parsed %s from %s", composeTag, service.Image)
-
-			if image == composeImage {
-				bytes, err := ioutil.ReadFile(composeFile)
-				if err != nil {
-					return false, err
-				}
-
-				old := fmt.Sprintf("%s:%s", composeImage, composeTag)
-				new := fmt.Sprintf("%s:%s", composeImage, tag)
-				replacedBytes := strings.Replace(string(bytes), old, new, -1)
-
-				logrus.Debugf("updating %s to %s in %s", old, new, compose.Filename)
-
-				if err := ioutil.WriteFile(compose.Filename, []byte(replacedBytes), 0764); err != nil {
-					return false, err
-				}
-			}
-		}
-	}
-
-	return false, nil
-}
-
-// UpdateLabel updates a label in-place on file system local compose files.
-func UpdateLabel(pattern, serviceName, label, recipeName string) error {
-	composeFiles, err := filepath.Glob(pattern)
-	if err != nil {
-		return err
-	}
-
-	logrus.Debugf("considering %s config(s) for label update", strings.Join(composeFiles, ", "))
-
-	for _, composeFile := range composeFiles {
-		opts := stack.Deploy{Composefiles: []string{composeFile}}
-
-		envSamplePath := path.Join(config.RECIPES_DIR, recipeName, ".env.sample")
-		sampleEnv, err := config.ReadEnv(envSamplePath)
-		if err != nil {
-			return err
-		}
-
-		compose, err := loader.LoadComposefile(opts, sampleEnv)
-		if err != nil {
-			return err
-		}
-
-		serviceExists := false
-		var service composetypes.ServiceConfig
-		for _, s := range compose.Services {
-			if s.Name == serviceName {
-				service = s
-				serviceExists = true
-			}
-		}
-
-		if !serviceExists {
-			continue
-		}
-
-		discovered := false
-		for oldLabel, value := range service.Deploy.Labels {
-			if strings.HasPrefix(oldLabel, "coop-cloud") {
-				discovered = true
-
-				bytes, err := ioutil.ReadFile(composeFile)
-				if err != nil {
-					return err
-				}
-
-				old := fmt.Sprintf("coop-cloud.${STACK_NAME}.version=%s", value)
-				replacedBytes := strings.Replace(string(bytes), old, label, -1)
-
-				if old == label {
-					logrus.Warnf("%s is already set, nothing to do?", label)
-					return nil
-				}
-
-				logrus.Debugf("updating %s to %s in %s", old, label, compose.Filename)
-
-				if err := ioutil.WriteFile(compose.Filename, []byte(replacedBytes), 0764); err != nil {
-					return err
-				}
-
-				logrus.Infof("synced label %s to service %s", label, serviceName)
-			}
-		}
-
-		if !discovered {
-			logrus.Warn("no existing label found, automagic insertion not supported yet")
-			logrus.Fatalf("add '- \"%s\"' manually to the 'app' service in %s", label, composeFile)
-		}
-	}
-
-	return nil
-}

pkg/config/app.go

@@ -1,440 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"html/template"
-	"io/ioutil"
-	"os"
-	"path"
-	"strings"
-
-	"coopcloud.tech/abra/pkg/formatter"
-	"coopcloud.tech/abra/pkg/upstream/convert"
-	loader "coopcloud.tech/abra/pkg/upstream/stack"
-	stack "coopcloud.tech/abra/pkg/upstream/stack"
-	composetypes "github.com/docker/cli/cli/compose/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/sirupsen/logrus"
-)
-
-// Type aliases to make code hints easier to understand
-
-// AppEnv is a map of the values in an apps env config
-type AppEnv = map[string]string
-
-// AppName is AppName
-type AppName = string
-
-// AppFile represents app env files on disk without reading the contents
-type AppFile struct {
-	Path   string
-	Server string
-}
-
-// AppFiles is a slice of appfiles
-type AppFiles map[AppName]AppFile
-
-// App reprents an app with its env file read into memory
-type App struct {
-	Name   AppName
-	Recipe string
-	Domain string
-	Env    AppEnv
-	Server string
-	Path   string
-}
-
-// StackName gets what the docker safe stack name is for the app. This should
-// not not shown to the user, use a.Name for that. Give the output of this
-// command to Docker only.
-func (a App) StackName() string {
-	if _, exists := a.Env["STACK_NAME"]; exists {
-		return a.Env["STACK_NAME"]
-	}
-
-	stackName := SanitiseAppName(a.Name)
-
-	if len(stackName) > 45 {
-		logrus.Debugf("trimming %s to %s to avoid runtime limits", stackName, stackName[:45])
-		stackName = stackName[:45]
-	}
-
-	a.Env["STACK_NAME"] = stackName
-
-	return stackName
-}
-
-// Filters retrieves exact app filters for querying the container runtime. Due
-// to upstream issues, filtering works different depending on what you're
-// querying. So, for example, secrets don't work with regex! The caller needs
-// to implement their own validation that the right secrets are matched. In
-// order to handle these cases, we provide the `appendServiceNames` /
-// `exactMatch` modifiers.
-func (a App) Filters(appendServiceNames, exactMatch bool) (filters.Args, error) {
-	filters := filters.NewArgs()
-
-	composeFiles, err := GetAppComposeFiles(a.Recipe, a.Env)
-	if err != nil {
-		return filters, err
-	}
-
-	opts := stack.Deploy{Composefiles: composeFiles}
-	compose, err := GetAppComposeConfig(a.Recipe, opts, a.Env)
-	if err != nil {
-		return filters, err
-	}
-
-	for _, service := range compose.Services {
-		var filter string
-
-		if appendServiceNames {
-			if exactMatch {
-				filter = fmt.Sprintf("^%s_%s", a.StackName(), service.Name)
-			} else {
-				filter = fmt.Sprintf("%s_%s", a.StackName(), service.Name)
-			}
-		} else {
-			if exactMatch {
-				filter = fmt.Sprintf("^%s", a.StackName())
-			} else {
-				filter = fmt.Sprintf("%s", a.StackName())
-			}
-		}
-
-		filters.Add("name", filter)
-	}
-
-	return filters, nil
-}
-
-// ByServer sort a slice of Apps
-type ByServer []App
-
-func (a ByServer) Len() int      { return len(a) }
-func (a ByServer) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a ByServer) Less(i, j int) bool {
-	return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
-}
-
-// ByServerAndRecipe sort a slice of Apps
-type ByServerAndRecipe []App
-
-func (a ByServerAndRecipe) Len() int      { return len(a) }
-func (a ByServerAndRecipe) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a ByServerAndRecipe) Less(i, j int) bool {
-	if a[i].Server == a[j].Server {
-		return strings.ToLower(a[i].Recipe) < strings.ToLower(a[j].Recipe)
-	}
-	return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
-}
-
-// ByRecipe sort a slice of Apps
-type ByRecipe []App
-
-func (a ByRecipe) Len() int      { return len(a) }
-func (a ByRecipe) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a ByRecipe) Less(i, j int) bool {
-	return strings.ToLower(a[i].Recipe) < strings.ToLower(a[j].Recipe)
-}
-
-// ByName sort a slice of Apps
-type ByName []App
-
-func (a ByName) Len() int      { return len(a) }
-func (a ByName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a ByName) Less(i, j int) bool {
-	return strings.ToLower(a[i].Name) < strings.ToLower(a[j].Name)
-}
-
-func readAppEnvFile(appFile AppFile, name AppName) (App, error) {
-	env, err := ReadEnv(appFile.Path)
-	if err != nil {
-		return App{}, fmt.Errorf("env file for %s couldn't be read: %s", name, err.Error())
-	}
-
-	logrus.Debugf("read env %s from %s", env, appFile.Path)
-
-	app, err := newApp(env, name, appFile)
-	if err != nil {
-		return App{}, fmt.Errorf("env file for %s has issues: %s", name, err.Error())
-	}
-
-	return app, nil
-}
-
-// newApp creates new App object
-func newApp(env AppEnv, name string, appFile AppFile) (App, error) {
-	domain := env["DOMAIN"]
-
-	recipe, exists := env["RECIPE"]
-	if !exists {
-		recipe, exists = env["TYPE"]
-		if !exists {
-			return App{}, fmt.Errorf("%s is missing the RECIPE env var", name)
-		}
-	}
-
-	return App{
-		Name:   name,
-		Domain: domain,
-		Recipe: recipe,
-		Env:    env,
-		Server: appFile.Server,
-		Path:   appFile.Path,
-	}, nil
-}
-
-// LoadAppFiles gets all app files for a given set of servers or all servers
-func LoadAppFiles(servers ...string) (AppFiles, error) {
-	appFiles := make(AppFiles)
-	if len(servers) == 1 {
-		if servers[0] == "" {
-			// Empty servers flag, one string will always be passed
-			var err error
-			servers, err = GetAllFoldersInDirectory(SERVERS_DIR)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	logrus.Debugf("collecting metadata from %v servers: %s", len(servers), strings.Join(servers, ", "))
-
-	for _, server := range servers {
-		serverDir := path.Join(SERVERS_DIR, server)
-		files, err := getAllFilesInDirectory(serverDir)
-		if err != nil {
-			return nil, fmt.Errorf("server %s doesn't exist? Run \"abra server ls\" to check", server)
-		}
-		for _, file := range files {
-			appName := strings.TrimSuffix(file.Name(), ".env")
-			appFilePath := path.Join(SERVERS_DIR, server, file.Name())
-			appFiles[appName] = AppFile{
-				Path:   appFilePath,
-				Server: server,
-			}
-		}
-	}
-	return appFiles, nil
-}
-
-// GetApp loads an apps settings, reading it from file, in preparation to use it
-//
-// ONLY use when ready to use the env file to keep IO down
-func GetApp(apps AppFiles, name AppName) (App, error) {
-	appFile, exists := apps[name]
-	if !exists {
-		return App{}, fmt.Errorf("cannot find app with name %s", name)
-	}
-
-	app, err := readAppEnvFile(appFile, name)
-	if err != nil {
-		return App{}, err
-	}
-
-	return app, nil
-}
-
-// GetApps returns a slice of Apps with their env files read from a given slice of AppFiles
-func GetApps(appFiles AppFiles) ([]App, error) {
-	var apps []App
-
-	for name := range appFiles {
-		app, err := GetApp(appFiles, name)
-		if err != nil {
-			return nil, err
-		}
-		apps = append(apps, app)
-	}
-
-	return apps, nil
-}
-
-// GetAppServiceNames retrieves a list of app service names.
-func GetAppServiceNames(appName string) ([]string, error) {
-	var serviceNames []string
-
-	appFiles, err := LoadAppFiles("")
-	if err != nil {
-		return serviceNames, err
-	}
-
-	app, err := GetApp(appFiles, appName)
-	if err != nil {
-		return serviceNames, err
-	}
-
-	composeFiles, err := GetAppComposeFiles(app.Recipe, app.Env)
-	if err != nil {
-		return serviceNames, err
-	}
-
-	opts := stack.Deploy{Composefiles: composeFiles}
-	compose, err := GetAppComposeConfig(app.Recipe, opts, app.Env)
-	if err != nil {
-		return serviceNames, err
-	}
-
-	for _, service := range compose.Services {
-		serviceNames = append(serviceNames, service.Name)
-	}
-
-	return serviceNames, nil
-}
-
-// GetAppNames retrieves a list of app names.
-func GetAppNames() ([]string, error) {
-	var appNames []string
-
-	appFiles, err := LoadAppFiles("")
-	if err != nil {
-		return appNames, err
-	}
-
-	apps, err := GetApps(appFiles)
-	if err != nil {
-		return appNames, err
-	}
-
-	for _, app := range apps {
-		appNames = append(appNames, app.Name)
-	}
-
-	return appNames, nil
-}
-
-// TemplateAppEnvSample copies the example env file for the app into the users env files
-func TemplateAppEnvSample(recipeName, appName, server, domain string) error {
-	envSamplePath := path.Join(RECIPES_DIR, recipeName, ".env.sample")
-	envSample, err := ioutil.ReadFile(envSamplePath)
-	if err != nil {
-		return err
-	}
-
-	appEnvPath := path.Join(ABRA_DIR, "servers", server, fmt.Sprintf("%s.env", appName))
-	if _, err := os.Stat(appEnvPath); os.IsExist(err) {
-		return fmt.Errorf("%s already exists?", appEnvPath)
-	}
-
-	err = ioutil.WriteFile(appEnvPath, envSample, 0664)
-	if err != nil {
-		return err
-	}
-
-	file, err := os.OpenFile(appEnvPath, os.O_RDWR, 0664)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	tpl, err := template.ParseFiles(appEnvPath)
-	if err != nil {
-		return err
-	}
-
-	type templateVars struct {
-		Name   string
-		Domain string
-	}
-
-	tvars := templateVars{Name: recipeName, Domain: domain}
-	if err := tpl.Execute(file, tvars); err != nil {
-		return err
-	}
-
-	logrus.Debugf("copied & templated %s to %s", envSamplePath, appEnvPath)
-
-	return nil
-}
-
-// SanitiseAppName makes a app name usable with Docker by replacing illegal characters
-func SanitiseAppName(name string) string {
-	return strings.ReplaceAll(name, ".", "_")
-}
-
-// GetAppStatuses queries servers to check the deployment status of given apps
-func GetAppStatuses(appFiles AppFiles) (map[string]map[string]string, error) {
-	statuses := make(map[string]map[string]string)
-
-	var unique []string
-	servers := make(map[string]struct{})
-	for _, appFile := range appFiles {
-		if _, ok := servers[appFile.Server]; !ok {
-			servers[appFile.Server] = struct{}{}
-			unique = append(unique, appFile.Server)
-		}
-	}
-
-	bar := formatter.CreateProgressbar(len(servers), "querying remote servers...")
-	ch := make(chan stack.StackStatus, len(servers))
-	for server := range servers {
-		go func(s string) {
-			ch <- stack.GetAllDeployedServices(s)
-			bar.Add(1)
-		}(server)
-	}
-
-	for range servers {
-		status := <-ch
-		for _, service := range status.Services {
-			result := make(map[string]string)
-			name := service.Spec.Labels[convert.LabelNamespace]
-
-			if _, ok := statuses[name]; !ok {
-				result["status"] = "deployed"
-			}
-
-			labelKey := fmt.Sprintf("coop-cloud.%s.version", name)
-			if version, ok := service.Spec.Labels[labelKey]; ok {
-				result["version"] = version
-			} else {
-				continue
-			}
-
-			statuses[name] = result
-		}
-	}
-
-	logrus.Debugf("retrieved app statuses: %s", statuses)
-
-	return statuses, nil
-}
-
-// GetAppComposeFiles gets the list of compose files for an app which should be
-// merged into a composetypes.Config while respecting the COMPOSE_FILE env var.
-func GetAppComposeFiles(recipe string, appEnv AppEnv) ([]string, error) {
-	var composeFiles []string
-
-	if _, ok := appEnv["COMPOSE_FILE"]; !ok {
-		logrus.Debug("no COMPOSE_FILE detected, loading compose.yml")
-		path := fmt.Sprintf("%s/%s/compose.yml", RECIPES_DIR, recipe)
-		composeFiles = append(composeFiles, path)
-		return composeFiles, nil
-	}
-
-	composeFileEnvVar := appEnv["COMPOSE_FILE"]
-	envVars := strings.Split(composeFileEnvVar, ":")
-	logrus.Debugf("COMPOSE_FILE detected (%s), loading %s", composeFileEnvVar, strings.Join(envVars, ", "))
-	for _, file := range strings.Split(composeFileEnvVar, ":") {
-		path := fmt.Sprintf("%s/%s/%s", RECIPES_DIR, recipe, file)
-		composeFiles = append(composeFiles, path)
-	}
-
-	logrus.Debugf("retrieved %s configs for %s", strings.Join(composeFiles, ", "), recipe)
-
-	return composeFiles, nil
-}
-
-// GetAppComposeConfig retrieves a compose specification for a recipe. This
-// specification is the result of a merge of all the compose.**.yml files in
-// the recipe repository.
-func GetAppComposeConfig(recipe string, opts stack.Deploy, appEnv AppEnv) (*composetypes.Config, error) {
-	compose, err := loader.LoadComposefile(opts, appEnv)
-	if err != nil {
-		return &composetypes.Config{}, err
-	}
-
-	logrus.Debugf("retrieved %s for %s", compose.Filename, recipe)
-
-	return compose, nil
-}

pkg/config/app_test.go

@@ -1,36 +0,0 @@
-package config
-
-import (
-	"reflect"
-	"testing"
-)
-
-func TestNewApp(t *testing.T) {
-	app, err := newApp(expectedAppEnv, appName, expectedAppFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(app, expectedApp) {
-		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, expectedApp)
-	}
-}
-
-func TestReadAppEnvFile(t *testing.T) {
-	app, err := readAppEnvFile(expectedAppFile, appName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(app, expectedApp) {
-		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, expectedApp)
-	}
-}
-
-func TestGetApp(t *testing.T) {
-	app, err := GetApp(expectedAppFiles, appName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(app, expectedApp) {
-		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, expectedApp)
-	}
-}

pkg/config/env.go

@@ -1,159 +0,0 @@
-package config
-
-import (
-	"bufio"
-	"fmt"
-	"io/fs"
-	"io/ioutil"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"github.com/Autonomic-Cooperative/godotenv"
-	"github.com/sirupsen/logrus"
-)
-
-var ABRA_DIR = os.ExpandEnv("$HOME/.abra")
-var SERVERS_DIR = path.Join(ABRA_DIR, "servers")
-var RECIPES_DIR = path.Join(ABRA_DIR, "recipes")
-var VENDOR_DIR = path.Join(ABRA_DIR, "vendor")
-var RECIPES_JSON = path.Join(ABRA_DIR, "catalogue", "recipes.json")
-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"
-
-// GetServers retrieves all servers.
-func GetServers() ([]string, error) {
-	var servers []string
-
-	servers, err := GetAllFoldersInDirectory(SERVERS_DIR)
-	if err != nil {
-		return servers, err
-	}
-
-	logrus.Debugf("retrieved %v servers: %s", len(servers), servers)
-
-	return servers, nil
-}
-
-// ReadEnv loads an app envivornment into a map.
-func ReadEnv(filePath string) (AppEnv, error) {
-	var envFile AppEnv
-
-	envFile, err := godotenv.Read(filePath)
-	if err != nil {
-		return nil, err
-	}
-
-	logrus.Debugf("read %s from %s", envFile, filePath)
-
-	return envFile, nil
-}
-
-// ReadServerNames retrieves all server names.
-func ReadServerNames() ([]string, error) {
-	serverNames, err := GetAllFoldersInDirectory(SERVERS_DIR)
-
-	if err != nil {
-		return nil, err
-	}
-
-	logrus.Debugf("read %s from %s", strings.Join(serverNames, ","), SERVERS_DIR)
-
-	return serverNames, nil
-}
-
-// getAllFilesInDirectory returns filenames of all files in directory
-func getAllFilesInDirectory(directory string) ([]fs.FileInfo, error) {
-	var realFiles []fs.FileInfo
-
-	files, err := ioutil.ReadDir(directory)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, file := range files {
-		// Follow any symlinks
-		filePath := path.Join(directory, file.Name())
-
-		if filepath.Ext(strings.TrimSpace(filePath)) != ".env" {
-			continue
-		}
-
-		realPath, err := filepath.EvalSymlinks(filePath)
-		if err != nil {
-			logrus.Warningf("broken symlink in your abra config folders: %s", filePath)
-		} else {
-			realFile, err := os.Stat(realPath)
-			if err != nil {
-				return nil, err
-			}
-			if !realFile.IsDir() {
-				realFiles = append(realFiles, file)
-			}
-		}
-	}
-
-	return realFiles, nil
-}
-
-// GetAllFoldersInDirectory returns both folder and symlink paths
-func GetAllFoldersInDirectory(directory string) ([]string, error) {
-	var folders []string
-
-	files, err := ioutil.ReadDir(directory)
-	if err != nil {
-		return nil, err
-	}
-	if len(files) == 0 {
-		return nil, fmt.Errorf("directory is empty: %s", directory)
-	}
-
-	for _, file := range files {
-		// Check if file is directory or symlink
-		if file.IsDir() || file.Mode()&fs.ModeSymlink != 0 {
-			filePath := path.Join(directory, file.Name())
-			realDir, err := filepath.EvalSymlinks(filePath)
-			if err != nil {
-				logrus.Warningf("broken symlink in your abra config folders: %s", filePath)
-			} else if stat, err := os.Stat(realDir); err == nil && stat.IsDir() {
-				// path is a directory
-				folders = append(folders, file.Name())
-			}
-		}
-	}
-
-	return folders, nil
-}
-
-// ReadAbraShEnvVars reads env vars from an abra.sh recipe file.
-func ReadAbraShEnvVars(abraSh string) (map[string]string, error) {
-	envVars := make(map[string]string)
-
-	file, err := os.Open(abraSh)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return envVars, nil
-		}
-		return envVars, err
-	}
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := scanner.Text()
-		if strings.Contains(line, "export") {
-			splitVals := strings.Split(line, "export ")
-			envVarDef := splitVals[len(splitVals)-1]
-			keyVal := strings.Split(envVarDef, "=")
-			if len(keyVal) != 2 {
-				return envVars, fmt.Errorf("couldn't parse %s", line)
-			}
-			envVars[keyVal[0]] = keyVal[1]
-		}
-	}
-
-	logrus.Debugf("read %s from %s", envVars, abraSh)
-
-	return envVars, nil
-}

pkg/config/env_test.go

@@ -1,84 +0,0 @@
-package config
-
-import (
-	"os"
-	"path"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-var testFolder = os.ExpandEnv("$PWD/../../tests/resources/test_folder")
-var validAbraConf = os.ExpandEnv("$PWD/../../tests/resources/valid_abra_config")
-
-// make sure these are in alphabetical order
-var tFolders = []string{"folder1", "folder2"}
-var tFiles = []string{"bar.env", "foo.env"}
-
-var appName = "ecloud"
-var serverName = "evil.corp"
-
-var expectedAppEnv = AppEnv{
-	"DOMAIN": "ecloud.evil.corp",
-	"RECIPE": "ecloud",
-}
-
-var expectedApp = App{
-	Name:   appName,
-	Recipe: expectedAppEnv["RECIPE"],
-	Domain: expectedAppEnv["DOMAIN"],
-	Env:    expectedAppEnv,
-	Path:   expectedAppFile.Path,
-	Server: expectedAppFile.Server,
-}
-
-var expectedAppFile = AppFile{
-	Path:   path.Join(validAbraConf, "servers", serverName, appName+".env"),
-	Server: serverName,
-}
-
-var expectedAppFiles = map[string]AppFile{
-	appName: expectedAppFile,
-}
-
-// var expectedServerNames = []string{"evil.corp"}
-
-func TestGetAllFoldersInDirectory(t *testing.T) {
-	folders, err := GetAllFoldersInDirectory(testFolder)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(folders, tFolders) {
-		t.Fatalf("did not get expected folders. Expected: (%s), Got: (%s)", strings.Join(tFolders, ","), strings.Join(folders, ","))
-	}
-}
-
-func TestGetAllFilesInDirectory(t *testing.T) {
-	files, err := getAllFilesInDirectory(testFolder)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var fileNames []string
-	for _, file := range files {
-		fileNames = append(fileNames, file.Name())
-	}
-	if !reflect.DeepEqual(fileNames, tFiles) {
-		t.Fatalf("did not get expected files. Expected: (%s), Got: (%s)", strings.Join(tFiles, ","), strings.Join(fileNames, ","))
-	}
-}
-
-func TestReadEnv(t *testing.T) {
-	env, err := ReadEnv(expectedAppFile.Path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(env, expectedAppEnv) {
-		t.Fatalf(
-			"did not get expected application settings. Expected: DOMAIN=%s RECIPE=%s; Got: DOMAIN=%s RECIPE=%s",
-			expectedAppEnv["DOMAIN"],
-			expectedAppEnv["RECIPE"],
-			env["DOMAIN"],
-			env["RECIPE"],
-		)
-	}
-}

pkg/container/container.go

@@ -1,70 +0,0 @@
-package container
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"coopcloud.tech/abra/pkg/formatter"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-)
-
-// GetContainer retrieves a container. If noInput is false and the retrievd
-// count of containers does not match 1, then a prompt is presented to let the
-// user choose. A count of 0 is handled gracefully.
-func GetContainer(c context.Context, cl *client.Client, filters filters.Args, noInput bool) (types.Container, error) {
-	containerOpts := types.ContainerListOptions{Filters: filters}
-	containers, err := cl.ContainerList(c, containerOpts)
-	if err != nil {
-		return types.Container{}, err
-	}
-
-	if len(containers) == 0 {
-		filter := filters.Get("name")[0]
-		return types.Container{}, fmt.Errorf("no containers matching the %v filter found?", filter)
-	}
-
-	if len(containers) != 1 {
-		var containersRaw []string
-		for _, container := range containers {
-			containerName := strings.Join(container.Names, " ")
-			trimmed := strings.TrimPrefix(containerName, "/")
-			created := formatter.HumanDuration(container.Created)
-			containersRaw = append(containersRaw, fmt.Sprintf("%s (created %v)", trimmed, created))
-		}
-
-		if noInput {
-			err := fmt.Errorf("expected 1 container but found %v: %s", len(containers), strings.Join(containersRaw, " "))
-			return types.Container{}, err
-		}
-
-		logrus.Warnf("ambiguous container list received, prompting for input")
-
-		var response string
-		prompt := &survey.Select{
-			Message: "which container are you looking for?",
-			Options: containersRaw,
-		}
-
-		if err := survey.AskOne(prompt, &response); err != nil {
-			return types.Container{}, err
-		}
-
-		chosenContainer := strings.TrimSpace(strings.Split(response, " ")[0])
-		for _, container := range containers {
-			containerName := strings.TrimSpace(strings.Join(container.Names, " "))
-			trimmed := strings.TrimPrefix(containerName, "/")
-			if trimmed == chosenContainer {
-				return container, nil
-			}
-		}
-
-		logrus.Panic("failed to match chosen container")
-	}
-
-	return containers[0], nil
-}

pkg/context/context.go

@@ -1,44 +0,0 @@
-package context
-
-import (
-	"errors"
-
-	"github.com/docker/cli/cli/command"
-	dConfig "github.com/docker/cli/cli/config"
-	"github.com/docker/cli/cli/context"
-	contextStore "github.com/docker/cli/cli/context/store"
-	cliflags "github.com/docker/cli/cli/flags"
-	"github.com/moby/term"
-)
-
-func NewDefaultDockerContextStore() *command.ContextStoreWithDefault {
-	_, _, stderr := term.StdStreams()
-	dockerConfig := dConfig.LoadDefaultConfigFile(stderr)
-	contextDir := dConfig.ContextStoreDir()
-	storeConfig := command.DefaultContextStoreConfig()
-	store := newContextStore(contextDir, storeConfig)
-
-	opts := &cliflags.CommonOptions{Context: "default"}
-
-	dockerContextStore := &command.ContextStoreWithDefault{
-		Store: store,
-		Resolver: func() (*command.DefaultContext, error) {
-			return command.ResolveDefaultContext(opts, dockerConfig, storeConfig, stderr)
-		},
-	}
-
-	return dockerContextStore
-}
-
-func GetContextEndpoint(ctx contextStore.Metadata) (string, error) {
-	endpointmeta, ok := ctx.Endpoints["docker"].(context.EndpointMetaBase)
-	if !ok {
-		err := errors.New("context lacks Docker endpoint")
-		return "", err
-	}
-	return endpointmeta.Host, nil
-}
-
-func newContextStore(dir string, config contextStore.Config) contextStore.Store {
-	return contextStore.New(dir, config)
-}

pkg/dns/common.go

@@ -1,103 +0,0 @@
-package dns
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"os"
-	"time"
-
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/sirupsen/logrus"
-)
-
-// NewToken constructs a new DNS provider token.
-func NewToken(provider, providerTokenEnvVar string) (string, error) {
-	if token, present := os.LookupEnv(providerTokenEnvVar); present {
-		return token, nil
-	}
-
-	logrus.Debugf("no %s in environment, asking via stdin", providerTokenEnvVar)
-
-	var token string
-	prompt := &survey.Input{
-		Message: fmt.Sprintf("%s API token?", provider),
-	}
-	if err := survey.AskOne(prompt, &token); err != nil {
-		return "", err
-	}
-
-	return token, nil
-}
-
-// EnsureIPv4 ensures that an ipv4 address is set for a domain name
-func EnsureIPv4(domainName string) (string, error) {
-	var ipv4 string
-
-	// comrade librehosters DNS resolver -> https://www.privacy-handbuch.de/handbuch_93d.htm
-	freifunkDNS := "5.1.66.255:53"
-
-	resolver := &net.Resolver{
-		PreferGo: false,
-		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
-			d := net.Dialer{
-				Timeout: time.Millisecond * time.Duration(10000),
-			}
-			return d.DialContext(ctx, "udp", freifunkDNS)
-		},
-	}
-
-	ctx := context.Background()
-	ips, err := resolver.LookupIPAddr(ctx, domainName)
-	if err != nil {
-		return ipv4, err
-	}
-
-	if len(ips) == 0 {
-		return ipv4, fmt.Errorf("unable to retrieve ipv4 address for %s", domainName)
-	}
-
-	ipv4 = ips[0].IP.To4().String()
-	logrus.Debugf("%s points to %s (resolver: %s)", domainName, ipv4, freifunkDNS)
-
-	return ipv4, nil
-}
-
-// EnsureDomainsResolveSameIPv4 ensures that domains resolve to the same ipv4 address
-func EnsureDomainsResolveSameIPv4(domainName, server string) (string, error) {
-	var ipv4 string
-
-	domainIPv4, err := EnsureIPv4(domainName)
-	if err != nil {
-		return ipv4, err
-	}
-
-	if domainIPv4 == "" {
-		return ipv4, fmt.Errorf("cannot resolve ipv4 for %s?", domainName)
-	}
-
-	serverIPv4, err := EnsureIPv4(server)
-	if err != nil {
-		return ipv4, err
-	}
-
-	if serverIPv4 == "" {
-		return ipv4, fmt.Errorf("cannot resolve ipv4 for %s?", server)
-	}
-
-	if domainIPv4 != serverIPv4 {
-		err := "app domain %s (%s) does not appear to resolve to app server %s (%s)?"
-		return ipv4, fmt.Errorf(err, domainName, domainIPv4, server, serverIPv4)
-	}
-
-	return ipv4, nil
-}
-
-// GetTTL parses a ttl string into a duration
-func GetTTL(ttl string) (time.Duration, error) {
-	val, err := time.ParseDuration(ttl)
-	if err != nil {
-		return val, err
-	}
-	return val, nil
-}

pkg/dns/gandi/gandi.go

@@ -1,15 +0,0 @@
-package gandi
-
-import (
-	"coopcloud.tech/abra/pkg/dns"
-	"github.com/libdns/gandi"
-)
-
-// New constructs a new DNs provider.
-func New() (gandi.Provider, error) {
-	token, err := dns.NewToken("Gandi", "GANDI_TOKEN")
-	if err != nil {
-		return gandi.Provider{}, err
-	}
-	return gandi.Provider{APIToken: token}, nil
-}

pkg/formatter/formatter.go

@@ -1,71 +0,0 @@
-package formatter
-
-import (
-	"os"
-	"strings"
-	"time"
-
-	"github.com/docker/go-units"
-	"github.com/olekukonko/tablewriter"
-	"github.com/schollz/progressbar/v3"
-	"github.com/sirupsen/logrus"
-)
-
-func ShortenID(str string) string {
-	return str[:12]
-}
-
-func SmallSHA(hash string) string {
-	return hash[:8]
-}
-
-// RemoveSha remove image sha from a string that are added in some docker outputs
-func RemoveSha(str string) string {
-	return strings.Split(str, "@")[0]
-}
-
-// HumanDuration from docker/cli RunningFor() to be accessible outside of the class
-func HumanDuration(timestamp int64) string {
-	date := time.Unix(timestamp, 0)
-	now := time.Now().UTC()
-	return units.HumanDuration(now.Sub(date)) + " ago"
-}
-
-// CreateTable prepares a table layout for output.
-func CreateTable(columns []string) *tablewriter.Table {
-	table := tablewriter.NewWriter(os.Stdout)
-	table.SetAutoWrapText(false)
-	table.SetHeader(columns)
-	return table
-}
-
-// CreateProgressbar generates a progress bar
-func CreateProgressbar(length int, title string) *progressbar.ProgressBar {
-	return progressbar.NewOptions(
-		length,
-		progressbar.OptionClearOnFinish(),
-		progressbar.OptionSetPredictTime(false),
-		progressbar.OptionShowCount(),
-		progressbar.OptionFullWidth(),
-		progressbar.OptionSetDescription(title),
-	)
-}
-
-// StripTagMeta strips front-matter image tag data that we don't need for parsing.
-func StripTagMeta(image string) string {
-	originalImage := image
-
-	if strings.Contains(image, "docker.io") {
-		image = strings.Split(image, "/")[1]
-	}
-
-	if strings.Contains(image, "library") {
-		image = strings.Split(image, "/")[1]
-	}
-
-	if originalImage != image {
-		logrus.Debugf("stripped %s to %s for parsing", originalImage, image)
-	}
-
-	return image
-}

pkg/git/branch.go

@@ -1,35 +0,0 @@
-package git
-
-import (
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
-)
-
-// GetCurrentBranch retrieves the current branch of a repository
-func GetCurrentBranch(repository *git.Repository) (string, error) {
-	branchRefs, err := repository.Branches()
-	if err != nil {
-		return "", err
-	}
-
-	headRef, err := repository.Head()
-	if err != nil {
-		return "", err
-	}
-
-	var currentBranchName string
-	err = branchRefs.ForEach(func(branchRef *plumbing.Reference) error {
-		if branchRef.Hash() == headRef.Hash() {
-			currentBranchName = branchRef.Name().String()
-
-			return nil
-		}
-
-		return nil
-	})
-	if err != nil {
-		return "", err
-	}
-
-	return currentBranchName, nil
-}

pkg/git/clone.go

@@ -1,40 +0,0 @@
-package git
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/sirupsen/logrus"
-)
-
-// Clone runs a git clone which accounts for different default branches.
-func Clone(dir, url string) error {
-	if _, err := os.Stat(dir); os.IsNotExist(err) {
-		logrus.Debugf("%s does not exist, attempting to git clone from %s", dir, url)
-		_, err := git.PlainClone(dir, false, &git.CloneOptions{URL: url, Tags: git.AllTags})
-		if err != nil {
-			logrus.Debugf("cloning %s default branch failed, attempting from main branch", url)
-			_, err := git.PlainClone(dir, false, &git.CloneOptions{
-				URL:           url,
-				Tags:          git.AllTags,
-				ReferenceName: plumbing.ReferenceName("refs/heads/main"),
-			})
-			if err != nil {
-				if strings.Contains(err.Error(), "authentication required") {
-					name := filepath.Base(dir)
-					return fmt.Errorf("unable to clone %s, does %s exist?", name, url)
-				}
-				return err
-			}
-		}
-		logrus.Debugf("%s has been git cloned successfully", dir)
-	} else {
-		logrus.Debugf("%s already exists", dir)
-	}
-
-	return nil
-}

pkg/git/commit.go

@@ -1,56 +0,0 @@
-package git
-
-import (
-	"fmt"
-
-	"github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
-)
-
-// Commit runs a git commit
-func Commit(repoPath, glob, commitMessage string, dryRun bool) error {
-	if commitMessage == "" {
-		return fmt.Errorf("no commit message specified?")
-	}
-
-	commitRepo, err := git.PlainOpen(repoPath)
-	if err != nil {
-		return err
-	}
-
-	commitWorktree, err := commitRepo.Worktree()
-	if err != nil {
-		return err
-	}
-
-	patterns, err := GetExcludesFiles()
-	if err != nil {
-		return err
-	}
-
-	if len(patterns) > 0 {
-		commitWorktree.Excludes = append(patterns, commitWorktree.Excludes...)
-	}
-
-	if !dryRun {
-		err = commitWorktree.AddGlob(glob)
-		if err != nil {
-			return err
-		}
-		logrus.Debugf("staged %s for commit", glob)
-	} else {
-		logrus.Debugf("dry run: did not stage %s for commit", glob)
-	}
-
-	if !dryRun {
-		_, err = commitWorktree.Commit(commitMessage, &git.CommitOptions{})
-		if err != nil {
-			return err
-		}
-		logrus.Debug("git changes commited")
-	} else {
-		logrus.Debug("dry run: no changes commited")
-	}
-
-	return nil
-}

pkg/git/common.go

@@ -1,14 +0,0 @@
-package git
-
-import (
-	"fmt"
-	"os"
-)
-
-// EnsureGitRepo ensures a git repo .git folder exists
-func EnsureGitRepo(repoPath string) error {
-	if _, err := os.Stat(repoPath); os.IsNotExist(err) {
-		return fmt.Errorf("no .git directory in %s?", repoPath)
-	}
-	return nil
-}

pkg/git/init.go

@@ -1,38 +0,0 @@
-package git
-
-import (
-	"github.com/go-git/go-git/v5"
-	gitPkg "github.com/go-git/go-git/v5"
-	"github.com/sirupsen/logrus"
-)
-
-// Init inits a new repo and commits all the stuff if you want
-func Init(repoPath string, commit bool) error {
-	if _, err := gitPkg.PlainInit(repoPath, false); err != nil {
-		logrus.Fatal(err)
-	}
-	logrus.Debugf("initialised new git repo in %s", repoPath)
-
-	if commit {
-		commitRepo, err := git.PlainOpen(repoPath)
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		commitWorktree, err := commitRepo.Worktree()
-		if err != nil {
-			logrus.Fatal(err)
-		}
-
-		if err := commitWorktree.AddWithOptions(&git.AddOptions{All: true}); err != nil {
-			return err
-		}
-
-		if _, err = commitWorktree.Commit("init", &git.CommitOptions{}); err != nil {
-			return err
-		}
-		logrus.Debugf("init committed all files for new git repo in %s", repoPath)
-	}
-
-	return nil
-}

pkg/git/push.go

@@ -1,43 +0,0 @@
-package git
-
-import (
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/config"
-	"github.com/sirupsen/logrus"
-)
-
-// Push pushes the latest changes & optionally tags to the default remote
-func Push(repoDir string, remote string, tags bool, dryRun bool) error {
-	if dryRun {
-		logrus.Debugf("dry run: no git changes pushed in %s", repoDir)
-		return nil
-	}
-
-	commitRepo, err := git.PlainOpen(repoDir)
-	if err != nil {
-		return err
-	}
-
-	opts := &git.PushOptions{}
-	if remote != "" {
-		opts.RemoteName = remote
-	}
-
-	if err := commitRepo.Push(opts); err != nil {
-		return err
-	}
-
-	logrus.Debugf("git changes pushed")
-
-	if tags {
-		opts.RefSpecs = append(opts.RefSpecs, config.RefSpec("+refs/tags/*:refs/tags/*"))
-
-		if err := commitRepo.Push(opts); err != nil {
-			return err
-		}
-
-		logrus.Debugf("git tags pushed")
-	}
-
-	return nil
-}

pkg/git/read.go

@@ -1,187 +0,0 @@
-package git
-
-import (
-	"io/ioutil"
-	"os"
-	"os/user"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"coopcloud.tech/abra/pkg/config"
-	"github.com/go-git/go-git/v5"
-	gitConfigPkg "github.com/go-git/go-git/v5/config"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/format/gitignore"
-	"github.com/sirupsen/logrus"
-)
-
-// GetRecipeHead retrieves latest HEAD metadata.
-func GetRecipeHead(recipeName string) (*plumbing.Reference, error) {
-	recipeDir := path.Join(config.RECIPES_DIR, recipeName)
-
-	repo, err := git.PlainOpen(recipeDir)
-	if err != nil {
-		return nil, err
-	}
-
-	head, err := repo.Head()
-	if err != nil {
-		return nil, err
-	}
-
-	return head, nil
-}
-
-// IsClean checks if a repo has unstaged changes
-func IsClean(repoPath string) (bool, error) {
-	repo, err := git.PlainOpen(repoPath)
-	if err != nil {
-		return false, err
-	}
-
-	worktree, err := repo.Worktree()
-	if err != nil {
-		return false, err
-	}
-
-	patterns, err := GetExcludesFiles()
-	if err != nil {
-		return false, err
-	}
-
-	if len(patterns) > 0 {
-		worktree.Excludes = append(patterns, worktree.Excludes...)
-	}
-
-	status, err := worktree.Status()
-	if err != nil {
-		return false, err
-	}
-
-	if status.String() != "" {
-		logrus.Debugf("discovered git status in %s: %s", repoPath, status.String())
-	} else {
-		logrus.Debugf("discovered clean git status in %s", repoPath)
-	}
-
-	return status.IsClean(), nil
-}
-
-// GetExcludesFiles reads the exlude files from a global gitignore
-func GetExcludesFiles() ([]gitignore.Pattern, error) {
-	var err error
-	var patterns []gitignore.Pattern
-
-	cfg, err := parseGitConfig()
-	if err != nil {
-		return patterns, err
-	}
-
-	excludesfile := getExcludesFile(cfg)
-	patterns, err = parseExcludesFile(excludesfile)
-	if err != nil {
-		return patterns, err
-	}
-
-	return patterns, nil
-}
-
-func parseGitConfig() (*gitConfigPkg.Config, error) {
-	cfg := gitConfigPkg.NewConfig()
-
-	usr, err := user.Current()
-	if err != nil {
-		return nil, err
-	}
-
-	globalGitConfig := filepath.Join(usr.HomeDir, ".gitconfig")
-	if _, err := os.Stat(globalGitConfig); err != nil {
-		if os.IsNotExist(err) {
-			logrus.Debugf("no %s exists, not reading any global gitignore config", globalGitConfig)
-			return cfg, nil
-		}
-		return cfg, err
-	}
-
-	b, err := ioutil.ReadFile(globalGitConfig)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := cfg.Unmarshal(b); err != nil {
-		return nil, err
-	}
-
-	return cfg, err
-}
-
-func getExcludesFile(cfg *gitConfigPkg.Config) string {
-	for _, sec := range cfg.Raw.Sections {
-		if sec.Name == "core" {
-			for _, opt := range sec.Options {
-				if opt.Key == "excludesfile" {
-					return opt.Value
-				}
-			}
-		}
-	}
-
-	return "~/.gitignore"
-}
-
-func parseExcludesFile(excludesfile string) ([]gitignore.Pattern, error) {
-	var ps []gitignore.Pattern
-
-	excludesfile, err := expandTilde(excludesfile)
-	if err != nil {
-		return nil, err
-	}
-
-	if _, err := os.Stat(excludesfile); err != nil {
-		if os.IsNotExist(err) {
-			logrus.Debugf("no %s exists, skipping reading gitignore paths", excludesfile)
-			return ps, nil
-		}
-		return ps, err
-	}
-
-	data, err := ioutil.ReadFile(excludesfile)
-	if err != nil {
-		return nil, err
-	}
-
-	var pathsRaw []string
-	for _, s := range strings.Split(string(data), "\n") {
-		if !strings.HasPrefix(s, "#") && len(strings.TrimSpace(s)) > 0 {
-			pathsRaw = append(pathsRaw, s)
-			ps = append(ps, gitignore.ParsePattern(s, nil))
-		}
-	}
-
-	logrus.Debugf("read global ignore paths: %s", strings.Join(pathsRaw, " "))
-
-	return ps, nil
-}
-
-func expandTilde(path string) (string, error) {
-	if !strings.HasPrefix(path, "~") {
-		return path, nil
-	}
-
-	var paths []string
-	u, err := user.Current()
-	if err != nil {
-		return "", err
-	}
-
-	for _, p := range strings.Split(path, string(filepath.Separator)) {
-		if p == "~" {
-			paths = append(paths, u.HomeDir)
-		} else {
-			paths = append(paths, p)
-		}
-	}
-
-	return filepath.Join(paths...), nil
-}

pkg/git/remote.go

@@ -1,28 +0,0 @@
-package git
-
-import (
-	"strings"
-
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/config"
-	"github.com/sirupsen/logrus"
-)
-
-// CreateRemote creates a new git remote in a repository
-func CreateRemote(repo *git.Repository, name, url string, dryRun bool) error {
-	if dryRun {
-		logrus.Debugf("dry run: remote %s (%s) not created", name, url)
-		return nil
-	}
-
-	if _, err := repo.CreateRemote(&config.RemoteConfig{
-		Name: name,
-		URLs: []string{url},
-	}); err != nil {
-		if !strings.Contains(err.Error(), "remote already exists") {
-			return err
-		}
-	}
-
-	return nil
-}

pkg/integration/integration.go

@@ -1,12 +0,0 @@
-package integration
-
-import (
-	"os"
-	"testing"
-)
-
-func skipIfNotIntegration(t *testing.T) {
-	if os.Getenv("ABRA_INTEGRATION") == "" {
-		t.Skip("missing 'ABRA_INTEGRATION', not running integration tests")
-	}
-}

pkg/limit/limit.go

@@ -1,20 +0,0 @@
-package limit // https://github.com/tidwall/limiter
-
-// Limiter is for limiting the number of concurrent operations. This
-type Limiter struct{ sem chan struct{} }
-
-// New returns a new Limiter. The limit param is the maximum number of
-// concurrent operations.
-func New(limit int) *Limiter {
-	return &Limiter{make(chan struct{}, limit)}
-}
-
-// Begin an operation.
-func (l *Limiter) Begin() {
-	l.sem <- struct{}{}
-}
-
-// End the operation.
-func (l *Limiter) End() {
-	<-l.sem
-}

pkg/lint/recipe.go

@@ -1,338 +0,0 @@
-package lint
-
-import (
-	"fmt"
-	"net/http"
-	"os"
-	"path"
-
-	"coopcloud.tech/abra/pkg/config"
-	"coopcloud.tech/abra/pkg/recipe"
-	recipePkg "coopcloud.tech/abra/pkg/recipe"
-	"coopcloud.tech/tagcmp"
-	"github.com/docker/distribution/reference"
-	"github.com/sirupsen/logrus"
-)
-
-var Warn = "warn"
-var Critical = "critical"
-
-type LintFunction func(recipe.Recipe) (bool, error)
-
-type LintRule struct {
-	Ref          string
-	Level        string
-	Description  string
-	HowToResolve string
-	Function     LintFunction
-}
-
-var LintRules = map[string][]LintRule{
-	"warn": {
-		{
-			Ref:          "R001",
-			Level:        "warn",
-			Description:  "compose config has expected version",
-			HowToResolve: "ensure 'version: \"3.8\"' in compose configs",
-			Function:     LintComposeVersion,
-		},
-		{
-			Ref:          "R002",
-			Level:        "warn",
-			Description:  "healthcheck enabled for all services",
-			HowToResolve: "wire up healthchecks",
-			Function:     LintHealthchecks,
-		},
-		{
-			Ref:          "R003",
-			Level:        "warn",
-			Description:  "all images use a tag",
-			HowToResolve: "use a tag for all images",
-			Function:     LintAllImagesTagged,
-		},
-		{
-			Ref:          "R004",
-			Level:        "warn",
-			Description:  "no unstable tags",
-			HowToResolve: "tag all images with stable tags",
-			Function:     LintNoUnstableTags,
-		},
-		{
-			Ref:          "R005",
-			Level:        "warn",
-			Description:  "tags use semver-like format",
-			HowToResolve: "use semver-like tags",
-			Function:     LintSemverLikeTags,
-		},
-		{
-			Ref:          "R006",
-			Level:        "warn",
-			Description:  "has published catalogue version",
-			HowToResolve: "publish a recipe version to the catalogue",
-			Function:     LintHasPublishedVersion,
-		},
-		{
-			Ref:          "R007",
-			Level:        "warn",
-			Description:  "README.md metadata filled in",
-			HowToResolve: "fill out all the metadata",
-			Function:     LintMetadataFilledIn,
-		},
-		{
-			Ref:          "R013",
-			Level:        "warn",
-			Description:  "git.coopcloud.tech repo exists",
-			HowToResolve: "upload your recipe to git.coopcloud.tech/coop-cloud/...",
-			Function:     LintHasRecipeRepo,
-		},
-	},
-	"error": {
-		{
-			Ref:          "R008",
-			Level:        "error",
-			Description:  ".env.sample provided",
-			HowToResolve: "create an example .env.sample",
-			Function:     LintEnvConfigPresent,
-		},
-		{
-			Ref:          "R009",
-			Level:        "error",
-			Description:  "one service named 'app'",
-			HowToResolve: "name a servce 'app'",
-			Function:     LintAppService,
-		},
-		{
-			Ref:          "R010",
-			Level:        "error",
-			Description:  "traefik routing enabled",
-			HowToResolve: "include \"traefik.enable=true\" deploy label",
-			Function:     LintTraefikEnabled,
-		},
-		{
-			Ref:          "R011",
-			Level:        "error",
-			Description:  "all services have images",
-			HowToResolve: "ensure \"image: ...\" set on all services",
-			Function:     LintImagePresent,
-		},
-		{
-			Ref:          "R012",
-			Level:        "error",
-			Description:  "config version are vendored",
-			HowToResolve: "vendor config versions in an abra.sh",
-			Function:     LintAbraShVendors,
-		},
-	},
-}
-
-func LintForErrors(recipe recipe.Recipe) error {
-	logrus.Debugf("linting for critical errors in %s configs", recipe.Name)
-
-	for level := range LintRules {
-		if level != "error" {
-			continue
-		}
-		for _, rule := range LintRules[level] {
-			ok, err := rule.Function(recipe)
-			if err != nil {
-				return err
-			}
-			if !ok {
-				return fmt.Errorf("lint error in %s configs: \"%s\" failed lint checks (%s)", recipe.Name, rule.Description, rule.Ref)
-			}
-		}
-	}
-
-	logrus.Debugf("linting successful, %s is well configured", recipe.Name)
-
-	return nil
-}
-
-func LintComposeVersion(recipe recipe.Recipe) (bool, error) {
-	if recipe.Config.Version == "3.8" {
-		return true, nil
-	}
-
-	return true, nil
-}
-
-func LintEnvConfigPresent(recipe recipe.Recipe) (bool, error) {
-	envSample := fmt.Sprintf("%s/%s/.env.sample", config.RECIPES_DIR, recipe.Name)
-	if _, err := os.Stat(envSample); !os.IsNotExist(err) {
-		return true, nil
-	}
-
-	return false, nil
-}
-
-func LintAppService(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
-		if service.Name == "app" {
-			return true, nil
-		}
-	}
-
-	return false, nil
-}
-
-func LintTraefikEnabled(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
-		for label := range service.Deploy.Labels {
-			if label == "traefik.enable" {
-				if service.Deploy.Labels[label] == "true" {
-					return true, nil
-				}
-			}
-		}
-	}
-
-	return false, nil
-}
-
-func LintHealthchecks(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
-		if service.HealthCheck == nil {
-			return false, nil
-		}
-	}
-
-	return true, nil
-}
-
-func LintAllImagesTagged(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
-		img, err := reference.ParseNormalizedNamed(service.Image)
-		if err != nil {
-			return false, err
-		}
-		if reference.IsNameOnly(img) {
-			return false, nil
-		}
-	}
-
-	return true, nil
-}
-
-func LintNoUnstableTags(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
-		img, err := reference.ParseNormalizedNamed(service.Image)
-		if err != nil {
-			return false, err
-		}
-
-		var tag string
-		switch img.(type) {
-		case reference.NamedTagged:
-			tag = img.(reference.NamedTagged).Tag()
-		case reference.Named:
-			return false, nil
-		}
-
-		if tag == "latest" {
-			return false, nil
-		}
-	}
-
-	return true, nil
-}
-
-func LintSemverLikeTags(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
-		img, err := reference.ParseNormalizedNamed(service.Image)
-		if err != nil {
-			return false, err
-		}
-
-		var tag string
-		switch img.(type) {
-		case reference.NamedTagged:
-			tag = img.(reference.NamedTagged).Tag()
-		case reference.Named:
-			return false, nil
-		}
-
-		if !tagcmp.IsParsable(tag) {
-			return false, nil
-		}
-	}
-
-	return true, nil
-}
-
-func LintImagePresent(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
-		if service.Image == "" {
-			return false, nil
-		}
-	}
-	return true, nil
-}
-
-func LintHasPublishedVersion(recipe recipe.Recipe) (bool, error) {
-	catl, err := recipePkg.ReadRecipeCatalogue()
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	versions, err := recipePkg.GetRecipeCatalogueVersions(recipe.Name, catl)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	if len(versions) == 0 {
-		return false, nil
-	}
-
-	return true, nil
-}
-
-func LintMetadataFilledIn(r recipe.Recipe) (bool, error) {
-	features, category, err := recipe.GetRecipeFeaturesAndCategory(r.Name)
-	if err != nil {
-		return false, err
-	}
-
-	if category == "" {
-		return false, nil
-	}
-
-	if features.Backups == "" ||
-		features.Email == "" ||
-		features.Healthcheck == "" ||
-		features.Image.Image == "" ||
-		features.SSO == "" {
-		return false, nil
-	}
-
-	return true, nil
-}
-
-func LintAbraShVendors(recipe recipe.Recipe) (bool, error) {
-	for _, service := range recipe.Config.Services {
-		if len(service.Configs) > 0 {
-			abraSh := path.Join(config.RECIPES_DIR, recipe.Name, "abra.sh")
-			if _, err := os.Stat(abraSh); err != nil {
-				if os.IsNotExist(err) {
-					return false, err
-				}
-				return false, err
-			}
-		}
-	}
-	return true, nil
-}
-
-func LintHasRecipeRepo(recipe recipe.Recipe) (bool, error) {
-	url := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, recipe.Name)
-
-	res, err := http.Get(url)
-	if err != nil {
-		return false, err
-	}
-
-	if res.StatusCode != 200 {
-		return false, err
-	}
-
-	return true, nil
-}

pkg/secret/pass.go

@@ -1,53 +0,0 @@
-package secret
-
-import (
-	"errors"
-	"fmt"
-	"os/exec"
-
-	"github.com/sirupsen/logrus"
-)
-
-// PassInsertSecret inserts a secret into a pass store.
-func PassInsertSecret(secretValue, secretName, appName, server string) error {
-	if _, err := exec.LookPath("pass"); err != nil {
-		return errors.New("pass command not found on $PATH, is it installed?")
-	}
-
-	cmd := fmt.Sprintf(
-		"echo %s | pass insert hosts/%s/%s/%s -m",
-		secretValue, server, appName, secretName,
-	)
-
-	logrus.Debugf("attempting to run %s", cmd)
-
-	if err := exec.Command("bash", "-c", cmd).Run(); err != nil {
-		return err
-	}
-
-	logrus.Infof("%s inserted into pass store", secretName)
-
-	return nil
-}
-
-// PassRmSecret deletes a secret from a pass store.
-func PassRmSecret(secretName, appName, server string) error {
-	if _, err := exec.LookPath("pass"); err != nil {
-		return errors.New("pass command not found on $PATH, is it installed?")
-	}
-
-	cmd := fmt.Sprintf(
-		"pass rm --force hosts/%s/%s/%s",
-		server, appName, secretName,
-	)
-
-	logrus.Debugf("attempting to run %s", cmd)
-
-	if err := exec.Command("bash", "-c", cmd).Run(); err != nil {
-		return err
-	}
-
-	logrus.Infof("%s removed from pass store", secretName)
-
-	return nil
-}

pkg/secret/secret.go

@@ -1,199 +0,0 @@
-// Package secret provides functionality for generating and storing secrets
-// both in a remote swarm and locally within supported storage such as pass
-// stores.
-package secret
-
-import (
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-	"sync"
-
-	"coopcloud.tech/abra/pkg/client"
-	"coopcloud.tech/abra/pkg/config"
-	"github.com/schultz-is/passgen"
-	"github.com/sirupsen/logrus"
-)
-
-// secretValue represents a parsed `SECRET_FOO=v1 # length=bar` env var config
-// secret definition.
-type secretValue struct {
-	Version string
-	Length  int
-}
-
-// GeneratePasswords generates passwords.
-func GeneratePasswords(count, length uint) ([]string, error) {
-	passwords, err := passgen.GeneratePasswords(
-		count,
-		length,
-		passgen.AlphabetDefault,
-	)
-
-	if err != nil {
-		return nil, err
-	}
-
-	logrus.Debugf("generated %s", strings.Join(passwords, ", "))
-
-	return passwords, nil
-}
-
-// GeneratePassphrases generates human readable and rememberable passphrases.
-func GeneratePassphrases(count uint) ([]string, error) {
-	passphrases, err := passgen.GeneratePassphrases(
-		count,
-		passgen.PassphraseWordCountDefault,
-		rune('-'),
-		passgen.PassphraseCasingDefault,
-		passgen.WordListDefault,
-	)
-
-	if err != nil {
-		return nil, err
-	}
-
-	logrus.Debugf("generated %s", strings.Join(passphrases, ", "))
-
-	return passphrases, nil
-}
-
-// ReadSecretEnvVars reads secret env vars from an app env var config.
-func ReadSecretEnvVars(appEnv config.AppEnv) map[string]string {
-	secretEnvVars := make(map[string]string)
-
-	for envVar := range appEnv {
-		regex := regexp.MustCompile(`^SECRET.*VERSION.*`)
-		if string(regex.Find([]byte(envVar))) != "" {
-			secretEnvVars[envVar] = appEnv[envVar]
-		}
-	}
-
-	logrus.Debugf("read %s as secrets from %s", secretEnvVars, appEnv)
-
-	return secretEnvVars
-}
-
-func ParseSecretEnvVarName(secretEnvVar string) string {
-	withoutPrefix := strings.TrimPrefix(secretEnvVar, "SECRET_")
-	withoutSuffix := strings.TrimSuffix(withoutPrefix, "_VERSION")
-	name := strings.ToLower(withoutSuffix)
-	logrus.Debugf("parsed %s as name from %s", name, secretEnvVar)
-	return name
-}
-
-func ParseGeneratedSecretName(secret string, appEnv config.App) string {
-	name := fmt.Sprintf("%s_", appEnv.StackName())
-	withoutAppName := strings.TrimPrefix(secret, name)
-	idx := strings.LastIndex(withoutAppName, "_")
-	parsed := withoutAppName[:idx]
-	logrus.Debugf("parsed %s as name from %s", parsed, secret)
-	return parsed
-}
-
-func ParseSecretEnvVarValue(secret string) (secretValue, error) {
-	values := strings.Split(secret, "#")
-	if len(values) == 0 {
-		return secretValue{}, fmt.Errorf("unable to parse %s", secret)
-	}
-
-	if len(values) == 1 {
-		return secretValue{Version: values[0], Length: 0}, nil
-	}
-
-	split := strings.Split(values[1], "=")
-	parsed := split[len(split)-1]
-	stripped := strings.ReplaceAll(parsed, " ", "")
-	length, err := strconv.Atoi(stripped)
-	if err != nil {
-		return secretValue{}, err
-	}
-	version := strings.ReplaceAll(values[0], " ", "")
-
-	logrus.Debugf("parsed version %s and length '%v' from %s", version, length, secret)
-
-	return secretValue{Version: version, Length: length}, nil
-}
-
-// GenerateSecrets generates secrets locally and sends them to a remote server for storage.
-func GenerateSecrets(secretEnvVars map[string]string, appName, server string) (map[string]string, error) {
-	secrets := make(map[string]string)
-
-	var mutex sync.Mutex
-	var wg sync.WaitGroup
-	ch := make(chan error, len(secretEnvVars))
-	for secretEnvVar := range secretEnvVars {
-		wg.Add(1)
-
-		go func(s string) {
-			defer wg.Done()
-
-			secretName := ParseSecretEnvVarName(s)
-			secretValue, err := ParseSecretEnvVarValue(secretEnvVars[s])
-			if err != nil {
-				ch <- err
-				return
-			}
-
-			secretRemoteName := fmt.Sprintf("%s_%s_%s", appName, secretName, secretValue.Version)
-			logrus.Debugf("attempting to generate and store %s on %s", secretRemoteName, server)
-
-			if secretValue.Length > 0 {
-				passwords, err := GeneratePasswords(1, uint(secretValue.Length))
-				if err != nil {
-					ch <- err
-					return
-				}
-
-				if err := client.StoreSecret(secretRemoteName, passwords[0], server); err != nil {
-					if strings.Contains(err.Error(), "AlreadyExists") {
-						logrus.Warnf("%s already exists, moving on...", secretRemoteName)
-						ch <- nil
-					} else {
-						ch <- err
-					}
-					return
-				}
-
-				mutex.Lock()
-				defer mutex.Unlock()
-				secrets[secretName] = passwords[0]
-			} else {
-				passphrases, err := GeneratePassphrases(1)
-				if err != nil {
-					ch <- err
-					return
-				}
-
-				if err := client.StoreSecret(secretRemoteName, passphrases[0], server); err != nil {
-					if strings.Contains(err.Error(), "AlreadyExists") {
-						logrus.Warnf("%s already exists, moving on...", secretRemoteName)
-						ch <- nil
-					} else {
-						ch <- err
-					}
-					return
-				}
-
-				mutex.Lock()
-				defer mutex.Unlock()
-				secrets[secretName] = passphrases[0]
-			}
-			ch <- nil
-		}(secretEnvVar)
-	}
-
-	wg.Wait()
-
-	for range secretEnvVars {
-		err := <-ch
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	logrus.Debugf("generated and stored %s on %s", secrets, server)
-
-	return secrets, nil
-}

pkg/server/server.go

@@ -1,27 +0,0 @@
-package server
-
-import (
-	"os"
-	"path"
-
-	"coopcloud.tech/abra/pkg/config"
-	"github.com/sirupsen/logrus"
-)
-
-// CreateServerDir creates a server directory under ~/.abra.
-func CreateServerDir(serverName string) error {
-	serverPath := path.Join(config.ABRA_DIR, "servers", serverName)
-
-	if err := os.Mkdir(serverPath, 0764); err != nil {
-		if !os.IsExist(err) {
-			return err
-		}
-
-		logrus.Infof("%s already exists", serverPath)
-		return nil
-	}
-
-	logrus.Infof("successfully created %s", serverPath)
-
-	return nil
-}

pkg/service/service.go

@@ -1,78 +0,0 @@
-package service
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"coopcloud.tech/abra/pkg/formatter"
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/swarm"
-	"github.com/docker/docker/client"
-	"github.com/sirupsen/logrus"
-)
-
-// 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.
-func GetService(c context.Context, cl *client.Client, filters filters.Args, prompt bool) (swarm.Service, error) {
-	serviceOpts := types.ServiceListOptions{Filters: filters}
-	services, err := cl.ServiceList(c, serviceOpts)
-	if err != nil {
-		return swarm.Service{}, err
-	}
-
-	if len(services) == 0 {
-		filter := filters.Get("name")[0]
-		return swarm.Service{}, fmt.Errorf("no services matching the %v filter found?", filter)
-	}
-
-	if len(services) != 1 {
-		var servicesRaw []string
-		for _, service := range services {
-			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(services), 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 services {
-			serviceName := strings.ToLower(service.Spec.Name)
-			if serviceName == chosenService {
-				return service, nil
-			}
-		}
-
-		logrus.Panic("failed to match chosen service")
-	}
-
-	return services[0], nil
-}
-
-// ContainerToServiceName converts a container name to a service name.
-func ContainerToServiceName(containerNames []string, stackName string) string {
-	containerName := strings.Join(containerNames, "")
-	trimmed := strings.TrimPrefix(containerName, "/")
-	stackNameServiceName := strings.Split(trimmed, ".")[0]
-	splitter := fmt.Sprintf("%s_", stackName)
-	return strings.Split(stackNameServiceName, splitter)[1]
-}

pkg/ssh/ssh.go

@@ -1,548 +0,0 @@
-package ssh
-
-import (
-	"bufio"
-	"bytes"
-	"crypto/sha256"
-	"encoding/base64"
-	"fmt"
-	"io"
-	"net"
-	"os"
-	"os/user"
-	"path/filepath"
-	"strings"
-	"sync"
-	"time"
-
-	"coopcloud.tech/abra/pkg/context"
-	"github.com/AlecAivazis/survey/v2"
-	dockerSSHPkg "github.com/docker/cli/cli/connhelper/ssh"
-	sshPkg "github.com/gliderlabs/ssh"
-	"github.com/kevinburke/ssh_config"
-	"github.com/sirupsen/logrus"
-	"golang.org/x/crypto/ssh"
-	"golang.org/x/crypto/ssh/agent"
-	"golang.org/x/crypto/ssh/knownhosts"
-)
-
-var KnownHostsPath = filepath.Join(os.Getenv("HOME"), ".ssh", "known_hosts")
-
-type Client struct {
-	SSHClient *ssh.Client
-}
-
-// HostConfig is a SSH host config.
-type HostConfig struct {
-	Host         string
-	IdentityFile string
-	Port         string
-	User         string
-}
-
-// Exec cmd on the remote host and return stderr and stdout
-func (c *Client) Exec(cmd string) ([]byte, error) {
-	session, err := c.SSHClient.NewSession()
-	if err != nil {
-		return nil, err
-	}
-	defer session.Close()
-
-	return session.CombinedOutput(cmd)
-}
-
-// Close the underlying SSH connection
-func (c *Client) Close() error {
-	return c.SSHClient.Close()
-}
-
-// New creates a new SSH client connection.
-func New(domainName, sshAuth, username, port string) (*Client, error) {
-	var client *Client
-
-	ctxConnDetails, err := GetContextConnDetails(domainName)
-	if err != nil {
-		return client, nil
-	}
-
-	if sshAuth == "identity-file" {
-		var err error
-		client, err = connectWithAgentTimeout(
-			ctxConnDetails.Host,
-			ctxConnDetails.User,
-			ctxConnDetails.Port,
-			5*time.Second,
-		)
-		if err != nil {
-			return client, err
-		}
-	} else {
-		password := ""
-		prompt := &survey.Password{
-			Message: "SSH password?",
-		}
-		if err := survey.AskOne(prompt, &password); err != nil {
-			return client, err
-		}
-
-		var err error
-		client, err = connectWithPasswordTimeout(
-			ctxConnDetails.Host,
-			ctxConnDetails.User,
-			ctxConnDetails.Port,
-			password,
-			5*time.Second,
-		)
-		if err != nil {
-			return client, err
-		}
-	}
-
-	return client, nil
-}
-
-// sudoWriter supports sudo command handling
-type sudoWriter struct {
-	b     bytes.Buffer
-	pw    string
-	stdin io.Writer
-	m     sync.Mutex
-}
-
-// Write satisfies the write interface for sudoWriter
-func (w *sudoWriter) Write(p []byte) (int, error) {
-	if strings.Contains(string(p), "sudo_password") {
-		w.stdin.Write([]byte(w.pw + "\n"))
-		w.pw = ""
-		return len(p), nil
-	}
-
-	w.m.Lock()
-	defer w.m.Unlock()
-
-	return w.b.Write(p)
-}
-
-// RunSudoCmd runs SSH commands and streams output
-func RunSudoCmd(cmd, passwd string, cl *Client) error {
-	session, err := cl.SSHClient.NewSession()
-	if err != nil {
-		return err
-	}
-	defer session.Close()
-
-	sudoCmd := fmt.Sprintf("SSH_ASKPASS=/usr/bin/ssh-askpass; sudo -p sudo_password -S %s", cmd)
-
-	w := &sudoWriter{pw: passwd}
-	w.stdin, err = session.StdinPipe()
-	if err != nil {
-		return err
-	}
-
-	session.Stdout = w
-	session.Stderr = w
-
-	modes := ssh.TerminalModes{
-		ssh.ECHO:          0,
-		ssh.TTY_OP_ISPEED: 14400,
-		ssh.TTY_OP_OSPEED: 14400,
-	}
-
-	err = session.RequestPty("xterm", 80, 40, modes)
-	if err != nil {
-		return err
-	}
-
-	if err := session.Run(sudoCmd); err != nil {
-		return fmt.Errorf("%s", string(w.b.Bytes()))
-	}
-
-	return nil
-}
-
-// EnsureKnowHostsFiles ensures that ~/.ssh/known_hosts is created
-func EnsureKnowHostsFiles() error {
-	if _, err := os.Stat(KnownHostsPath); os.IsNotExist(err) {
-		logrus.Debugf("missing %s, creating now", KnownHostsPath)
-		file, err := os.OpenFile(KnownHostsPath, os.O_CREATE, 0600)
-		if err != nil {
-			return err
-		}
-		file.Close()
-	}
-
-	return nil
-}
-
-// GetHostKey checks if a host key is registered in the ~/.ssh/known_hosts file
-func GetHostKey(hostname string) (bool, sshPkg.PublicKey, error) {
-	var hostKey sshPkg.PublicKey
-
-	ctxConnDetails, err := GetContextConnDetails(hostname)
-	if err != nil {
-		return false, hostKey, err
-	}
-
-	if err := EnsureKnowHostsFiles(); err != nil {
-		return false, hostKey, err
-	}
-
-	file, err := os.Open(KnownHostsPath)
-	if err != nil {
-		return false, hostKey, err
-	}
-	defer file.Close()
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		fields := strings.Split(scanner.Text(), " ")
-		if len(fields) != 3 {
-			continue
-		}
-
-		hostnameAndPort := fmt.Sprintf("%s:%s", ctxConnDetails.Host, ctxConnDetails.Port)
-		hashed := knownhosts.Normalize(hostnameAndPort)
-
-		if strings.Contains(fields[0], hashed) {
-			var err error
-			hostKey, _, _, _, err = ssh.ParseAuthorizedKey(scanner.Bytes())
-			if err != nil {
-				return false, hostKey, fmt.Errorf("error parsing server SSH host key %q: %v", fields[2], err)
-			}
-			break
-		}
-	}
-
-	if hostKey != nil {
-		logrus.Debugf("server SSH host key present in ~/.ssh/known_hosts for %s", hostname)
-		return true, hostKey, nil
-	}
-
-	return false, hostKey, nil
-}
-
-// InsertHostKey adds a new host key to the ~/.ssh/known_hosts file
-func InsertHostKey(hostname string, remote net.Addr, pubKey ssh.PublicKey) error {
-	file, err := os.OpenFile(KnownHostsPath, os.O_APPEND|os.O_WRONLY, 0600)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	hashedHostname := knownhosts.Normalize(hostname)
-	lineHostname := knownhosts.Line([]string{hashedHostname}, pubKey)
-	_, err = file.WriteString(fmt.Sprintf("%s\n", lineHostname))
-	if err != nil {
-		return err
-	}
-
-	hashedRemote := knownhosts.Normalize(remote.String())
-	lineRemote := knownhosts.Line([]string{hashedRemote}, pubKey)
-	_, err = file.WriteString(fmt.Sprintf("%s\n", lineRemote))
-	if err != nil {
-		return err
-	}
-
-	logrus.Debugf("SSH host key generated: %s", lineHostname)
-	logrus.Debugf("SSH host key generated: %s", lineRemote)
-
-	return nil
-}
-
-// HostKeyAddCallback ensures server ssh host keys are handled
-func HostKeyAddCallback(hostnameAndPort string, remote net.Addr, pubKey ssh.PublicKey) error {
-	exists, _, err := GetHostKey(hostnameAndPort)
-	if err != nil {
-		return err
-	}
-
-	if exists {
-		hostname := strings.Split(hostnameAndPort, ":")[0]
-		logrus.Debugf("server SSH host key found for %s", hostname)
-		return nil
-	}
-
-	if !exists {
-		hostname := strings.Split(hostnameAndPort, ":")[0]
-		parsedPubKey := FingerprintSHA256(pubKey)
-
-		fmt.Printf(fmt.Sprintf(`
-You are attempting to make an SSH connection to a server but there is no entry
-in your ~/.ssh/known_hosts file which confirms that you have already validated
-that this is indeed the server you want to connect to. Please take a moment to
-validate the following SSH host key, it is important.
-
-    Host:        %s
-    Fingerprint: %s
-
-If this is confusing to you, you can read the article below and learn how to
-validate this fingerprint safely. Thanks to the comrades at cyberia.club for
-writing this extensive guide <3
-
-    https://sequentialread.com/understanding-the-secure-shell-protocol-ssh/
-
-`, hostname, parsedPubKey))
-
-		response := false
-		prompt := &survey.Confirm{
-			Message: "are you sure you trust this host key?",
-		}
-
-		if err := survey.AskOne(prompt, &response); err != nil {
-			return err
-		}
-
-		if !response {
-			logrus.Fatal("exiting as requested")
-		}
-
-		logrus.Debugf("attempting to insert server SSH host key for %s, %s", hostnameAndPort, remote)
-
-		if err := InsertHostKey(hostnameAndPort, remote, pubKey); err != nil {
-			return err
-		}
-
-		logrus.Infof("successfully added server SSH host key for %s", hostname)
-	}
-
-	return nil
-}
-
-// connect makes the SSH connection
-func connect(username, host, port string, authMethod ssh.AuthMethod, timeout time.Duration) (*Client, error) {
-	config := &ssh.ClientConfig{
-		User:            username,
-		Auth:            []ssh.AuthMethod{authMethod},
-		HostKeyCallback: HostKeyAddCallback, // the main reason why we fork
-	}
-
-	hostnameAndPort := fmt.Sprintf("%s:%s", host, port)
-
-	logrus.Debugf("tcp dialing %s", hostnameAndPort)
-
-	var conn net.Conn
-	var err error
-	conn, err = net.DialTimeout("tcp", hostnameAndPort, timeout)
-	if err != nil {
-		logrus.Debugf("tcp dialing %s failed, trying via ~/.ssh/config", hostnameAndPort)
-		hostConfig, err := GetHostConfig(host, username, port, true)
-		if err != nil {
-			return nil, err
-		}
-		conn, err = net.DialTimeout("tcp", fmt.Sprintf("%s:%s", hostConfig.Host, hostConfig.Port), timeout)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	sshConn, chans, reqs, err := ssh.NewClientConn(conn, hostnameAndPort, config)
-	if err != nil {
-		return nil, err
-	}
-
-	client := ssh.NewClient(sshConn, chans, reqs)
-	c := &Client{SSHClient: client}
-
-	return c, nil
-}
-
-func connectWithAgentTimeout(host, username, port string, timeout time.Duration) (*Client, error) {
-	logrus.Debugf("using ssh-agent to make an SSH connection for %s", host)
-
-	sshAgent, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK"))
-	if err != nil {
-		return nil, err
-	}
-
-	agentCl := agent.NewClient(sshAgent)
-	authMethod := ssh.PublicKeysCallback(agentCl.Signers)
-
-	loadedKeys, err := agentCl.List()
-	if err != nil {
-		return nil, err
-	}
-
-	var convertedKeys []string
-	for _, key := range loadedKeys {
-		convertedKeys = append(convertedKeys, key.String())
-	}
-
-	if len(convertedKeys) > 0 {
-		logrus.Debugf("ssh-agent has these keys loaded: %s", strings.Join(convertedKeys, ","))
-	} else {
-		logrus.Debug("ssh-agent has no keys loaded")
-	}
-
-	return connect(username, host, port, authMethod, timeout)
-}
-
-func connectWithPasswordTimeout(host, username, port, pass string, timeout time.Duration) (*Client, error) {
-	authMethod := ssh.Password(pass)
-
-	return connect(username, host, port, authMethod, timeout)
-}
-
-// EnsureHostKey ensures that a host key trusted and added to the ~/.ssh/known_hosts file
-func EnsureHostKey(hostname string) error {
-	if hostname == "default" || hostname == "local" {
-		logrus.Debugf("not checking server SSH host key against local/default target")
-		return nil
-	}
-
-	exists, _, err := GetHostKey(hostname)
-	if err != nil {
-		return err
-	}
-	if exists {
-		return nil
-	}
-
-	ctxConnDetails, err := GetContextConnDetails(hostname)
-	if err != nil {
-		return err
-	}
-
-	_, err = connectWithAgentTimeout(
-		ctxConnDetails.Host,
-		ctxConnDetails.User,
-		ctxConnDetails.Port,
-		5*time.Second,
-	)
-
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// FingerprintSHA256 generates the SHA256 fingerprint for a server SSH host key
-func FingerprintSHA256(key ssh.PublicKey) string {
-	hash := sha256.Sum256(key.Marshal())
-	b64hash := base64.StdEncoding.EncodeToString(hash[:])
-	trimmed := strings.TrimRight(b64hash, "=")
-	return fmt.Sprintf("SHA256:%s", trimmed)
-}
-
-// GetContextConnDetails retrieves SSH connection details from a docker context endpoint
-func GetContextConnDetails(serverName string) (*dockerSSHPkg.Spec, error) {
-	dockerContextStore := context.NewDefaultDockerContextStore()
-	contexts, err := dockerContextStore.Store.List()
-	if err != nil {
-		return &dockerSSHPkg.Spec{}, err
-	}
-
-	if strings.Contains(serverName, ":") {
-		serverName = strings.Split(serverName, ":")[0]
-	}
-
-	for _, ctx := range contexts {
-		endpoint, err := context.GetContextEndpoint(ctx)
-		if err != nil && strings.Contains(err.Error(), "does not exist") {
-			// No local context found, we can continue safely
-			continue
-		}
-		if ctx.Name == serverName {
-			ctxConnDetails, err := dockerSSHPkg.ParseURL(endpoint)
-			if err != nil {
-				return &dockerSSHPkg.Spec{}, err
-			}
-			logrus.Debugf("found context connection details %v for %s", ctxConnDetails, serverName)
-			return ctxConnDetails, nil
-		}
-	}
-
-	hostConfig, err := GetHostConfig(serverName, "", "", false)
-	if err != nil {
-		return &dockerSSHPkg.Spec{}, err
-	}
-
-	logrus.Debugf("couldn't find a docker context matching %s", serverName)
-	logrus.Debugf("searching ~/.ssh/config for a Host entry for %s", serverName)
-
-	connDetails := &dockerSSHPkg.Spec{
-		Host: hostConfig.Host,
-		User: hostConfig.User,
-		Port: hostConfig.Port,
-	}
-
-	logrus.Debugf("using %v from ~/.ssh/config for connection details", connDetails)
-
-	return connDetails, nil
-}
-
-// GetHostConfig retrieves a ~/.ssh/config config for a host.
-func GetHostConfig(hostname, username, port string, override bool) (HostConfig, error) {
-	var hostConfig HostConfig
-
-	if hostname == "" || override {
-		if sshHost := ssh_config.Get(hostname, "Hostname"); sshHost != "" {
-			hostname = sshHost
-		}
-	}
-
-	if username == "" || override {
-		if sshUser := ssh_config.Get(hostname, "User"); sshUser != "" {
-			username = sshUser
-		} else {
-			systemUser, err := user.Current()
-			if err != nil {
-				return hostConfig, err
-			}
-			username = systemUser.Username
-		}
-	}
-
-	if port == "" || override {
-		if sshPort := ssh_config.Get(hostname, "Port"); sshPort != "" {
-			// skip override probably correct port with dummy default value from
-			// ssh_config which is 22. only when the original port number is empty
-			// should we try this default. this might not cover all cases
-			// unfortunately.
-			if port != "" && sshPort != "22" {
-				port = sshPort
-			}
-		}
-	}
-
-	if idf := ssh_config.Get(hostname, "IdentityFile"); idf != "" && idf != "~/.ssh/identity" {
-		var err error
-		idf, err = identityFileAbsPath(idf)
-		if err != nil {
-			return hostConfig, err
-		}
-		hostConfig.IdentityFile = idf
-	} else {
-		hostConfig.IdentityFile = ""
-	}
-
-	hostConfig.Host = hostname
-	hostConfig.Port = port
-	hostConfig.User = username
-
-	logrus.Debugf("constructed SSH config %s for %s", hostConfig, hostname)
-
-	return hostConfig, nil
-}
-
-func identityFileAbsPath(relPath string) (string, error) {
-	var err error
-	var absPath string
-
-	if strings.HasPrefix(relPath, "~/") {
-		systemUser, err := user.Current()
-		if err != nil {
-			return absPath, err
-		}
-		absPath = filepath.Join(systemUser.HomeDir, relPath[2:])
-	} else {
-		absPath, err = filepath.Abs(relPath)
-		if err != nil {
-			return absPath, err
-		}
-	}
-
-	logrus.Debugf("resolved %s to %s to read the ssh identity file", relPath, absPath)
-
-	return absPath, nil
-}