feat(stack): add destroy command (#547)

Author: paketeserrano

internal/commands/all/list.go

@@ -38,7 +38,7 @@ func (c *listCommand) InitCommand() {
 
 // ExecuteWithoutArguments implements commands.NoArgumentCommand
 func (c *listCommand) ExecuteWithoutArguments(exec commands.Executor) (output.Output, error) {
-	resources, err := listResources(exec, c.include, c.exclude)
+	resources, err := ListResources(exec, c.include, c.exclude)
 	if err != nil {
 		return nil, err
 	}

internal/commands/all/purge.go

@@ -36,12 +36,12 @@ func (c *purgeCommand) InitCommand() {
 
 // ExecuteWithoutArguments implements commands.NoArgumentCommand
 func (c *purgeCommand) ExecuteWithoutArguments(exec commands.Executor) (output.Output, error) {
-	resources, err := listResources(exec, c.include, c.exclude)
+	resources, err := ListResources(exec, c.include, c.exclude)
 	if err != nil {
 		return nil, err
 	}
 
-	err = deleteResources(exec, resources, 16)
+	err = DeleteResources(exec, resources, 16)
 	if err != nil {
 		return nil, err
 	}

internal/commands/all/resource.go

@@ -147,7 +147,7 @@ func findResources[T any](exec commands.Executor, wg *sync.WaitGroup, returnChan
 	}()
 }
 
-func listResources(exec commands.Executor, include, exclude []string) ([]Resource, error) {
+func ListResources(exec commands.Executor, include, exclude []string) ([]Resource, error) {
 	var resources []Resource
 	returnChan := make(chan findResult, 12)
 
@@ -301,7 +301,7 @@ type deleteResult struct {
 	Error    error
 }
 
-func deleteResources(exec commands.Executor, resources []Resource, workerCount int) error {
+func DeleteResources(exec commands.Executor, resources []Resource, workerCount int) error {
 	if len(resources) == 0 {
 		return nil
 	}

internal/commands/base/base.go

@@ -283,11 +283,16 @@ func BuildCommands(rootCmd *cobra.Command, conf *config.Config) {
 	commands.BuildCommand(all.PurgeCommand(), allCommand.Cobra(), conf)
 	commands.BuildCommand(all.ListCommand(), allCommand.Cobra(), conf)
 
+	// Stack operations
 	stackCommand := commands.BuildCommand(stack.BaseStackCommand(), rootCmd, conf)
 	stackDeployCommand := commands.BuildCommand(stack.DeployCommand(), stackCommand.Cobra(), conf)
+	stackDestroyCommand := commands.BuildCommand(stack.DestroyCommand(), stackCommand.Cobra(), conf)
 	commands.BuildCommand(supabase.DeploySupabaseCommand(), stackDeployCommand.Cobra(), conf)
 	commands.BuildCommand(dokku.DeployDokkuCommand(), stackDeployCommand.Cobra(), conf)
 	commands.BuildCommand(starterkit.DeployStarterKitCommand(), stackDeployCommand.Cobra(), conf)
+	commands.BuildCommand(supabase.DestroySupabaseCommand(), stackDestroyCommand.Cobra(), conf)
+	commands.BuildCommand(dokku.DestroyDokkuCommand(), stackDestroyCommand.Cobra(), conf)
+	commands.BuildCommand(starterkit.DestroyStarterKitCommand(), stackDestroyCommand.Cobra(), conf)
 
 	// Misc
 	commands.BuildCommand(

internal/commands/stack/destroy.go

@@ -0,0 +1,19 @@
+package stack
+
+import "github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+
+// DestroyCommand creates the "stack destroy" command
+func DestroyCommand() commands.Command {
+	return &destroyCommand{
+		BaseCommand: commands.New(
+			"destroy",
+			"Destroy a stack (EXPERIMENTAL)",
+			"upctl stack destroy <stack-name>",
+			"upctl stack destroy (supabase|dokku|starter-kit)",
+		),
+	}
+}
+
+type destroyCommand struct {
+	*commands.BaseCommand
+}

internal/commands/stack/dokku/destroy.go

@@ -0,0 +1,46 @@
+package dokku
+
+import (
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/stack"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/output"
+	"github.com/spf13/pflag"
+)
+
+func DestroyDokkuCommand() commands.Command {
+	return &destroyDokkuCommand{
+		BaseCommand: commands.New(
+			"dokku",
+			"Destroy a Dokku stack",
+			"upctl stack destroy dokku --name <project-name> --zone <zone-name>",
+			"upctl stack destroy dokku --name my-new-project --zone es-mad1",
+		),
+	}
+}
+
+type destroyDokkuCommand struct {
+	*commands.BaseCommand
+	zone string
+	name string
+}
+
+func (s *destroyDokkuCommand) InitCommand() {
+	fs := &pflag.FlagSet{}
+	fs.StringVar(&s.zone, "zone", s.zone, "Zone for the stack deployment")
+	fs.StringVar(&s.name, "name", s.name, "Supabase stack name")
+	s.AddFlags(fs)
+
+	commands.Must(s.Cobra().MarkFlagRequired("zone"))
+	commands.Must(s.Cobra().MarkFlagRequired("name"))
+}
+
+// ExecuteWithoutArguments implements commands.NoArgumentCommand
+// TODO: This is not deleting the LB that dokku creates. Need to find a way to identify it.
+func (c *destroyDokkuCommand) ExecuteWithoutArguments(exec commands.Executor) (output.Output, error) {
+	err := stack.DestroyStack(exec, c.name, c.zone, false, false, stack.StackTypeDokku)
+	if err != nil {
+		return nil, err
+	}
+
+	return output.None{}, nil
+}

internal/commands/stack/dokku/dokku.go

@@ -20,8 +20,8 @@ import (
 )
 
 func (s *deployDokkuCommand) deploy(exec commands.Executor, configDir string) error {
-	clusterName := fmt.Sprintf("stack-dokku-cluster-%s-%s", s.name, s.zone)
-	networkName := fmt.Sprintf("stack-dokku-net-%s-%s", s.name, s.zone)
+	clusterName := fmt.Sprintf("%s-%s-%s", stack.DokkuResourceRootNameCluster, s.name, s.zone)
+	networkName := fmt.Sprintf("%s-%s-%s", stack.DokkuResourceRootNameNetwork, s.name, s.zone)
 	var network *upcloud.Network
 
 	// Check if the cluster already exists

internal/commands/stack/helm.go

@@ -284,3 +284,45 @@ func DeployHelmReleaseFromRepo(
 
 	return nil
 }
+
+// UninstallHelmRelease uninstalls a Helm release in namespace=releaseName.
+func UninstallHelmRelease(releaseName, logDir string) error {
+	// return error if KUBECONFIG is not set
+	if os.Getenv("KUBECONFIG") == "" {
+		return errors.New("KUBECONFIG environment variable is not set")
+	}
+
+	if err := os.Setenv("HELM_NAMESPACE", releaseName); err != nil {
+		return fmt.Errorf("set HELM_NAMESPACE: %w", err)
+	}
+
+	// Ensure logs are written to the same chartPath dir
+	logFile, err := CreateHelmLogFile(logDir)
+	if err != nil {
+		return fmt.Errorf("creating Helm log file: %w", err)
+	}
+	defer logFile.Close()
+
+	// Initialize Helm action config
+	actionConfig, err := InitHelmActionConfig(releaseName, logFile)
+	if err != nil {
+		return fmt.Errorf("initializing Helm action config: %w", err)
+	}
+
+	// Prepare uninstall client
+	uninstall := action.NewUninstall(actionConfig)
+	uninstall.Wait = true
+	uninstall.Timeout = 15 * time.Minute
+
+	// Run uninstall
+	resp, err := uninstall.Run(releaseName)
+	if err != nil {
+		return fmt.Errorf("uninstalling release %q: %w", releaseName, err)
+	}
+
+	if resp != nil {
+		fmt.Fprintf(logFile, "Uninstalled release %q: %s\n", releaseName, resp.Info)
+	}
+
+	return nil
+}

internal/commands/stack/kube.go

@@ -279,3 +279,124 @@ func WriteKubeconfigToFile(exec commands.Executor, clusterID string, configDir s
 
 	return kubeconfigPath, nil
 }
+
+// CollectPVCVolumeUUIDs collects the UUIDs of any UpCloud storage volumes that were provisioned
+// by PVCs in the given namespace (typically the Helm release namespace).
+func CollectPVCVolumeUUIDs(ctx context.Context, exec commands.Executor, kubeClient *kubernetes.Clientset, namespace string) ([]string, error) {
+	var uuids []string
+
+	// List PVCs in the namespace
+	pvcs, err := kubeClient.CoreV1().PersistentVolumeClaims(namespace).List(ctx, v1.ListOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("listing PVCs in namespace %q: %w", namespace, err)
+	}
+
+	if len(pvcs.Items) == 0 {
+		msg := fmt.Sprintf("No PVCs found in namespace %q", namespace)
+		exec.PushProgressStarted(msg)
+		exec.PushProgressSuccess(msg)
+		return nil, nil
+	}
+
+	// Announce PVC check
+	msg := fmt.Sprintf("Checking %d PVC(s) in namespace %q for backing volumes", len(pvcs.Items), namespace)
+	exec.PushProgressStarted(msg)
+	exec.PushProgressSuccess(msg)
+
+	// List PVs once
+	pvs, err := kubeClient.CoreV1().PersistentVolumes().List(ctx, v1.ListOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("listing PVs: %w", err)
+	}
+
+	// Iterate over PVCs belonging to this namespace
+	for _, pvc := range pvcs.Items {
+		pvcMsg := fmt.Sprintf("PVC %s/%s", namespace, pvc.Name)
+		exec.PushProgressStarted(pvcMsg)
+
+		if pvc.Spec.VolumeName == "" {
+			exec.PushProgressStarted(fmt.Sprintf("%s → no bound PV, skipping", pvcMsg))
+			exec.PushProgressSuccess(fmt.Sprintf("%s → no bound PV, skipping", pvcMsg))
+			continue
+		}
+
+		// Find the matching PV
+		var matchedPV *corev1.PersistentVolume
+		for _, pv := range pvs.Items {
+			if pv.Name == pvc.Spec.VolumeName {
+				matchedPV = &pv
+				break
+			}
+		}
+		if matchedPV == nil {
+			exec.PushProgressStarted(fmt.Sprintf("%s → bound PV %q not found, skipping", pvcMsg, pvc.Spec.VolumeName))
+			exec.PushProgressSuccess(fmt.Sprintf("%s → bound PV %q not found, skipping", pvcMsg, pvc.Spec.VolumeName))
+			continue
+		}
+
+		if matchedPV.Spec.CSI == nil {
+			exec.PushProgressStarted(fmt.Sprintf("%s → PV %q has no CSI spec, skipping", pvcMsg, matchedPV.Name))
+			exec.PushProgressSuccess(fmt.Sprintf("%s → PV %q has no CSI spec, skipping", pvcMsg, matchedPV.Name))
+			continue
+		}
+
+		storageUUID := matchedPV.Spec.CSI.VolumeHandle
+		if storageUUID == "" {
+			exec.PushProgressStarted(fmt.Sprintf("%s → PV %q has empty VolumeHandle, skipping", pvcMsg, matchedPV.Name))
+			exec.PushProgressSuccess(fmt.Sprintf("%s → PV %q has empty VolumeHandle, skipping", pvcMsg, matchedPV.Name))
+			continue
+		}
+
+		uuids = append(uuids, storageUUID)
+		exec.PushProgressSuccess(pvcMsg)
+	}
+
+	return uuids, nil
+}
+
+func DeletePVCVolumesByUUIDs(exec commands.Executor, uuids []string) error {
+	for _, storageUUID := range uuids {
+		deleteMsg := fmt.Sprintf("Deleting UpCloud storage %s", storageUUID)
+		exec.PushProgressStarted(deleteMsg)
+
+		// Wait for the storage to be detached (in case the PVC was recently deleted)
+		if err := waitForStorageToBeDetached(exec, storageUUID, 5*time.Minute); err != nil {
+			exec.PushProgressUpdateMessage(fmt.Sprintf("storage %s", storageUUID), fmt.Sprintf("waiting failed: %v", err))
+			continue
+		}
+
+		req := &request.DeleteStorageRequest{UUID: storageUUID}
+		if err := exec.All().DeleteStorage(exec.Context(), req); err != nil {
+			exec.PushProgressStarted(fmt.Sprintf("Failed to delete UpCloud storage %s: %v", storageUUID, err))
+			exec.PushProgressSuccess(fmt.Sprintf("Failed to delete UpCloud storage %s: %v", storageUUID, err))
+			continue
+		}
+
+		exec.PushProgressSuccess(deleteMsg)
+	}
+	return nil
+}
+
+// WaitForNamespaceDeletion waits until the given namespace is deleted, or times out after the specified duration.
+func WaitForNamespaceDeletion(ctx context.Context, kubeClient *kubernetes.Clientset, name string, timeout time.Duration) error {
+	ticker := time.NewTicker(2 * time.Second)
+	defer ticker.Stop()
+	timeoutCh := time.After(timeout)
+
+	for {
+		select {
+		case <-timeoutCh:
+			return fmt.Errorf("namespace %q not deleted within %s", name, timeout)
+		case <-ticker.C:
+			_, err := kubeClient.CoreV1().Namespaces().Get(ctx, name, v1.GetOptions{})
+			if err != nil {
+				if apierrors.IsNotFound(err) {
+					// Namespace gone
+					return nil
+				}
+				return fmt.Errorf("error checking namespace %q: %w", name, err)
+			}
+			// still exists, keep waiting
+		}
+	}
+}