Feat(dokku): destroy dokku cmd (#558)

Author: paketeserrano

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- stack destroy command for supabase, dokku and starter-kit
+
 ## [3.24.1] - 2025-10-14
 
 ### Changed

internal/commands/stack/dokku/deploy.go

@@ -63,7 +63,7 @@ func (s *deployDokkuCommand) InitCommand() {
 	fs.StringVar(&s.githubUser, "github-user", s.githubUser, "Used to allow Dokku to push your app images to your GitHub Container Registry")
 	fs.StringVar(&s.certManagerEmail, "cert-manager-email", "ops@example.com", "Email for TLS cert registration (default: ops@example.com)")
 	fs.StringVar(&s.globalDomain, "global-domain", s.globalDomain, "Example: example.com. If you do not have a domain name leave this empty and it will get the value of the ingress nginx load balancer automatically. Example: lb-0a39e6584…")
-	fs.IntVar(&s.numNodes, "num-nodes", 3, "Number of nodes in the Dokku cluster (default: 3)")
+	fs.IntVar(&s.numNodes, "num-nodes", 1, "Number of nodes in the Dokku cluster (default: 1)")
 	fs.StringVar(&s.sshPath, "ssh-path", defaultSSH, "Path to your private SSH key (default: ~/.ssh/id_rsa). Needed to be able to ‘git push dokku@<host>:<app>’ when deploying apps with git push")
 	fs.StringVar(&s.sshPubPath, "ssh-path-pub", defaultSSHPub, "Path to your public SSH key (default: ~/.ssh/id_rsa.pub)")
 	fs.StringVar(&s.githubPackageURL, "github-package-url", "ghcr.io", "Container registry hostname (default: ghcr.io)")

internal/commands/stack/dokku/destroy.go

@@ -20,24 +20,25 @@ func DestroyDokkuCommand() commands.Command {
 
 type destroyDokkuCommand struct {
 	*commands.BaseCommand
-	zone string
-	name string
+	zone          string
+	name          string
+	deleteStorage bool
 }
 
 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")
+	fs.BoolVar(&s.deleteStorage, "delete-storage", false, "Delete associated UpCloud storage resources")
 	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)
+	err := stack.DestroyStack(exec, c.name, c.zone, c.deleteStorage, false, stack.StackTypeDokku)
 	if err != nil {
 		return nil, err
 	}

internal/commands/stack/helm.go

@@ -210,10 +210,16 @@ func DeployHelmReleaseFromRepo(
 	valsFiles []string,
 	upgrade bool,
 ) error {
+	// Wait for the Kubernetes API server to be ready
+	err := WaitForAPIServer(kubeClient)
+	if err != nil {
+		return fmt.Errorf("waiting for API server: %w", err)
+	}
+
 	os.Setenv("HELM_NAMESPACE", releaseName)
 
 	// Ensure the target namespace exists
-	err := CreateNamespace(kubeClient, releaseName)
+	err = CreateNamespace(kubeClient, releaseName)
 	if err != nil {
 		return fmt.Errorf("ensuring namespace %q exists: %w", releaseName, err)
 	}

internal/commands/stack/stackops.go

@@ -248,10 +248,6 @@ func DestroyStack(exec commands.Executor, name, zone string, deleteStorage, dele
 		}
 
 		var uuids []string
-		// Collect PVC volume UUIDs for deletion if deleteStorage is true
-		// This is done before uninstalling the helm release to ensure we get all PVCs
-		// associated with the Supabase stack
-		// If deleteStorage is false, we skip this step and leave the PVCs intact
 		if deleteStorage {
 			msg = fmt.Sprintln("Collecting PVC volume UUIDs for deletion")
 			exec.PushProgressStarted(msg)
@@ -372,9 +368,6 @@ func DestroyStack(exec commands.Executor, name, zone string, deleteStorage, dele
 			return err
 		}
 
-		msg = fmt.Sprintf("Deleting network %s in zone %s", clusterName, zone)
-		exec.PushProgressStarted(msg)
-
 		networkName := fmt.Sprintf("%s-%s-%s", SupabaseResourceRootNameNetwork, name, zone)
 		networks, err := exec.All().GetNetworks(exec.Context())
 		if err != nil {
@@ -393,19 +386,110 @@ func DestroyStack(exec commands.Executor, name, zone string, deleteStorage, dele
 				break
 			}
 		}
-		exec.PushProgressSuccess(msg)
 	case StackTypeDokku:
+		logDir := os.TempDir()
 		clusterName := fmt.Sprintf("%s-%s-%s", DokkuResourceRootNameCluster, name, zone)
-		networkName := fmt.Sprintf("%s-%s-%s", DokkuResourceRootNameNetwork, name, zone)
+		msg := fmt.Sprintf("Searching cluster %s in zone %s", clusterName, zone)
+		exec.PushProgressStarted(msg)
+		clusters, err := exec.All().GetKubernetesClusters(exec.Context(), &request.GetKubernetesClustersRequest{})
+		if err != nil {
+			return fmt.Errorf("failed to get kubernetes clusters: %w", err)
+		}
+
+		var cluster *upcloud.KubernetesCluster
+		for _, cl := range clusters {
+			if cl.Name == clusterName {
+				cluster = &cl
+				break
+			}
+		}
+
+		if cluster == nil {
+			return fmt.Errorf("a cluster with the name '%s' was not found", clusterName)
+		}
+
+		exec.PushProgressSuccess(msg)
 
-		resources, err := all.ListResources(exec, []string{clusterName, networkName}, []string{})
+		msg = fmt.Sprintln("Preparing to start deleting resources")
+		exec.PushProgressStarted(msg)
+
+		kubeconfigPath, err := WriteKubeconfigToFile(exec, cluster.UUID, logDir)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to write kubeconfig to file: %w", err)
 		}
 
-		err = all.DeleteResources(exec, resources, 16)
+		if err := os.Setenv("KUBECONFIG", kubeconfigPath); err != nil {
+			return fmt.Errorf("set KUBECONFIG: %w", err)
+		}
+
+		exec.PushProgressSuccess(msg)
+
+		kubeClient, err := GetKubernetesClient(kubeconfigPath)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to create Kubernetes client: %w", err)
+		}
+
+		var uuids []string
+		if deleteStorage {
+			msg = fmt.Sprintln("Collecting PVC volume UUIDs for deletion")
+			exec.PushProgressStarted(msg)
+
+			uuids, err = CollectPVCVolumeUUIDs(exec.Context(), exec, kubeClient, "dokku")
+			if err != nil {
+				return fmt.Errorf("failed to retrieve PVC volume UUIDs: %w", err)
+			}
+
+			exec.PushProgressSuccess(msg)
+		}
+
+		msg = fmt.Sprintf("Uninstalling ingress nginx helm release: %s", clusterName)
+		exec.PushProgressStarted(msg)
+
+		err = UninstallHelmRelease("ingress-nginx", logDir)
+		if err != nil {
+			exec.PushProgressUpdateMessage(msg, "failed to uninstall ingress-nginx. You might have to manually delete the load balancer")
+		}
+
+		exec.PushProgressSuccess(msg)
+
+		msg = fmt.Sprintf("Deleting Kubernetes cluster %s in zone %s", clusterName, zone)
+		exec.PushProgressStarted(msg)
+
+		_, err = kubernetes.Delete(exec, cluster.UUID, true)
+		if err != nil {
+			return fmt.Errorf("failed to delete kubernetes cluster: %w", err)
+		}
+
+		exec.PushProgressSuccess(msg)
+
+		if deleteStorage && len(uuids) > 0 {
+			msg = fmt.Sprintln("Deleting PVC volumes")
+			exec.PushProgressStarted(msg)
+
+			err = DeletePVCVolumesByUUIDs(exec, uuids)
+			if err != nil {
+				return fmt.Errorf("failed to delete PVC volumes: %w", err)
+			}
+			exec.PushProgressSuccess(msg)
+		}
+
+		networkName := fmt.Sprintf("%s-%s-%s", DokkuResourceRootNameNetwork, name, zone)
+		networks, err := exec.All().GetNetworks(exec.Context())
+		if err != nil {
+			return fmt.Errorf("failed to get networks: %w", err)
+		}
+
+		for _, net := range networks.Networks {
+			if net.Name == networkName {
+				msg := fmt.Sprintf("Deleting network %s in zone %s", networkName, zone)
+				exec.PushProgressStarted(msg)
+				_, err = network.Delete(exec, net.UUID)
+				if err != nil {
+					return fmt.Errorf("failed to delete network: %w", err)
+				}
+				exec.PushProgressSuccess(msg)
+				break
+			}
 		}
 	case StackTypeStarterKit:
 		clusterName := fmt.Sprintf("%s-%s-%s", StarterKitResourceRootNameCluster, name, zone)

internal/commands/stack/supabase/destroy.go

@@ -39,7 +39,6 @@ func (s *destroySupabaseCommand) InitCommand() {
 }
 
 // ExecuteWithoutArguments implements commands.NoArgumentCommand
-// TODO: This is not deleting the LB that supabase creates. Need to find a way to identify it.
 func (c *destroySupabaseCommand) ExecuteWithoutArguments(exec commands.Executor) (output.Output, error) {
 	err := stack.DestroyStack(exec, c.name, c.zone, c.deleteStorage, c.deleteObjectStorage, stack.StackTypeSupabase)
 	if err != nil {