init

cmd/qliksense/export.go

@@ -0,0 +1,27 @@
+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, false); err != nil {
+			if err = qp.CheckDns(namespace, kubeConfigContents); 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, false); err != nil {
+			if err = qp.CheckDeployment(namespace, kubeConfigContents); 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, false); err != nil {
+			if err = qp.CheckService(namespace, kubeConfigContents); 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, false); err != nil {
+			if err = qp.CheckPod(namespace, kubeConfigContents); 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, false); err != nil {
+			if err = qp.CheckCreateRole(namespace); 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, false); err != nil {
+			if err = qp.CheckCreateRoleBinding(namespace); 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, false); err != nil {
+			if err = qp.CheckCreateServiceAccount(namespace); 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, false); err != nil {
+			if err = qp.CheckMongo(kubeConfigContents, namespace, preflightOpts); err != nil {
 				fmt.Fprintf(out, "%s\n", Red("Preflight mongo check FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
@@ -436,42 +436,3 @@ 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,6 +202,9 @@ 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))
@@ -220,7 +223,6 @@ 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,7 +34,9 @@ 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, false); err != nil {
+	if err := qp.CheckDeployment(namespace, kubeConfigContents); 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, false); err != nil {
+	if err := qp.CheckService(namespace, kubeConfigContents); 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, false); err != nil {
+	if err := qp.CheckPod(namespace, kubeConfigContents); 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, false); err != nil {
+	if err := qp.CheckCreateRole(namespace); 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, false); err != nil {
+	if err := qp.CheckCreateRoleBinding(namespace); 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, false); err != nil {
+	if err := qp.CheckCreateServiceAccount(namespace); 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, false); err != nil {
+	if err := qp.CheckMongo(kubeConfigContents, namespace, preflightOpts); 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, false); err != nil {
+	if err := qp.CheckDns(namespace, kubeConfigContents); 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, cleanup bool) error {
+func (qp *QliksensePreflight) CheckDeployment(namespace string, kubeConfigContents []byte) error {
 	clientset, _, err := getK8SClientSet(kubeConfigContents, "")
 	if err != nil {
 		err = fmt.Errorf("Kube config error: %v\n", err)
@@ -14,80 +14,63 @@ func (qp *QliksensePreflight) CheckDeployment(namespace string, kubeConfigConten
 	}
 
 	// Deployment check
-	if !cleanup {
+	qp.P.LogVerboseMessage("Preflight deployment check: \n")
-		qp.P.LogVerboseMessage("Preflight deployment check: \n")
+	qp.P.LogVerboseMessage("--------------------------- \n")
-		qp.P.LogVerboseMessage("--------------------------- \n")
+	err = qp.checkPfDeployment(clientset, namespace, "deployment-preflight-check")
-	}
-	err = qp.checkPfDeployment(clientset, namespace, cleanup)
 	if err != nil {
 		qp.P.LogVerboseMessage("Preflight Deployment check: FAILED\n")
 		return err
 	}
-	if !cleanup {
+	qp.P.LogVerboseMessage("Completed preflight deployment check\n")
-		qp.P.LogVerboseMessage("Completed preflight deployment check\n")
-	}
 
 	return nil
 }
 
-func (qp *QliksensePreflight) CheckService(namespace string, kubeConfigContents []byte, cleanup bool) error {
+func (qp *QliksensePreflight) CheckService(namespace string, kubeConfigContents []byte) error {
 	clientset, _, err := getK8SClientSet(kubeConfigContents, "")
 	if err != nil {
 		err = fmt.Errorf("unable to create a kubernetes client: %v\n", err)
 		return err
 	}
 	// Service check
-	if !cleanup {
+	qp.P.LogVerboseMessage("Preflight service check: \n")
-		qp.P.LogVerboseMessage("Preflight service check: \n")
+	qp.P.LogVerboseMessage("------------------------ \n")
-		qp.P.LogVerboseMessage("------------------------ \n")
+	err = qp.checkPfService(clientset, namespace)
-	}
-	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, cleanup bool) error {
+func (qp *QliksensePreflight) CheckPod(namespace string, kubeConfigContents []byte) 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
-	if !cleanup {
+	qp.P.LogVerboseMessage("Preflight pod check: \n")
-		qp.P.LogVerboseMessage("Preflight pod check: \n")
+	qp.P.LogVerboseMessage("-------------------- \n")
-		qp.P.LogVerboseMessage("-------------------- \n")
+	err = qp.checkPfPod(clientset, namespace)
-	}
-	err = qp.checkPfPod(clientset, namespace, cleanup)
 	if err != nil {
 		qp.P.LogVerboseMessage("Preflight Pod check: FAILED\n")
 		return err
 	}
-	if !cleanup {
+	qp.P.LogVerboseMessage("Completed preflight pod check\n")
-		qp.P.LogVerboseMessage("Completed preflight pod check\n")
-	}
 	return nil
 }
 
-func (qp *QliksensePreflight) checkPfPod(clientset *kubernetes.Clientset, namespace string, cleanup bool) error {
+func (qp *QliksensePreflight) checkPfPod(clientset *kubernetes.Clientset, namespace string) error {
-	// delete the pod we are going to create, if it already exists in the cluster
+	// create a pod
 	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)
@@ -104,14 +87,9 @@ func (qp *QliksensePreflight) checkPfPod(clientset *kubernetes.Clientset, namesp
 	return nil
 }
 
-func (qp *QliksensePreflight) checkPfService(clientset *kubernetes.Clientset, namespace string, cleanup bool) error {
+func (qp *QliksensePreflight) checkPfService(clientset *kubernetes.Clientset, namespace string) 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
+	serviceName := "svc-pf-check"
 	pfService, err := qp.createPreflightTestService(clientset, namespace, serviceName)
 	if err != nil {
 		err = fmt.Errorf("unable to create service - %v\n", err)
@@ -128,14 +106,7 @@ func (qp *QliksensePreflight) checkPfService(clientset *kubernetes.Clientset, na
 	return nil
 }
 
-func (qp *QliksensePreflight) checkPfDeployment(clientset *kubernetes.Clientset, namespace string, cleanup bool) error {
+func (qp *QliksensePreflight) checkPfDeployment(clientset *kubernetes.Clientset, namespace, depName string) 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,8 +3,6 @@ package preflight
 import (
 	"fmt"
 	"strings"
-
-	"k8s.io/client-go/kubernetes"
 )
 
 const (
@@ -12,32 +10,21 @@ const (
 	netcat = "netcat"
 )
 
-func (qp *QliksensePreflight) CheckDns(namespace string, kubeConfigContents []byte, cleanup bool) error {
+func (qp *QliksensePreflight) CheckDns(namespace string, kubeConfigContents []byte) error {
-	depName := "dep-dns-preflight-check"
+	qp.P.LogVerboseMessage("Preflight DNS check: \n")
-	serviceName := "svc-dns-pf-check"
+	qp.P.LogVerboseMessage("------------------- \n")
-	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)
@@ -50,6 +37,7 @@ 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)
@@ -58,13 +46,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)
@@ -95,16 +83,9 @@ func (qp *QliksensePreflight) CheckDns(namespace string, kubeConfigContents []by
 		err = fmt.Errorf("Expected response not found\n")
 		return err
 	}
-	if !cleanup {
+
-		qp.P.LogVerboseMessage("Completed preflight DNS check\n")
+	qp.P.LogVerboseMessage("Completed preflight DNS check\n")
-		qp.P.LogVerboseMessage("Cleaning up resources...\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,12 +15,11 @@ const (
 	mongo = "mongo"
 )
 
-func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions, cleanup bool) error {
+func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions) error {
-	if !cleanup {
+	qp.P.LogVerboseMessage("Preflight mongodb check: \n")
-		qp.P.LogVerboseMessage("Preflight mongodb check: \n")
+	qp.P.LogVerboseMessage("------------------------ \n")
-		qp.P.LogVerboseMessage("------------------------ \n")
+
-	}
+	if preflightOpts.MongoOptions.MongodbUrl == "" {
-	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)
@@ -40,52 +39,43 @@ func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace st
 		}
 		preflightOpts.MongoOptions.MongodbUrl = decryptedCR.Spec.GetFromSecrets("qliksense", "mongoDbUri")
 	}
-	if !cleanup {
+
-		qp.P.LogVerboseMessage("MongodbUrl: %s\n", preflightOpts.MongoOptions.MongodbUrl)
+	qp.P.LogVerboseMessage("MongodbUrl: %s\n", preflightOpts.MongoOptions.MongodbUrl)
-	}
+	if err := qp.mongoConnCheck(kubeConfigContents, namespace, preflightOpts); err != nil {
-	if err := qp.mongoConnCheck(kubeConfigContents, namespace, preflightOpts, cleanup); err != nil {
 		return err
 	}
-	if !cleanup {
+	qp.P.LogVerboseMessage("Completed preflight mongodb check\n")
-		qp.P.LogVerboseMessage("Completed preflight mongodb check\n")
-	}
 	return nil
 }
 
-func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions, cleanup bool) error {
+func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions) error {
-	caCertSecretName := "preflight-mongo-test-cacert"
+	var caCertSecretName, clientCertSecretName string
-	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.Name)
+		defer qp.deleteK8sSecret(clientset, namespace, caCertSecret)
 		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.Name)
+		defer qp.deleteK8sSecret(clientset, namespace, clientCertSecret)
 		secrets = append(secrets, clientCertSecretName)
 	}
 
@@ -117,17 +107,18 @@ 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, mongoPodName, imageName, secrets, commandToRun)
+	mongoPod, err := qp.createPreflightTestPod(clientset, namespace, podName, imageName, secrets, commandToRun)
 	if err != nil {
 		err = fmt.Errorf("unable to create pod : %v\n", err)
 		return err
 	}
-	defer qp.deletePod(clientset, namespace, mongoPodName)
+	defer qp.deletePod(clientset, namespace, podName)
 
 	if err := waitForPod(clientset, namespace, mongoPod); err != nil {
 		return err
@@ -166,9 +157,3 @@ 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,6 +288,7 @@ 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)
@@ -567,20 +568,18 @@ func (qp *QliksensePreflight) createPfRole(clientset *kubernetes.Clientset, name
 	return role, nil
 }
 
-func (qp *QliksensePreflight) deleteRole(clientset *kubernetes.Clientset, namespace string, roleName string) error {
+func (qp *QliksensePreflight) deleteRole(clientset *kubernetes.Clientset, namespace string, role *v1beta1.Role) {
 	rolesClient := clientset.RbacV1beta1().Roles(namespace)
 
 	deletePolicy := v1.DeletePropagationForeground
 	deleteOptions := v1.DeleteOptions{
 		PropagationPolicy: &deletePolicy,
 	}
-	err := rolesClient.Delete(roleName, &deleteOptions)
+	err := rolesClient.Delete(role.GetName(), &deleteOptions)
 	if err != nil {
-		log.Printf("Error: %v\n", err)
+		log.Fatal(err)
-		return err
 	}
-	qp.P.LogVerboseMessage("Deleted role: %s\n\n", roleName)
+	qp.P.LogVerboseMessage("Deleted role: %s\n\n", role.Name)
-	return nil
 }
 
 func (qp *QliksensePreflight) createPfRoleBinding(clientset *kubernetes.Clientset, namespace, roleBindingName string) (*v1beta1.RoleBinding, error) {
@@ -620,20 +619,18 @@ func (qp *QliksensePreflight) createPfRoleBinding(clientset *kubernetes.Clientse
 	return roleBinding, nil
 }
 
-func (qp *QliksensePreflight) deleteRoleBinding(clientset *kubernetes.Clientset, namespace string, roleBindingName string) error {
+func (qp *QliksensePreflight) deleteRoleBinding(clientset *kubernetes.Clientset, namespace string, roleBinding *v1beta1.RoleBinding) {
 	roleBindingClient := clientset.RbacV1beta1().RoleBindings(namespace)
 
 	deletePolicy := v1.DeletePropagationForeground
 	deleteOptions := v1.DeleteOptions{
 		PropagationPolicy: &deletePolicy,
 	}
-	err := roleBindingClient.Delete(roleBindingName, &deleteOptions)
+	err := roleBindingClient.Delete(roleBinding.GetName(), &deleteOptions)
 	if err != nil {
-		log.Printf("Error: %v\n", err)
+		log.Fatal(err)
-		return err
 	}
-	qp.P.LogVerboseMessage("Deleted RoleBinding: %s\n\n", roleBindingName)
+	qp.P.LogVerboseMessage("Deleted RoleBinding: %s\n\n", roleBinding.Name)
-	return nil
 }
 
 func (qp *QliksensePreflight) createPfServiceAccount(clientset *kubernetes.Clientset, namespace, serviceAccountName string) (*apiv1.ServiceAccount, error) {
@@ -660,20 +657,18 @@ func (qp *QliksensePreflight) createPfServiceAccount(clientset *kubernetes.Clien
 	return serviceAccount, nil
 }
 
-func (qp *QliksensePreflight) deleteServiceAccount(clientset *kubernetes.Clientset, namespace string, serviceAccountName string) error {
+func (qp *QliksensePreflight) deleteServiceAccount(clientset *kubernetes.Clientset, namespace string, serviceAccount *apiv1.ServiceAccount) {
 	serviceAccountClient := clientset.CoreV1().ServiceAccounts(namespace)
 
 	deletePolicy := v1.DeletePropagationForeground
 	deleteOptions := v1.DeleteOptions{
 		PropagationPolicy: &deletePolicy,
 	}
-	err := serviceAccountClient.Delete(serviceAccountName, &deleteOptions)
+	err := serviceAccountClient.Delete(serviceAccount.GetName(), &deleteOptions)
 	if err != nil {
-		log.Printf("Error: %v\n", err)
+		log.Fatal(err)
-		return err
 	}
-	qp.P.LogVerboseMessage("Deleted ServiceAccount: %s\n\n", serviceAccountName)
+	qp.P.LogVerboseMessage("Deleted ServiceAccount: %s\n\n", serviceAccount.Name)
-	return nil
 }
 
 func (qp *QliksensePreflight) createPreflightTestSecret(clientset *kubernetes.Clientset, namespace, secretName string, secretData []byte) (*apiv1.Secret, error) {
@@ -704,42 +699,16 @@ func (qp *QliksensePreflight) createPreflightTestSecret(clientset *kubernetes.Cl
 	return secret, nil
 }
 
-func (qp *QliksensePreflight) deleteK8sSecret(clientset *kubernetes.Clientset, namespace string, secretName string) error {
+func (qp *QliksensePreflight) deleteK8sSecret(clientset *kubernetes.Clientset, namespace string, k8sSecret *apiv1.Secret) {
 	secretClient := clientset.CoreV1().Secrets(namespace)
 
 	deletePolicy := v1.DeletePropagationForeground
 	deleteOptions := v1.DeleteOptions{
 		PropagationPolicy: &deletePolicy,
 	}
-	err := secretClient.Delete(secretName, &deleteOptions)
+	err := secretClient.Delete(k8sSecret.GetName(), &deleteOptions)
 	if err != nil {
-		return err
+		log.Fatal(err)
 	}
-	qp.P.LogVerboseMessage("Deleted Secret: %s\n", secretName)
+	qp.P.LogVerboseMessage("Deleted Secret: %s\n", k8sSecret.Name)
-	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,59 +11,48 @@ import (
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 )
 
-func (qp *QliksensePreflight) CheckCreateRole(namespace string, cleanup bool) error {
+var resultYamlBytes = []byte("")
+
+func (qp *QliksensePreflight) CheckCreateRole(namespace string) error {
 	// create a Role
-	if !cleanup {
+	qp.P.LogVerboseMessage("Preflight role check: \n")
-		qp.P.LogVerboseMessage("Preflight role check: \n")
+	qp.P.LogVerboseMessage("--------------------- \n")
-		qp.P.LogVerboseMessage("--------------------- \n")
+	err := qp.checkCreateEntity(namespace, "Role")
-	}
-	err := qp.checkCreateEntity(namespace, "Role", cleanup)
 	if err != nil {
 		return err
 	}
-	if !cleanup {
+	qp.P.LogVerboseMessage("Completed preflight role check\n")
-		qp.P.LogVerboseMessage("Completed preflight role check\n")
-	}
 	return nil
 }
 
-func (qp *QliksensePreflight) CheckCreateRoleBinding(namespace string, cleanup bool) error {
+func (qp *QliksensePreflight) CheckCreateRoleBinding(namespace string) error {
 	// create a RoleBinding
-	if !cleanup {
+	qp.P.LogVerboseMessage("Preflight rolebinding check: \n")
-		qp.P.LogVerboseMessage("Preflight rolebinding check: \n")
+	qp.P.LogVerboseMessage("---------------------------- \n")
-		qp.P.LogVerboseMessage("---------------------------- \n")
+	err := qp.checkCreateEntity(namespace, "RoleBinding")
-	}
-	err := qp.checkCreateEntity(namespace, "RoleBinding", cleanup)
 	if err != nil {
 		return err
 	}
-	if !cleanup {
+	qp.P.LogVerboseMessage("Completed preflight rolebinding check\n")
-		qp.P.LogVerboseMessage("Completed preflight rolebinding check\n")
-	}
 	return nil
 }
 
-func (qp *QliksensePreflight) CheckCreateServiceAccount(namespace string, cleanup bool) error {
+func (qp *QliksensePreflight) CheckCreateServiceAccount(namespace string) error {
 	// create a service account
-	if !cleanup {
+	qp.P.LogVerboseMessage("Preflight serviceaccount check: \n")
-		qp.P.LogVerboseMessage("Preflight serviceaccount check: \n")
+	qp.P.LogVerboseMessage("------------------------------- \n")
-		qp.P.LogVerboseMessage("------------------------------- \n")
+	err := qp.checkCreateEntity(namespace, "ServiceAccount")
-	}
-	err := qp.checkCreateEntity(namespace, "ServiceAccount", cleanup)
 	if err != nil {
 		return err
 	}
-	if !cleanup {
+	qp.P.LogVerboseMessage("Completed preflight serviceaccount check\n")
-		qp.P.LogVerboseMessage("Completed preflight serviceaccount check\n")
-	}
 	return nil
 }
-func (qp *QliksensePreflight) checkCreateEntity(namespace, entityToTest string, cleanup bool) error {
+func (qp *QliksensePreflight) checkCreateEntity(namespace, entityToTest string) 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 {
@@ -100,12 +89,6 @@ 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)
@@ -130,7 +113,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", false)
+	err1 := qp.checkCreateEntity(namespace, "Role")
 	if err1 != nil {
 		errStr.WriteString(err1.Error())
 		errStr.WriteString("\n")
@@ -142,7 +125,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", false)
+	err2 := qp.checkCreateEntity(namespace, "RoleBinding")
 	if err2 != nil {
 		errStr.WriteString(err2.Error())
 		errStr.WriteString("\n")
@@ -154,7 +137,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", false)
+	err3 := qp.checkCreateEntity(namespace, "ServiceAccount")
 	if err3 != nil {
 		errStr.WriteString(err3.Error())
 		errStr.WriteString("\n")

pkg/qliksense/export.go

@@ -0,0 +1,71 @@
+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
+}