abra/cli/app/undeploy.go

package app

import (
	"context"
	"fmt"
	"time"

	"coopcloud.tech/abra/cli/internal"
	"coopcloud.tech/abra/pkg/autocomplete"
	"coopcloud.tech/abra/pkg/client"
	"coopcloud.tech/abra/pkg/config"
	"coopcloud.tech/abra/pkg/formatter"
	stack "coopcloud.tech/abra/pkg/upstream/stack"
	"github.com/docker/docker/api/types/filters"
	dockerClient "github.com/docker/docker/client"
	"github.com/sirupsen/logrus"
	"github.com/urfave/cli"
)

var prune bool

var pruneFlag = &cli.BoolFlag{
	Name:        "prune, p",
	Destination: &prune,
	Usage:       "Prunes unused containers, networks, and dangling images for an app",
}

// pruneApp runs the equivalent of a "docker system prune" but only filtering
// against resources connected with the app deployment. It is not a system wide
// prune. Volumes are not pruned to avoid unwated data loss.
func pruneApp(c *cli.Context, cl *dockerClient.Client, app config.App) error {
	stackName := app.StackName()
	ctx := context.Background()

	for {
		logrus.Debugf("polling for %s stack, waiting to be undeployed...", stackName)

		services, err := stack.GetStackServices(ctx, cl, stackName)
		if err != nil {
			return err
		}

		if len(services) == 0 {
			logrus.Debugf("%s undeployed, moving on with pruning logic", stackName)
			time.Sleep(time.Second) // give runtime more time to tear down related state
			break
		}

		time.Sleep(time.Second)
	}

	pruneFilters := filters.NewArgs()
	stackSearch := fmt.Sprintf("%s*", stackName)
	pruneFilters.Add("label", stackSearch)
	cr, err := cl.ContainersPrune(ctx, pruneFilters)
	if err != nil {
		return err
	}

	cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed)
	logrus.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)

	nr, err := cl.NetworksPrune(ctx, pruneFilters)
	if err != nil {
		return err
	}

	logrus.Infof("networks pruned: %d", len(nr.NetworksDeleted))

	ir, err := cl.ImagesPrune(ctx, pruneFilters)
	if err != nil {
		return err
	}

	imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed)
	logrus.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)

	return nil
}

var appUndeployCommand = cli.Command{
	Name:      "undeploy",
	Aliases:   []string{"un"},
	ArgsUsage: "<domain>",
	Flags: []cli.Flag{
		internal.DebugFlag,
		internal.NoInputFlag,
		pruneFlag,
	},
	Before:       internal.SubCommandBefore,
	Usage:        "Undeploy an app",
	BashComplete: autocomplete.AppNameComplete,
	Description: `
This does not destroy any of the application data.

However, you should remain vigilant, as your swarm installation will consider
any previously attached volumes as eligible for pruning once undeployed.

Passing "-p/--prune" does not remove those volumes.
`,
	Action: func(c *cli.Context) error {
		app := internal.ValidateApp(c)
		stackName := app.StackName()

		cl, err := client.New(app.Server)
		if err != nil {
			logrus.Fatal(err)
		}

		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)
		}

		if prune {
			if err := pruneApp(c, cl, app); err != nil {
				logrus.Fatal(err)
			}
		}

		return nil
	},
}