abra/cli/server/remove.go

package server

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

	"coopcloud.tech/abra/cli/formatter"
	"coopcloud.tech/abra/cli/internal"
	"coopcloud.tech/abra/pkg/client"
	"coopcloud.tech/abra/pkg/config"
	"github.com/AlecAivazis/survey/v2"
	"github.com/hetznercloud/hcloud-go/hcloud"
	"github.com/sirupsen/logrus"
	"github.com/urfave/cli/v2"
)

var rmServer bool
var rmServerFlag = &cli.BoolFlag{
	Name:        "server",
	Aliases:     []string{"s"},
	Value:       false,
	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(c.Context, 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(c.Context, 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{
		rmServerFlag,

		// Hetzner
		internal.HetznerCloudNameFlag,
		internal.HetznerCloudAPITokenFlag,
	},
	Action: func(c *cli.Context) error {
		serverName, err := internal.ValidateServer(c)
		if err != nil {
			logrus.Fatal(err)
		}

		if !rmServer {
			logrus.Warn("did not pass -s/--server for actual server deletion, prompting")

			response := false
			prompt := &survey.Confirm{
				Message: "prompt to actual server deletion?",
			}
			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.ABRA_SERVER_FOLDER, serverName)); err != nil {
			logrus.Fatal(err)
		}

		logrus.Infof("server at '%s' has been lost in time, like tears in rain", serverName)

		return nil
	},
}