abra/cli/server/remove.go

package server

import (
	"context"
	"fmt"
	"os"
	"path/filepath"

	"coopcloud.tech/abra/cli/internal"
	"coopcloud.tech/abra/pkg/autocomplete"
	"coopcloud.tech/abra/pkg/client"
	"coopcloud.tech/abra/pkg/config"
	"coopcloud.tech/abra/pkg/formatter"
	"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: `
Remova 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,
	BashComplete: autocomplete.ServerNameComplete,
	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
	},
}