Preflight clean cmd (#345)

* Preflight clean as a command and cleanup before and after individual preflight checks

cmd/qliksense/export.go

@@ -1,27 +0,0 @@
-package main
-
-import (
-	"github.com/qlik-oss/sense-installer/pkg/qliksense"
-	"github.com/spf13/cobra"
-)
-
-func exportCmd(q *qliksense.Qliksense) *cobra.Command {
-	filePath := q.QliksenseHome
-	c := &cobra.Command{
-		Use:     "export",
-		Short:   "export files for corresponding context",
-		Long:    `exports all context files in zip format`,
-		Example: `qliksense export <context_name>`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-
-			if len(args) != 0 {
-				context := args[0]
-				return q.ExportContext(context, filePath)
-			}
-			return nil
-		},
-	}
-	f := c.Flags()
-	f.StringVarP(&filePath, "output", "o", "", "Output Directory")
-	return c
-}

cmd/qliksense/preflight.go

@@ -3,9 +3,9 @@ package main
 import (
 	"fmt"
 
+	. "github.com/logrusorgru/aurora"
 	ansi "github.com/mattn/go-colorable"
 	"github.com/qlik-oss/sense-installer/pkg/preflight"
-	. "github.com/logrusorgru/aurora"
 
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 	"github.com/spf13/cobra"
@@ -44,7 +44,7 @@ func pfDnsCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			if namespace == "" {
 				namespace = "default"
 			}
-			if err = qp.CheckDns(namespace, kubeConfigContents); err != nil {
+			if err = qp.CheckDns(namespace, kubeConfigContents, false); err != nil {
 				fmt.Fprintf(out, "%s\n", Red("Preflight DNS check FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
@@ -163,7 +163,7 @@ func pfDeploymentCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			if namespace == "" {
 				namespace = "default"
 			}
-			if err = qp.CheckDeployment(namespace, kubeConfigContents); err != nil {
+			if err = qp.CheckDeployment(namespace, kubeConfigContents, false); err != nil {
 				fmt.Fprintf(out, "%s\n", Red("Preflight deployment check FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
@@ -202,7 +202,7 @@ func pfServiceCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			if namespace == "" {
 				namespace = "default"
 			}
-			if err = qp.CheckService(namespace, kubeConfigContents); err != nil {
+			if err = qp.CheckService(namespace, kubeConfigContents, false); err != nil {
 				fmt.Fprintf(out, "%s\n", Red("Preflight service check FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
@@ -240,7 +240,7 @@ func pfPodCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			if namespace == "" {
 				namespace = "default"
 			}
-			if err = qp.CheckPod(namespace, kubeConfigContents); err != nil {
+			if err = qp.CheckPod(namespace, kubeConfigContents, false); err != nil {
 				fmt.Fprintf(out, "%s\n", Red("Preflight pod check FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
@@ -275,7 +275,7 @@ func pfCreateRoleCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			if err = qp.CheckCreateRole(namespace); err != nil {
+			if err = qp.CheckCreateRole(namespace, false); err != nil {
 				fmt.Fprintf(out, "%s\n", Red("Preflight role check FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
@@ -310,7 +310,7 @@ func pfCreateRoleBindingCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			if err = qp.CheckCreateRoleBinding(namespace); err != nil {
+			if err = qp.CheckCreateRoleBinding(namespace, false); err != nil {
 				fmt.Fprintf(out, "%s\n", Red("Preflight rolebinding check FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
@@ -345,7 +345,7 @@ func pfCreateServiceAccountCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			if err = qp.CheckCreateServiceAccount(namespace); err != nil {
+			if err = qp.CheckCreateServiceAccount(namespace, false); err != nil {
 				fmt.Fprintf(out, "%s\n", Red("Preflight ServiceAccount check FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
@@ -417,7 +417,7 @@ func pfMongoCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			if namespace == "" {
 				namespace = "default"
 			}
-			if err = qp.CheckMongo(kubeConfigContents, namespace, preflightOpts); err != nil {
+			if err = qp.CheckMongo(kubeConfigContents, namespace, preflightOpts, false); err != nil {
 				fmt.Fprintf(out, "%s\n", Red("Preflight mongo check FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
@@ -436,3 +436,42 @@ func pfMongoCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 	f.BoolVar(&preflightOpts.MongoOptions.Tls, "tls", false, "enable tls?")
 	return preflightMongoCmd
 }
+
+func pfCleanupCmd(q *qliksense.Qliksense) *cobra.Command {
+	out := ansi.NewColorableStdout()
+	preflightOpts := &preflight.PreflightOptions{
+		MongoOptions: &preflight.MongoOptions{},
+	}
+
+	var pfCleanCmd = &cobra.Command{
+		Use:     "clean",
+		Short:   "perform preflight clean",
+		Long:    `perform preflight clean to ensure that all resources are cleared up in the cluster`,
+		Example: `qliksense preflight clean`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			qp := &preflight.QliksensePreflight{Q: q, P: preflightOpts}
+
+			// Preflight clean
+			namespace, kubeConfigContents, err := preflight.InitPreflight()
+			if err != nil {
+				fmt.Fprintf(out, "%s\n", Red("Preflight cleanup FAILED"))
+				fmt.Printf("Error: %v\n", err)
+				return nil
+			}
+
+			if namespace == "" {
+				namespace = "default"
+			}
+			if err = qp.Cleanup(namespace, kubeConfigContents); err != nil {
+				fmt.Fprintf(out, "%s\n", Red("Preflight cleanup FAILED"))
+				fmt.Printf("Error: %v\n", err)
+				return nil
+			}
+			fmt.Fprintf(out, "%s\n", Green("Preflight cleanup complete"))
+			return nil
+		},
+	}
+	f := pfCleanCmd.Flags()
+	f.BoolVarP(&preflightOpts.Verbose, "verbose", "v", false, "verbose mode")
+	return pfCleanCmd
+}

cmd/qliksense/root.go

@@ -202,9 +202,6 @@ func rootCmd(p *qliksense.Qliksense) *cobra.Command {
 	// add uninstall command
 	cmd.AddCommand(uninstallCmd(p))
 
-	// add export command
-	cmd.AddCommand(exportCmd(p))
-
 	// add crds
 	cmd.AddCommand(crdsCmd)
 	crdsCmd.AddCommand(crdsViewCmd(p))
@@ -223,6 +220,7 @@ func rootCmd(p *qliksense.Qliksense) *cobra.Command {
 	preflightCmd.AddCommand(pfCreateRoleBindingCheckCmd(p))
 	preflightCmd.AddCommand(pfCreateServiceAccountCheckCmd(p))
 	preflightCmd.AddCommand(pfCreateAuthCheckCmd(p))
+	preflightCmd.AddCommand(pfCleanupCmd(p))
 
 	cmd.AddCommand(preflightCmd)
 	cmd.AddCommand(loadCrFile(p))

go.mod

@@ -34,9 +34,7 @@ require (
 	github.com/hashicorp/golang-lru v0.5.4 // indirect
 	github.com/jinzhu/copier v0.0.0-20190924061706-b57f9002281a
 	github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0 // indirect
-
 	github.com/logrusorgru/aurora v0.0.0-20200102142835-e9ef32dff381
-
 	github.com/mattn/go-colorable v0.1.4
 	github.com/mattn/go-tty v0.0.3
 	github.com/mitchellh/go-homedir v1.1.0

pkg/preflight/all_checks.go

@@ -3,9 +3,9 @@ package preflight
 import (
 	"fmt"
 
+	. "github.com/logrusorgru/aurora"
 	ansi "github.com/mattn/go-colorable"
 	"github.com/pkg/errors"
-	. "github.com/logrusorgru/aurora"
 )
 
 func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions) error {
@@ -24,7 +24,7 @@ func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, n
 	totalCount++
 
 	// Preflight deployment check
-	if err := qp.CheckDeployment(namespace, kubeConfigContents); err != nil {
+	if err := qp.CheckDeployment(namespace, kubeConfigContents, false); err != nil {
 		fmt.Fprintf(out, "%s\n", Red("Preflight deployment check FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
@@ -34,7 +34,7 @@ func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, n
 	totalCount++
 
 	// Preflight service check
-	if err := qp.CheckService(namespace, kubeConfigContents); err != nil {
+	if err := qp.CheckService(namespace, kubeConfigContents, false); err != nil {
 		fmt.Fprintf(out, "%s\n", Red("Preflight service check FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
@@ -44,7 +44,7 @@ func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, n
 	totalCount++
 
 	// Preflight pod check
-	if err := qp.CheckPod(namespace, kubeConfigContents); err != nil {
+	if err := qp.CheckPod(namespace, kubeConfigContents, false); err != nil {
 		fmt.Fprintf(out, "%s\n", Red("Preflight pod check FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
@@ -54,7 +54,7 @@ func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, n
 	totalCount++
 
 	// Preflight role check
-	if err := qp.CheckCreateRole(namespace); err != nil {
+	if err := qp.CheckCreateRole(namespace, false); err != nil {
 		fmt.Fprintf(out, "%s\n", Red("Preflight role check FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
@@ -64,7 +64,7 @@ func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, n
 	totalCount++
 
 	// Preflight rolebinding check
-	if err := qp.CheckCreateRoleBinding(namespace); err != nil {
+	if err := qp.CheckCreateRoleBinding(namespace, false); err != nil {
 		fmt.Fprintf(out, "%s\n", Red(" Preflight rolebinding check FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
@@ -74,7 +74,7 @@ func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, n
 	totalCount++
 
 	// Preflight serviceaccount check
-	if err := qp.CheckCreateServiceAccount(namespace); err != nil {
+	if err := qp.CheckCreateServiceAccount(namespace, false); err != nil {
 		fmt.Fprintf(out, "%s\n", Red(" Preflight serviceaccount check FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
@@ -84,7 +84,7 @@ func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, n
 	totalCount++
 
 	// Preflight mongo check
-	if err := qp.CheckMongo(kubeConfigContents, namespace, preflightOpts); err != nil {
+	if err := qp.CheckMongo(kubeConfigContents, namespace, preflightOpts, false); err != nil {
 		fmt.Fprintf(out, "%s\n", Red(" Preflight mongo check FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
@@ -94,7 +94,7 @@ func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, n
 	totalCount++
 
 	// Preflight DNS check
-	if err := qp.CheckDns(namespace, kubeConfigContents); err != nil {
+	if err := qp.CheckDns(namespace, kubeConfigContents, false); err != nil {
 		fmt.Fprintf(out, "%s\n", Red(" Preflight DNS check FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {

pkg/preflight/deployability.go

@@ -6,7 +6,7 @@ import (
 	"k8s.io/client-go/kubernetes"
 )
 
-func (qp *QliksensePreflight) CheckDeployment(namespace string, kubeConfigContents []byte) error {
+func (qp *QliksensePreflight) CheckDeployment(namespace string, kubeConfigContents []byte, cleanup bool) error {
 	clientset, _, err := getK8SClientSet(kubeConfigContents, "")
 	if err != nil {
 		err = fmt.Errorf("Kube config error: %v\n", err)
@@ -14,63 +14,80 @@ func (qp *QliksensePreflight) CheckDeployment(namespace string, kubeConfigConten
 	}
 
 	// Deployment check
-	qp.P.LogVerboseMessage("Preflight deployment check: \n")
-	qp.P.LogVerboseMessage("--------------------------- \n")
-	err = qp.checkPfDeployment(clientset, namespace, "deployment-preflight-check")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Preflight deployment check: \n")
+		qp.P.LogVerboseMessage("--------------------------- \n")
+	}
+	err = qp.checkPfDeployment(clientset, namespace, cleanup)
 	if err != nil {
 		qp.P.LogVerboseMessage("Preflight Deployment check: FAILED\n")
 		return err
 	}
-	qp.P.LogVerboseMessage("Completed preflight deployment check\n")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Completed preflight deployment check\n")
+	}
 
 	return nil
 }
 
-func (qp *QliksensePreflight) CheckService(namespace string, kubeConfigContents []byte) error {
+func (qp *QliksensePreflight) CheckService(namespace string, kubeConfigContents []byte, cleanup bool) error {
 	clientset, _, err := getK8SClientSet(kubeConfigContents, "")
 	if err != nil {
 		err = fmt.Errorf("unable to create a kubernetes client: %v\n", err)
 		return err
 	}
 	// Service check
-	qp.P.LogVerboseMessage("Preflight service check: \n")
-	qp.P.LogVerboseMessage("------------------------ \n")
-	err = qp.checkPfService(clientset, namespace)
+	if !cleanup {
+		qp.P.LogVerboseMessage("Preflight service check: \n")
+		qp.P.LogVerboseMessage("------------------------ \n")
+	}
+	err = qp.checkPfService(clientset, namespace, cleanup)
 	if err != nil {
 		qp.P.LogVerboseMessage("Preflight Service check: FAILED\n")
 		return err
 	}
-	qp.P.LogVerboseMessage("Completed preflight service check\n")
+
+	if !cleanup {
+		qp.P.LogVerboseMessage("Completed preflight service check\n")
+	}
 	return nil
 }
 
-func (qp *QliksensePreflight) CheckPod(namespace string, kubeConfigContents []byte) error {
+func (qp *QliksensePreflight) CheckPod(namespace string, kubeConfigContents []byte, cleanup bool) error {
 	clientset, _, err := getK8SClientSet(kubeConfigContents, "")
 	if err != nil {
 		err = fmt.Errorf("error: unable to create a kubernetes client: %v\n", err)
 		return err
 	}
 	// Pod check
-	qp.P.LogVerboseMessage("Preflight pod check: \n")
-	qp.P.LogVerboseMessage("-------------------- \n")
-	err = qp.checkPfPod(clientset, namespace)
+	if !cleanup {
+		qp.P.LogVerboseMessage("Preflight pod check: \n")
+		qp.P.LogVerboseMessage("-------------------- \n")
+	}
+	err = qp.checkPfPod(clientset, namespace, cleanup)
 	if err != nil {
 		qp.P.LogVerboseMessage("Preflight Pod check: FAILED\n")
 		return err
 	}
-	qp.P.LogVerboseMessage("Completed preflight pod check\n")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Completed preflight pod check\n")
+	}
 	return nil
 }
 
-func (qp *QliksensePreflight) checkPfPod(clientset *kubernetes.Clientset, namespace string) error {
-	// create a pod
+func (qp *QliksensePreflight) checkPfPod(clientset *kubernetes.Clientset, namespace string, cleanup bool) error {
+	// delete the pod we are going to create, if it already exists in the cluster
 	podName := "pod-pf-check"
+	qp.deletePod(clientset, namespace, podName)
+	if cleanup {
+		return nil
+	}
 	commandToRun := []string{}
-
 	imageName, err := qp.GetPreflightConfigObj().GetImageName(nginx, true)
 	if err != nil {
 		return err
 	}
+	// create a pod
 	pod, err := qp.createPreflightTestPod(clientset, namespace, podName, imageName, nil, commandToRun)
 	if err != nil {
 		err = fmt.Errorf("unable to create pod - %v\n", err)
@@ -87,9 +104,14 @@ func (qp *QliksensePreflight) checkPfPod(clientset *kubernetes.Clientset, namesp
 	return nil
 }
 
-func (qp *QliksensePreflight) checkPfService(clientset *kubernetes.Clientset, namespace string) error {
-	// creating service
+func (qp *QliksensePreflight) checkPfService(clientset *kubernetes.Clientset, namespace string, cleanup bool) error {
+	// delete the service we are going to create, if it already exists in the cluster
 	serviceName := "svc-pf-check"
+	qp.deleteService(clientset, namespace, serviceName)
+	if cleanup {
+		return nil
+	}
+	// creating service
 	pfService, err := qp.createPreflightTestService(clientset, namespace, serviceName)
 	if err != nil {
 		err = fmt.Errorf("unable to create service - %v\n", err)
@@ -106,7 +128,14 @@ func (qp *QliksensePreflight) checkPfService(clientset *kubernetes.Clientset, na
 	return nil
 }
 
-func (qp *QliksensePreflight) checkPfDeployment(clientset *kubernetes.Clientset, namespace, depName string) error {
+func (qp *QliksensePreflight) checkPfDeployment(clientset *kubernetes.Clientset, namespace string, cleanup bool) error {
+	// delete the deployment we are going to create, if it already exists in the cluster
+	depName := "deployment-preflight-check"
+	qp.deleteDeployment(clientset, namespace, depName)
+	if cleanup {
+		return nil
+	}
+
 	// check if we are able to create a deployment
 	imageName, err := qp.GetPreflightConfigObj().GetImageName(nginx, true)
 	if err != nil {

pkg/preflight/dns_check.go

@@ -3,6 +3,8 @@ package preflight
 import (
 	"fmt"
 	"strings"
+
+	"k8s.io/client-go/kubernetes"
 )
 
 const (
@@ -10,21 +12,32 @@ const (
 	netcat = "netcat"
 )
 
-func (qp *QliksensePreflight) CheckDns(namespace string, kubeConfigContents []byte) error {
-	qp.P.LogVerboseMessage("Preflight DNS check: \n")
-	qp.P.LogVerboseMessage("------------------- \n")
+func (qp *QliksensePreflight) CheckDns(namespace string, kubeConfigContents []byte, cleanup bool) error {
+	depName := "dep-dns-preflight-check"
+	serviceName := "svc-dns-pf-check"
+	podName := "pf-pod-1"
+
+	if !cleanup {
+		qp.P.LogVerboseMessage("Preflight DNS check: \n")
+		qp.P.LogVerboseMessage("------------------- \n")
+	}
 	clientset, _, err := getK8SClientSet(kubeConfigContents, "")
 	if err != nil {
 		err = fmt.Errorf("unable to create a kubernetes client: %v\n", err)
 		return err
 	}
 
+	// delete the deployment we are going to create, if it already exists in the cluster
+	qp.runDNSCleanup(clientset, namespace, podName, serviceName, depName)
+	if cleanup {
+		return nil
+	}
 	// creating deployment
-	depName := "dep-dns-preflight-check"
 	nginxImageName, err := qp.GetPreflightConfigObj().GetImageName(nginx, true)
 	if err != nil {
 		return err
 	}
+
 	dnsDeployment, err := qp.createPreflightTestDeployment(clientset, namespace, depName, nginxImageName)
 	if err != nil {
 		err = fmt.Errorf("unable to create deployment: %v\n", err)
@@ -37,7 +50,6 @@ func (qp *QliksensePreflight) CheckDns(namespace string, kubeConfigContents []by
 	}
 
 	// creating service
-	serviceName := "svc-dns-pf-check"
 	dnsService, err := qp.createPreflightTestService(clientset, namespace, serviceName)
 	if err != nil {
 		err = fmt.Errorf("unable to create service : %s, %s\n", serviceName, err)
@@ -46,13 +58,13 @@ func (qp *QliksensePreflight) CheckDns(namespace string, kubeConfigContents []by
 	defer qp.deleteService(clientset, namespace, serviceName)
 
 	// create a pod
-	podName := "pf-pod-1"
 	commandToRun := []string{"sh", "-c", "sleep 10; nc -z -v -w 1 " + dnsService.Name + " 80"}
 	netcatImageName, err := qp.GetPreflightConfigObj().GetImageName(netcat, true)
 	if err != nil {
 		err = fmt.Errorf("unable to retrieve image : %v\n", err)
 		return err
 	}
+
 	dnsPod, err := qp.createPreflightTestPod(clientset, namespace, podName, netcatImageName, nil, commandToRun)
 	if err != nil {
 		err = fmt.Errorf("unable to create pod : %s, %s\n", podName, err)
@@ -83,9 +95,16 @@ func (qp *QliksensePreflight) CheckDns(namespace string, kubeConfigContents []by
 		err = fmt.Errorf("Expected response not found\n")
 		return err
 	}
-
-	qp.P.LogVerboseMessage("Completed preflight DNS check\n")
-	qp.P.LogVerboseMessage("Cleaning up resources...\n")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Completed preflight DNS check\n")
+		qp.P.LogVerboseMessage("Cleaning up resources...\n")
+	}
 
 	return nil
 }
+
+func (qp *QliksensePreflight) runDNSCleanup(clientset *kubernetes.Clientset, namespace, podName, serviceName, depName string) {
+	qp.deleteDeployment(clientset, namespace, depName)
+	qp.deletePod(clientset, namespace, podName)
+	qp.deleteService(clientset, namespace, serviceName)
+}

pkg/preflight/mongo_check.go

@@ -15,11 +15,12 @@ const (
 	mongo = "mongo"
 )
 
-func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions) error {
-	qp.P.LogVerboseMessage("Preflight mongodb check: \n")
-	qp.P.LogVerboseMessage("------------------------ \n")
-
-	if preflightOpts.MongoOptions.MongodbUrl == "" {
+func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions, cleanup bool) error {
+	if !cleanup {
+		qp.P.LogVerboseMessage("Preflight mongodb check: \n")
+		qp.P.LogVerboseMessage("------------------------ \n")
+	}
+	if preflightOpts != nil && preflightOpts.MongoOptions.MongodbUrl == "" && !cleanup {
 		// infer mongoDbUrl from currentCR
 		qp.P.LogVerboseMessage("MongoDbUri is empty, infer from CR\n")
 		qConfig := qapi.NewQConfig(qp.Q.QliksenseHome)
@@ -39,43 +40,52 @@ func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace st
 		}
 		preflightOpts.MongoOptions.MongodbUrl = decryptedCR.Spec.GetFromSecrets("qliksense", "mongoDbUri")
 	}
-
-	qp.P.LogVerboseMessage("MongodbUrl: %s\n", preflightOpts.MongoOptions.MongodbUrl)
-	if err := qp.mongoConnCheck(kubeConfigContents, namespace, preflightOpts); err != nil {
+	if !cleanup {
+		qp.P.LogVerboseMessage("MongodbUrl: %s\n", preflightOpts.MongoOptions.MongodbUrl)
+	}
+	if err := qp.mongoConnCheck(kubeConfigContents, namespace, preflightOpts, cleanup); err != nil {
 		return err
 	}
-	qp.P.LogVerboseMessage("Completed preflight mongodb check\n")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Completed preflight mongodb check\n")
+	}
 	return nil
 }
 
-func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions) error {
-	var caCertSecretName, clientCertSecretName string
+func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions, cleanup bool) error {
+	caCertSecretName := "preflight-mongo-test-cacert"
+	clientCertSecretName := "preflight-mongo-test-clientcert"
+	mongoPodName := "pf-mongo-pod"
 	clientset, _, err := getK8SClientSet(kubeConfigContents, "")
 	if err != nil {
 		err = fmt.Errorf("unable to create a kubernetes client: %v\n", err)
 		return err
 	}
+
+	// cleanup before starting check
+	qp.runMongoCleanup(clientset, namespace, mongoPodName, caCertSecretName, clientCertSecretName)
+	if cleanup {
+		return nil
+	}
 	var secrets []string
 	if preflightOpts.MongoOptions.CaCertFile != "" {
-		caCertSecretName = "preflight-mongo-test-cacert"
 		caCertSecret, err := qp.createSecret(clientset, namespace, preflightOpts.MongoOptions.CaCertFile, caCertSecretName)
 		if err != nil {
 			err = fmt.Errorf("unable to create a ca cert kubernetes secret: %v\n", err)
 			return err
 		}
 
-		defer qp.deleteK8sSecret(clientset, namespace, caCertSecret)
+		defer qp.deleteK8sSecret(clientset, namespace, caCertSecret.Name)
 		secrets = append(secrets, caCertSecretName)
 	}
 	if preflightOpts.MongoOptions.ClientCertFile != "" {
-		clientCertSecretName = "preflight-mongo-test-clientcert"
 		clientCertSecret, err := qp.createSecret(clientset, namespace, preflightOpts.MongoOptions.ClientCertFile, clientCertSecretName)
 		if err != nil {
 			err = fmt.Errorf("unable to create a client cert kubernetes secret: %v\n", err)
 			return err
 		}
 
-		defer qp.deleteK8sSecret(clientset, namespace, clientCertSecret)
+		defer qp.deleteK8sSecret(clientset, namespace, clientCertSecret.Name)
 		secrets = append(secrets, clientCertSecretName)
 	}
 
@@ -107,18 +117,17 @@ func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespac
 	api.LogDebugMessage("Mongo command: %s\n", strings.Join(commandToRun, " "))
 
 	// create a pod
-	podName := "pf-mongo-pod"
 	imageName, err := qp.GetPreflightConfigObj().GetImageName(mongo, true)
 	if err != nil {
 		err = fmt.Errorf("unable to retrieve image : %v\n", err)
 		return err
 	}
-	mongoPod, err := qp.createPreflightTestPod(clientset, namespace, podName, imageName, secrets, commandToRun)
+	mongoPod, err := qp.createPreflightTestPod(clientset, namespace, mongoPodName, imageName, secrets, commandToRun)
 	if err != nil {
 		err = fmt.Errorf("unable to create pod : %v\n", err)
 		return err
 	}
-	defer qp.deletePod(clientset, namespace, podName)
+	defer qp.deletePod(clientset, namespace, mongoPodName)
 
 	if err := waitForPod(clientset, namespace, mongoPod); err != nil {
 		return err
@@ -157,3 +166,9 @@ func (qp *QliksensePreflight) createSecret(clientset *kubernetes.Clientset, name
 	}
 	return certSecret, nil
 }
+
+func (qp *QliksensePreflight) runMongoCleanup(clientset *kubernetes.Clientset, namespace, mongoPodName, caCertSecretName, clientCertSecretName string) {
+	qp.deletePod(clientset, namespace, mongoPodName)
+	qp.deleteK8sSecret(clientset, namespace, caCertSecretName)
+	qp.deleteK8sSecret(clientset, namespace, clientCertSecretName)
+}

pkg/preflight/preflight_utils.go

@@ -288,7 +288,6 @@ func (qp *QliksensePreflight) deleteService(clientset *kubernetes.Clientset, nam
 	if err := retryOnError(func() (err error) {
 		return servicesClient.Delete(name, &deleteOptions)
 	}); err != nil {
-		fmt.Println(err)
 		return err
 	}
 	qp.P.LogVerboseMessage("Deleted service: %s\n", name)
@@ -568,18 +567,20 @@ func (qp *QliksensePreflight) createPfRole(clientset *kubernetes.Clientset, name
 	return role, nil
 }
 
-func (qp *QliksensePreflight) deleteRole(clientset *kubernetes.Clientset, namespace string, role *v1beta1.Role) {
+func (qp *QliksensePreflight) deleteRole(clientset *kubernetes.Clientset, namespace string, roleName string) error {
 	rolesClient := clientset.RbacV1beta1().Roles(namespace)
 
 	deletePolicy := v1.DeletePropagationForeground
 	deleteOptions := v1.DeleteOptions{
 		PropagationPolicy: &deletePolicy,
 	}
-	err := rolesClient.Delete(role.GetName(), &deleteOptions)
+	err := rolesClient.Delete(roleName, &deleteOptions)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("Error: %v\n", err)
+		return err
 	}
-	qp.P.LogVerboseMessage("Deleted role: %s\n\n", role.Name)
+	qp.P.LogVerboseMessage("Deleted role: %s\n\n", roleName)
+	return nil
 }
 
 func (qp *QliksensePreflight) createPfRoleBinding(clientset *kubernetes.Clientset, namespace, roleBindingName string) (*v1beta1.RoleBinding, error) {
@@ -619,18 +620,20 @@ func (qp *QliksensePreflight) createPfRoleBinding(clientset *kubernetes.Clientse
 	return roleBinding, nil
 }
 
-func (qp *QliksensePreflight) deleteRoleBinding(clientset *kubernetes.Clientset, namespace string, roleBinding *v1beta1.RoleBinding) {
+func (qp *QliksensePreflight) deleteRoleBinding(clientset *kubernetes.Clientset, namespace string, roleBindingName string) error {
 	roleBindingClient := clientset.RbacV1beta1().RoleBindings(namespace)
 
 	deletePolicy := v1.DeletePropagationForeground
 	deleteOptions := v1.DeleteOptions{
 		PropagationPolicy: &deletePolicy,
 	}
-	err := roleBindingClient.Delete(roleBinding.GetName(), &deleteOptions)
+	err := roleBindingClient.Delete(roleBindingName, &deleteOptions)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("Error: %v\n", err)
+		return err
 	}
-	qp.P.LogVerboseMessage("Deleted RoleBinding: %s\n\n", roleBinding.Name)
+	qp.P.LogVerboseMessage("Deleted RoleBinding: %s\n\n", roleBindingName)
+	return nil
 }
 
 func (qp *QliksensePreflight) createPfServiceAccount(clientset *kubernetes.Clientset, namespace, serviceAccountName string) (*apiv1.ServiceAccount, error) {
@@ -657,18 +660,20 @@ func (qp *QliksensePreflight) createPfServiceAccount(clientset *kubernetes.Clien
 	return serviceAccount, nil
 }
 
-func (qp *QliksensePreflight) deleteServiceAccount(clientset *kubernetes.Clientset, namespace string, serviceAccount *apiv1.ServiceAccount) {
+func (qp *QliksensePreflight) deleteServiceAccount(clientset *kubernetes.Clientset, namespace string, serviceAccountName string) error {
 	serviceAccountClient := clientset.CoreV1().ServiceAccounts(namespace)
 
 	deletePolicy := v1.DeletePropagationForeground
 	deleteOptions := v1.DeleteOptions{
 		PropagationPolicy: &deletePolicy,
 	}
-	err := serviceAccountClient.Delete(serviceAccount.GetName(), &deleteOptions)
+	err := serviceAccountClient.Delete(serviceAccountName, &deleteOptions)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("Error: %v\n", err)
+		return err
 	}
-	qp.P.LogVerboseMessage("Deleted ServiceAccount: %s\n\n", serviceAccount.Name)
+	qp.P.LogVerboseMessage("Deleted ServiceAccount: %s\n\n", serviceAccountName)
+	return nil
 }
 
 func (qp *QliksensePreflight) createPreflightTestSecret(clientset *kubernetes.Clientset, namespace, secretName string, secretData []byte) (*apiv1.Secret, error) {
@@ -699,16 +704,42 @@ func (qp *QliksensePreflight) createPreflightTestSecret(clientset *kubernetes.Cl
 	return secret, nil
 }
 
-func (qp *QliksensePreflight) deleteK8sSecret(clientset *kubernetes.Clientset, namespace string, k8sSecret *apiv1.Secret) {
+func (qp *QliksensePreflight) deleteK8sSecret(clientset *kubernetes.Clientset, namespace string, secretName string) error {
 	secretClient := clientset.CoreV1().Secrets(namespace)
 
 	deletePolicy := v1.DeletePropagationForeground
 	deleteOptions := v1.DeleteOptions{
 		PropagationPolicy: &deletePolicy,
 	}
-	err := secretClient.Delete(k8sSecret.GetName(), &deleteOptions)
+	err := secretClient.Delete(secretName, &deleteOptions)
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
-	qp.P.LogVerboseMessage("Deleted Secret: %s\n", k8sSecret.Name)
+	qp.P.LogVerboseMessage("Deleted Secret: %s\n", secretName)
+	return nil
+}
+
+func (qp *QliksensePreflight) Cleanup(namespace string, kubeConfigContents []byte) error {
+	qp.P.LogVerboseMessage("Preflight clean\n")
+	qp.P.LogVerboseMessage("----------------\n")
+
+	qp.P.LogVerboseMessage("Removing deployment...\n")
+	qp.CheckDeployment(namespace, kubeConfigContents, true)
+	qp.P.LogVerboseMessage("Removing service...\n")
+	qp.CheckService(namespace, kubeConfigContents, true)
+	qp.P.LogVerboseMessage("Removing pod...\n")
+	qp.CheckPod(namespace, kubeConfigContents, true)
+
+	qp.P.LogVerboseMessage("Removing role...\n")
+	qp.CheckCreateRole(namespace, true)
+	qp.P.LogVerboseMessage("Removing rolebinding...\n")
+	qp.CheckCreateRoleBinding(namespace, true)
+	qp.P.LogVerboseMessage("Removing serviceaccount...\n")
+	qp.CheckCreateServiceAccount(namespace, true)
+
+	qp.P.LogVerboseMessage("Removing DNS check components...\n")
+	qp.CheckDns(namespace, kubeConfigContents, true)
+	qp.P.LogVerboseMessage("Removing mongo check components...\n")
+	qp.CheckMongo(kubeConfigContents, namespace, &PreflightOptions{MongoOptions: &MongoOptions{}}, true)
+	return nil
 }

pkg/preflight/role_check.go

@@ -11,48 +11,59 @@ import (
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 )
 
-var resultYamlBytes = []byte("")
-
-func (qp *QliksensePreflight) CheckCreateRole(namespace string) error {
+func (qp *QliksensePreflight) CheckCreateRole(namespace string, cleanup bool) error {
 	// create a Role
-	qp.P.LogVerboseMessage("Preflight role check: \n")
-	qp.P.LogVerboseMessage("--------------------- \n")
-	err := qp.checkCreateEntity(namespace, "Role")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Preflight role check: \n")
+		qp.P.LogVerboseMessage("--------------------- \n")
+	}
+	err := qp.checkCreateEntity(namespace, "Role", cleanup)
 	if err != nil {
 		return err
 	}
-	qp.P.LogVerboseMessage("Completed preflight role check\n")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Completed preflight role check\n")
+	}
 	return nil
 }
 
-func (qp *QliksensePreflight) CheckCreateRoleBinding(namespace string) error {
+func (qp *QliksensePreflight) CheckCreateRoleBinding(namespace string, cleanup bool) error {
 	// create a RoleBinding
-	qp.P.LogVerboseMessage("Preflight rolebinding check: \n")
-	qp.P.LogVerboseMessage("---------------------------- \n")
-	err := qp.checkCreateEntity(namespace, "RoleBinding")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Preflight rolebinding check: \n")
+		qp.P.LogVerboseMessage("---------------------------- \n")
+	}
+	err := qp.checkCreateEntity(namespace, "RoleBinding", cleanup)
 	if err != nil {
 		return err
 	}
-	qp.P.LogVerboseMessage("Completed preflight rolebinding check\n")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Completed preflight rolebinding check\n")
+	}
 	return nil
 }
 
-func (qp *QliksensePreflight) CheckCreateServiceAccount(namespace string) error {
+func (qp *QliksensePreflight) CheckCreateServiceAccount(namespace string, cleanup bool) error {
 	// create a service account
-	qp.P.LogVerboseMessage("Preflight serviceaccount check: \n")
-	qp.P.LogVerboseMessage("------------------------------- \n")
-	err := qp.checkCreateEntity(namespace, "ServiceAccount")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Preflight serviceaccount check: \n")
+		qp.P.LogVerboseMessage("------------------------------- \n")
+	}
+	err := qp.checkCreateEntity(namespace, "ServiceAccount", cleanup)
 	if err != nil {
 		return err
 	}
-	qp.P.LogVerboseMessage("Completed preflight serviceaccount check\n")
+	if !cleanup {
+		qp.P.LogVerboseMessage("Completed preflight serviceaccount check\n")
+	}
 	return nil
 }
-func (qp *QliksensePreflight) checkCreateEntity(namespace, entityToTest string) error {
+func (qp *QliksensePreflight) checkCreateEntity(namespace, entityToTest string, cleanup bool) error {
 	qConfig := qapi.NewQConfig(qp.Q.QliksenseHome)
 	var currentCR *qapi.QliksenseCR
 	mfroot := ""
 	kusDir := ""
+	resultYamlBytes := []byte("")
 	var err error
 	currentCR, err = qConfig.GetCurrentCR()
 	if err != nil {
@@ -89,6 +100,12 @@ func (qp *QliksensePreflight) checkCreateEntity(namespace, entityToTest string)
 	}
 	namespace = "" // namespace is handled when generating the manifests
 
+	// check if entity already exists in the cluster, if so - delete it
+	api.KubectlDeleteVerbose(sa, namespace, qp.P.Verbose)
+	if cleanup {
+		return nil
+	}
+
 	defer func() {
 		qp.P.LogVerboseMessage("Cleaning up resources...\n")
 		err := api.KubectlDeleteVerbose(sa, namespace, qp.P.Verbose)
@@ -113,7 +130,7 @@ func (qp *QliksensePreflight) CheckCreateRB(namespace string, kubeConfigContents
 	qp.P.LogVerboseMessage("Preflight createRole check: \n")
 	qp.P.LogVerboseMessage("--------------------------- \n")
 	errStr := strings.Builder{}
-	err1 := qp.checkCreateEntity(namespace, "Role")
+	err1 := qp.checkCreateEntity(namespace, "Role", false)
 	if err1 != nil {
 		errStr.WriteString(err1.Error())
 		errStr.WriteString("\n")
@@ -125,7 +142,7 @@ func (qp *QliksensePreflight) CheckCreateRB(namespace string, kubeConfigContents
 	// create a roleBinding
 	qp.P.LogVerboseMessage("Preflight rolebinding check: \n")
 	qp.P.LogVerboseMessage("---------------------------- \n")
-	err2 := qp.checkCreateEntity(namespace, "RoleBinding")
+	err2 := qp.checkCreateEntity(namespace, "RoleBinding", false)
 	if err2 != nil {
 		errStr.WriteString(err2.Error())
 		errStr.WriteString("\n")
@@ -137,7 +154,7 @@ func (qp *QliksensePreflight) CheckCreateRB(namespace string, kubeConfigContents
 	// create a service account
 	qp.P.LogVerboseMessage("Preflight serviceaccount check: \n")
 	qp.P.LogVerboseMessage("------------------------------- \n")
-	err3 := qp.checkCreateEntity(namespace, "ServiceAccount")
+	err3 := qp.checkCreateEntity(namespace, "ServiceAccount", false)
 	if err3 != nil {
 		errStr.WriteString(err3.Error())
 		errStr.WriteString("\n")

pkg/qliksense/export.go

@@ -1,71 +0,0 @@
-package qliksense
-
-import (
-	"archive/zip"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-func (q *Qliksense) ExportContext(context string, output string) error {
-	qliksenseContextsDir := filepath.Join(q.QliksenseHome, QliksenseContextsDir)
-	qliksenseContextFile := filepath.Join(qliksenseContextsDir, context)
-	qliksenseSecretsDir := filepath.Join(q.QliksenseHome, QliksenseSecretsDir, QliksenseContextsDir)
-	qliksenseSecretsFile := filepath.Join(qliksenseSecretsDir, context)
-	// files := []string{qliksenseContextFile, qliksenseSecretsFile}
-
-	fmt.Println(q.QliksenseHome)
-	fmt.Println(qliksenseSecretsFile)
-	fmt.Println(qliksenseContextFile)
-
-	filename := "result.zip"
-	destinationFile, err := os.Create(output + "/" + filename)
-	var folders []string
-	if err != nil {
-		return err
-	}
-	folders = append(folders, qliksenseContextFile, qliksenseSecretsFile)
-	if err := RecursiveZip(folders, destinationFile); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func RecursiveZip(pathToZip []string, destinationFile *os.File) error {
-s	myZip := zip.NewWriter(destinationFile)
-	for _, element := range pathToZip {
-		err := filepath.Walk(element, func(filePath string, info os.FileInfo, err error) error {
-			if info.IsDir() {
-				return nil
-			}
-			if err != nil {
-				return err
-			}
-			relPath := strings.TrimPrefix(filePath, element)
-			zipFile, err := myZip.Create(relPath)
-			if err != nil {
-				return err
-			}
-			fsFile, err := os.Open(filePath)
-			if err != nil {
-				return err
-			}
-			_, err = io.Copy(zipFile, fsFile)
-			if err != nil {
-				return err
-			}
-			return nil
-		})xs
-		if err != nil {
-			return err
-		}
-	}
-	err := myZip.Close()
-	if err != nil {
-		return err
-	}
-	return nil
-}