Upgrading kustomize API to version qlik/v0.0.28 (#408)

* Pinned netcat, nginx and preflight-mongo images to specific tags

cmd/qliksense/apply.go

@@ -1,74 +1,45 @@
 package main
 
 import (
-	"bytes"
-	"errors"
-	"fmt"
-
-	qapi "github.com/qlik-oss/sense-installer/pkg/api"
-
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 	"github.com/spf13/cobra"
 )
 
 func applyCmd(q *qliksense.Qliksense) *cobra.Command {
-	opts := &qliksense.InstallCommandOptions{}
+	opts := &qliksense.InstallCommandOptions{
+		CleanPatchFiles: true,
+	}
 	filePath := ""
-	keepPatchFiles, pull, push := false, false, false
 	c := &cobra.Command{
 		Use:     "apply",
 		Short:   "install qliksense based on provided cr file",
 		Long:    `install qliksense based on provided cr file`,
 		Example: `qliksense apply -f file_name or cat cr_file | qliksense apply -f -`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runLoadOrApplyCommandE(cmd, func(crBytes []byte) error {
-				if cr, crBytesWithEula, err := getCrWithEulaInserted(crBytes); err != nil {
-					return err
-				} else if err := validatePullPushFlagsOnApply(cr, pull, push); err != nil {
-					return err
-				} else {
-					return q.ApplyCRFromReader(bytes.NewReader(crBytesWithEula), opts, keepPatchFiles, true, pull, push)
-				}
-			})
+			return apply(q, cmd, opts)
 		},
 	}
 
 	f := c.Flags()
 	f.StringVarP(&filePath, "file", "f", "", "Install from a CR file")
-	c.MarkFlagRequired("file")
 	f.StringVarP(&opts.StorageClass, "storageClass", "s", "", "Storage class for qliksense")
 	f.StringVarP(&opts.MongodbUri, "mongodbUri", "m", "", "mongodbUri for qliksense (i.e. mongodb://qlik-default-mongodb:27017/qliksense?ssl=false)")
 	f.StringVarP(&opts.RotateKeys, "rotateKeys", "r", "", "Rotate JWT keys for qliksense (yes:rotate keys/ no:use exising keys from cluster/ None: use default EJSON_KEY from env")
-	f.BoolVar(&keepPatchFiles, keepPatchFilesFlagName, keepPatchFiles, keepPatchFilesFlagUsage)
-	f.BoolVarP(&pull, pullFlagName, pullFlagShorthand, pull, pullFlagUsage)
-	f.BoolVarP(&push, pushFlagName, pushFlagShorthand, push, pushFlagUsage)
-
-	eulaPreRunHooks.addValidator(fmt.Sprintf("%v %v", rootCommandName, c.Name()), loadOrApplyCommandEulaPreRunHook)
+	f.BoolVar(&opts.CleanPatchFiles, cleanPatchFilesFlagName, opts.CleanPatchFiles, cleanPatchFilesFlagUsage)
+	f.BoolVarP(&opts.Pull, pullFlagName, pullFlagShorthand, opts.Pull, pullFlagUsage)
+	f.BoolVarP(&opts.Push, pushFlagName, pushFlagShorthand, opts.Push, pushFlagUsage)
+	f.StringVarP(&opts.AcceptEULA, "acceptEULA", "a", opts.AcceptEULA, "Accept EULA for qliksense")
 
+	if err := c.MarkFlagRequired("file"); err != nil {
+		panic(err)
+	}
 	return c
 }
 
-func validatePullPushFlagsOnApply(cr *qapi.QliksenseCR, pull, push bool) error {
-	if pull && !push {
-		fmt.Printf("WARNING: pulling images without pushing them")
-	}
-	if push {
-		if registry := cr.Spec.GetImageRegistry(); registry == "" {
-			return errors.New("no image registry set in the CR; to set it use: qliksense config set-image-registry")
-		}
-	}
-	return nil
-}
-
-func getCrWithEulaInserted(crBytes []byte) (*qapi.QliksenseCR, []byte, error) {
-	if cr, err := qapi.CreateCRObjectFromString(string(crBytes)); err != nil {
-		return nil, nil, err
+func apply(q *qliksense.Qliksense, cmd *cobra.Command, opts *qliksense.InstallCommandOptions) error {
+	if crBytes, err := getCrBytesFromFileFlag(cmd); err != nil {
+		return err
 	} else {
-		cr.SetEULA("yes")
-		if crBytesWithEula, err := qapi.K8sToYaml(cr); err != nil {
-			return nil, nil, err
-		} else {
-			return cr, crBytesWithEula, nil
-		}
+		return q.ApplyCRFromBytes(crBytes, opts, true)
 	}
 }

cmd/qliksense/eula.go

@@ -1,109 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/mattn/go-tty"
-	qapi "github.com/qlik-oss/sense-installer/pkg/api"
-	"github.com/qlik-oss/sense-installer/pkg/qliksense"
-	"github.com/spf13/cobra"
-)
-
-type eulaPreRunHooksT struct {
-	validators              map[string]func(cmd *cobra.Command, q *qliksense.Qliksense) (bool, error)
-	postValidationArtifacts map[string]interface{}
-}
-
-func (e *eulaPreRunHooksT) addValidator(command string, validator func(cmd *cobra.Command, q *qliksense.Qliksense) (bool, error)) {
-	e.validators[command] = validator
-}
-
-func (e *eulaPreRunHooksT) getValidator(command string) func(cmd *cobra.Command, q *qliksense.Qliksense) (bool, error) {
-	if validator, ok := e.validators[command]; ok {
-		return validator
-	}
-	return nil
-}
-
-func (e *eulaPreRunHooksT) addPostValidationArtifact(artifactName string, artifact interface{}) {
-	e.postValidationArtifacts[artifactName] = artifact
-}
-
-func (e *eulaPreRunHooksT) getPostValidationArtifact(artifactName string) interface{} {
-	if artifact, ok := e.postValidationArtifacts[artifactName]; ok {
-		return artifact
-	}
-	return nil
-}
-
-var eulaEnforced = os.Getenv("QLIKSENSE_EULA_ENFORCE") == "true"
-var eulaText = "Please read the end user license agreement at: https://www.qlik.com/us/legal/license-terms"
-var eulaPrompt = "Do you accept our EULA? (y/n): "
-var eulaErrorInstruction = `You must enter "y" to continue or execute the command with the acceptEULA flag set to "yes"`
-var eulaPreRunHooks = eulaPreRunHooksT{
-	validators:              make(map[string]func(cmd *cobra.Command, q *qliksense.Qliksense) (bool, error)),
-	postValidationArtifacts: make(map[string]interface{}),
-}
-
-func commandAlwaysRequiresEulaAcceptance(commandName string) bool {
-	return commandName == fmt.Sprintf("%v install", rootCommandName) ||
-		commandName == fmt.Sprintf("%v apply", rootCommandName)
-}
-
-func globalEulaPreRun(cmd *cobra.Command, q *qliksense.Qliksense) {
-	if isEulaEnforced(cmd.CommandPath()) {
-		eulaFlagValue := strings.TrimSpace(strings.ToLower(cmd.Flag("acceptEULA").Value.String()))
-		if eulaFlagValue != "" && eulaFlagValue != "yes" {
-			doEnforceEula()
-		} else if eulaFlagValue == "" {
-			if eulaPreRunHook := eulaPreRunHooks.getValidator(cmd.CommandPath()); eulaPreRunHook != nil {
-				if eulaAccepted, err := eulaPreRunHook(cmd, q); err != nil {
-					panic(err)
-				} else if !eulaAccepted {
-					doEnforceEula()
-				}
-			} else if qConfig, err := qapi.NewQConfigE(q.QliksenseHome); err != nil {
-				doEnforceEula()
-			} else if qcr, err := qConfig.GetCurrentCR(); err != nil || !qcr.IsEULA() {
-				doEnforceEula()
-			}
-		}
-	}
-}
-
-func globalEulaPostRun(cmd *cobra.Command, q *qliksense.Qliksense) {
-	if isEulaEnforced(cmd.CommandPath()) {
-		if err := q.SetEulaAccepted(); err != nil {
-			panic(err)
-		}
-	}
-}
-
-func isEulaEnforced(commandName string) bool {
-	return eulaEnforced || commandAlwaysRequiresEulaAcceptance(commandName)
-}
-
-func doEnforceEula() {
-	fmt.Println(eulaText)
-	fmt.Print(eulaPrompt)
-	answer := readRuneFromTty()
-	if strings.ToLower(answer) != "y" {
-		fmt.Println(eulaErrorInstruction)
-		os.Exit(1)
-	}
-}
-
-func readRuneFromTty() string {
-	t, err := tty.Open()
-	if err != nil {
-		panic(err)
-	}
-	defer t.Close()
-	answer, err := t.ReadString()
-	if err != nil {
-		panic(err)
-	}
-	return answer
-}

cmd/qliksense/install.go

@@ -1,19 +1,15 @@
 package main
 
 import (
-	"bytes"
-	"fmt"
-
-	qapi "github.com/qlik-oss/sense-installer/pkg/api"
-
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 	"github.com/spf13/cobra"
 )
 
 func installCmd(q *qliksense.Qliksense) *cobra.Command {
-	opts := &qliksense.InstallCommandOptions{}
+	opts := &qliksense.InstallCommandOptions{
+		CleanPatchFiles: true,
+	}
 	filePath := ""
-	keepPatchFiles, pull, push := false, false, false
 	c := &cobra.Command{
 		Use:   "install",
 		Short: "install a qliksense release",
@@ -22,76 +18,29 @@ func installCmd(q *qliksense.Qliksense) *cobra.Command {
 		# qliksense install -f file_name or cat cr_file | qliksense install -f -
 		`,
 		RunE: func(cmd *cobra.Command, args []string) error {
+			version := ""
+			if len(args) != 0 {
+				version = args[0]
+			}
+
 			if filePath != "" {
-				return runLoadOrApplyCommandE(cmd, func(crBytes []byte) error {
-					if cr, crBytesWithEula, err := getCrWithEulaInserted(crBytes); err != nil {
-						return err
-					} else if err := validatePullPushFlagsOnApply(cr, pull, push); err != nil {
-						return err
-					} else {
-						return q.ApplyCRFromReader(bytes.NewReader(crBytesWithEula), opts, keepPatchFiles, true, pull, push)
-					}
-				})
+				return apply(q, cmd, opts)
 			} else {
-				version := ""
-				if len(args) != 0 {
-					version = args[0]
-				}
-				if err := validatePullPushFlagsOnInstall(q, pull, push); err != nil {
-					return err
-				}
-				if pull {
-					fmt.Println("Pulling images...")
-					if err := q.PullImages(version, ""); err != nil {
-						return err
-					}
-				}
-				if push {
-					fmt.Println("Pushing images...")
-					if err := q.PushImagesForCurrentCR(); err != nil {
-						return err
-					}
-				}
-				return q.InstallQK8s(version, opts, keepPatchFiles)
+				return q.InstallQK8s(version, opts)
 			}
 		},
 	}
 
-	eulaPreRunHooks.addValidator(fmt.Sprintf("%v %v", rootCommandName, c.Name()), func(cmd *cobra.Command, q *qliksense.Qliksense) (b bool, err error) {
-		if filePath != "" {
-			return loadOrApplyCommandEulaPreRunHook(cmd, q)
-		} else if qConfig, err := qapi.NewQConfigE(q.QliksenseHome); err != nil {
-			return false, nil
-		} else if qcr, err := qConfig.GetCurrentCR(); err != nil {
-			return false, nil
-		} else {
-			return qcr.IsEULA(), nil
-		}
-	})
-
 	f := c.Flags()
+	f.StringVarP(&filePath, "file", "f", "", "Install from a CR file")
 	f.StringVarP(&opts.StorageClass, "storageClass", "s", "", "Storage class for qliksense")
 	f.StringVarP(&opts.MongodbUri, "mongodbUri", "m", "", "mongodbUri for qliksense (i.e. mongodb://qlik-default-mongodb:27017/qliksense?ssl=false)")
 	f.StringVarP(&opts.RotateKeys, "rotateKeys", "r", "", "Rotate JWT keys for qliksense (yes:rotate keys/ no:use exising keys from cluster/ None: use default EJSON_KEY from env")
-	f.BoolVar(&keepPatchFiles, keepPatchFilesFlagName, keepPatchFiles, keepPatchFilesFlagUsage)
-	f.StringVarP(&filePath, "file", "f", "", "Install from a CR file")
-
+	f.BoolVar(&opts.CleanPatchFiles, cleanPatchFilesFlagName, opts.CleanPatchFiles, cleanPatchFilesFlagUsage)
+	f.BoolVarP(&opts.Pull, pullFlagName, pullFlagShorthand, opts.Pull, pullFlagUsage)
+	f.BoolVarP(&opts.Push, pushFlagName, pushFlagShorthand, opts.Push, pushFlagUsage)
+	f.StringVarP(&opts.AcceptEULA, "acceptEULA", "a", opts.AcceptEULA, "Accept EULA for qliksense")
 	f.BoolVarP(&opts.DryRun, "dry-run", "", false, "Dry run will generate the patches without rotating keys")
 
-	f.BoolVarP(&pull, pullFlagName, pullFlagShorthand, pull, pullFlagUsage)
-	f.BoolVarP(&push, pushFlagName, pushFlagShorthand, push, pushFlagUsage)
-
 	return c
 }
-
-func validatePullPushFlagsOnInstall(q *qliksense.Qliksense, pull, push bool) error {
-	if pull && !push {
-		fmt.Printf("WARNING: pulling images without pushing them")
-	}
-	if push {
-		if err := ensureImageRegistrySetInCR(q); err != nil {
-			return err
-		}
-	}
-	return nil
-}

cmd/qliksense/load.go

@@ -1,8 +1,6 @@
 package main
 
 import (
-	"bytes"
-	"fmt"
 	"io/ioutil"
 	"os"
 
@@ -20,69 +18,48 @@ func loadCrFile(q *qliksense.Qliksense) *cobra.Command {
 		Long:    `load a CR a file and create necessary structure for future use`,
 		Example: `qliksense load -f file_name or cat cr_file | qliksense load -f -`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runLoadOrApplyCommandE(cmd, func(buffer []byte) error {
-				return q.LoadCr(bytes.NewReader(buffer), overwriteExistingContext)
-			})
+			if crBytes, err := getCrBytesFromFileFlag(cmd); err != nil {
+				return err
+			} else {
+				return q.LoadCr(crBytes, overwriteExistingContext)
+			}
 		},
 	}
 	f := c.Flags()
 	f.StringVarP(&filePath, "file", "f", "", "File to load CR from")
-	c.MarkFlagRequired("file")
 	f.BoolVarP(&overwriteExistingContext, "overwrite", "o", overwriteExistingContext, "Overwrite any existing contexts with the same name")
 
-	eulaPreRunHooks.addValidator(fmt.Sprintf("%v %v", rootCommandName, c.Name()), loadOrApplyCommandEulaPreRunHook)
+	if err := c.MarkFlagRequired("file"); err != nil {
+		panic(err)
+	}
 	return c
 }
 
-func getCrFileFromFlag(cmd *cobra.Command, flagName string) (*os.File, error) {
-	filePath := cmd.Flag(flagName).Value.String()
-	if filePath == "-" {
-		if !isInputFromPipe() {
-			return nil, errors.New("No input pipe present")
-		}
-		return os.Stdin, nil
-	}
-	file, e := os.Open(filePath)
-	if e != nil {
-		return nil, errors.Wrapf(e,
-			"unable to read the file %s", filePath)
-	}
-	return file, nil
-}
-
 func isInputFromPipe() bool {
 	fileInfo, _ := os.Stdin.Stat()
 	return fileInfo.Mode()&os.ModeCharDevice == 0
 }
 
-func loadOrApplyCommandEulaPreRunHook(cmd *cobra.Command, q *qliksense.Qliksense) (bool, error) {
-	file, err := getCrFileFromFlag(cmd, "file")
-	if err != nil {
-		return false, err
-	}
-	defer file.Close()
-
-	if crBytes, err := ioutil.ReadAll(file); err != nil {
-		return false, err
-	} else {
-		eulaPreRunHooks.addPostValidationArtifact("CR", crBytes)
-		return q.IsEulaAcceptedInCrFile(bytes.NewBuffer(crBytes))
-	}
-}
-
-func runLoadOrApplyCommandE(cmd *cobra.Command, callBack func(buffer []byte) error) error {
-	if crBytes := eulaPreRunHooks.getPostValidationArtifact("CR"); crBytes != nil {
-		return callBack(crBytes.([]byte))
-	} else {
-		file, err := getCrFileFromFlag(cmd, "file")
-		if err != nil {
-			return err
-		}
-		defer file.Close()
-		if crBytes, err := ioutil.ReadAll(file); err != nil {
-			return err
+func getCrFileFromFlag(cmd *cobra.Command, flagName string) (*os.File, error) {
+	filePath := cmd.Flag(flagName).Value.String()
+	if filePath == "-" {
+		if !isInputFromPipe() {
+			return nil, errors.New("No input pipe present")
 		} else {
-			return callBack(crBytes)
+			return os.Stdin, nil
 		}
+	} else if file, err := os.Open(filePath); err != nil {
+		return nil, errors.Wrapf(err, "unable to read the file %s", filePath)
+	} else {
+		return file, nil
+	}
+}
+
+func getCrBytesFromFileFlag(cmd *cobra.Command) ([]byte, error) {
+	if file, err := getCrFileFromFlag(cmd, "file"); err != nil {
+		return nil, err
+	} else {
+		defer file.Close()
+		return ioutil.ReadAll(file)
 	}
 }

cmd/qliksense/preflight.go

@@ -43,7 +43,7 @@ func pfDnsCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			// Preflight DNS check
 			namespace, kubeConfigContents, err := qp.CG.LoadKubeConfigAndNamespace()
 			if err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight DNS check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
@@ -51,11 +51,11 @@ func pfDnsCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 				namespace = "default"
 			}
 			if err = qp.CheckDns(namespace, kubeConfigContents, false); err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight DNS check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			fmt.Fprintf(out, "%s\n", Green("Preflight DNS check PASSED"))
+			fmt.Fprintf(out, "%s\n", Green("PASSED"))
 			return nil
 		},
 	}
@@ -81,16 +81,16 @@ func pfK8sVersionCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			// Preflight Kubernetes minimum version check
 			namespace, kubeConfigContents, err := qp.CG.LoadKubeConfigAndNamespace()
 			if err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight kubernetes minimum version check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
 			if err = qp.CheckK8sVersion(namespace, kubeConfigContents); err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight kubernetes minimum version check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			fmt.Fprintf(out, "%s\n", Green("Preflight kubernetes minimum version check PASSED"))
+			fmt.Fprintf(out, "%s\n", Green("PASSED"))
 			return nil
 		},
 	}
@@ -157,7 +157,7 @@ func pfDeploymentCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			// Preflight deployments check
 			namespace, kubeConfigContents, err := qp.CG.LoadKubeConfigAndNamespace()
 			if err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight deployment check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
@@ -165,11 +165,11 @@ func pfDeploymentCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 				namespace = "default"
 			}
 			if err = qp.CheckDeployment(namespace, kubeConfigContents, false); err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight deployment check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			fmt.Fprintf(out, "%s\n", Green("Preflight deployment check PASSED"))
+			fmt.Fprintf(out, "%s\n", Green("PASSED"))
 			return nil
 		},
 	}
@@ -195,7 +195,7 @@ func pfServiceCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			// Preflight service check
 			namespace, kubeConfigContents, err := qp.CG.LoadKubeConfigAndNamespace()
 			if err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight service check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
@@ -204,11 +204,11 @@ func pfServiceCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 				namespace = "default"
 			}
 			if err = qp.CheckService(namespace, kubeConfigContents, false); err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight service check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			fmt.Fprintf(out, "%s\n", Green("Preflight service check PASSED"))
+			fmt.Fprintf(out, "%s\n", Green("PASSED"))
 			return nil
 		},
 	}
@@ -234,7 +234,7 @@ func pfPodCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			// Preflight pod check
 			namespace, kubeConfigContents, err := qp.CG.LoadKubeConfigAndNamespace()
 			if err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight pod check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
@@ -242,11 +242,11 @@ func pfPodCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 				namespace = "default"
 			}
 			if err = qp.CheckPod(namespace, kubeConfigContents, false); err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight pod check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			fmt.Fprintf(out, "%s\n", Green("Preflight pod check PASSED"))
+			fmt.Fprintf(out, "%s\n", Green("PASSED"))
 			return nil
 		},
 	}
@@ -272,16 +272,16 @@ func pfCreateRoleCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			// Preflight role check
 			namespace, _, err := qp.CG.LoadKubeConfigAndNamespace()
 			if err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight role check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
 			if err = qp.CheckCreateRole(namespace, false); err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight role check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			fmt.Fprintf(out, "%s\n", Green("Preflight role check PASSED"))
+			fmt.Fprintf(out, "%s\n", Green("PASSED"))
 			return nil
 		},
 	}
@@ -307,16 +307,16 @@ func pfCreateRoleBindingCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			// Preflight createRoleBinding check
 			namespace, _, err := qp.CG.LoadKubeConfigAndNamespace()
 			if err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight rolebinding check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
 			if err = qp.CheckCreateRoleBinding(namespace, false); err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight rolebinding check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			fmt.Fprintf(out, "%s\n", Green("Preflight rolebinding check PASSED"))
+			fmt.Fprintf(out, "%s\n", Green("PASSED"))
 			return nil
 		},
 	}
@@ -342,16 +342,16 @@ func pfCreateServiceAccountCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			// Preflight createServiceAccount check
 			namespace, _, err := qp.CG.LoadKubeConfigAndNamespace()
 			if err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight ServiceAccount check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
 			if err = qp.CheckCreateServiceAccount(namespace, false); err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight ServiceAccount check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			fmt.Fprintf(out, "%s\n", Green("Preflight ServiceAccount check PASSED"))
+			fmt.Fprintf(out, "%s\n", Green("PASSED"))
 			return nil
 		},
 	}
@@ -376,16 +376,16 @@ func pfCreateAuthCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			// Preflight authcheck
 			namespace, kubeConfigContents, err := qp.CG.LoadKubeConfigAndNamespace()
 			if err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight authcheck FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
 			if err = qp.CheckCreateRB(namespace, kubeConfigContents); err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight authcheck FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			fmt.Fprintf(out, "%s\n", Green("Preflight authcheck PASSED"))
+			fmt.Fprintf(out, "%s\n", Green("PASSED"))
 			return nil
 		},
 	}
@@ -411,7 +411,7 @@ func pfMongoCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			// Preflight mongo check
 			namespace, kubeConfigContents, err := qp.CG.LoadKubeConfigAndNamespace()
 			if err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight mongo check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
@@ -419,11 +419,11 @@ func pfMongoCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 				namespace = "default"
 			}
 			if err = qp.CheckMongo(kubeConfigContents, namespace, preflightOpts, false); err != nil {
-				fmt.Fprintf(out, "%s\n", Red("Preflight mongo check FAILED"))
+				fmt.Fprintf(out, "%s\n", Red("FAILED"))
 				fmt.Printf("Error: %v\n", err)
 				return nil
 			}
-			fmt.Fprintf(out, "%s\n", Green("Preflight mongo check PASSED"))
+			fmt.Fprintf(out, "%s\n", Green("PASSED"))
 			return nil
 		},
 	}

cmd/qliksense/pull_push.go

@@ -1,9 +1,6 @@
 package main
 
 import (
-	"errors"
-
-	qapi "github.com/qlik-oss/sense-installer/pkg/api"
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 	"github.com/spf13/cobra"
 )
@@ -34,22 +31,8 @@ func pushQliksenseImages(q *qliksense.Qliksense) *cobra.Command {
 		Short:   "Push docker images for offline install",
 		Example: `qliksense push`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if err := ensureImageRegistrySetInCR(q); err != nil {
-				return err
-			} else {
-				return q.PushImagesForCurrentCR()
-			}
+			return q.PushImagesForCurrentCR()
 		},
 	}
 	return cmd
 }
-
-func ensureImageRegistrySetInCR(q *qliksense.Qliksense) error {
-	qConfig := qapi.NewQConfig(q.QliksenseHome)
-	if qcr, err := qConfig.GetCurrentCR(); err != nil {
-		return err
-	} else if registry := qcr.Spec.GetImageRegistry(); registry == "" {
-		return errors.New("no image registry set in the CR; to set it use: qliksense config set-image-registry")
-	}
-	return nil
-}

cmd/qliksense/root.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"fmt"
-	"io"
 	"log"
 	"os"
 	"path/filepath"
@@ -23,17 +22,17 @@ import (
 // qliksense <command>
 
 const (
-	qlikSenseHomeVar        = "QLIKSENSE_HOME"
-	qlikSenseDirVar         = ".qliksense"
-	keepPatchFilesFlagName  = "keep-config-repo-patches"
-	keepPatchFilesFlagUsage = "Keep config repo patch files (for debugging)"
-	pullFlagName            = "pull"
-	pullFlagShorthand       = "d"
-	pullFlagUsage           = "If using private docker registry, pull (download) all required Qliksense images before install"
-	pushFlagName            = "push"
-	pushFlagShorthand       = "u"
-	pushFlagUsage           = "If using private docker registry, push (upload) all downloaded Qliksense images to that registry before install"
-	rootCommandName         = "qliksense"
+	qlikSenseHomeVar         = "QLIKSENSE_HOME"
+	qlikSenseDirVar          = ".qliksense"
+	cleanPatchFilesFlagName  = "clean"
+	cleanPatchFilesFlagUsage = "Set --clean=false to keep any prior config repo file changes on install (for debugging)"
+	pullFlagName             = "pull"
+	pullFlagShorthand        = "d"
+	pullFlagUsage            = "If using private docker registry, pull (download) all required Qliksense images before install"
+	pushFlagName             = "push"
+	pushFlagShorthand        = "u"
+	pushFlagUsage            = "If using private docker registry, push (upload) all downloaded Qliksense images to that registry before install"
+	rootCommandName          = "qliksense"
 )
 
 func initAndExecute() error {
@@ -106,7 +105,6 @@ func getRootCmd(p *qliksense.Qliksense) *cobra.Command {
 		Args:  cobra.ArbitraryArgs,
 		PersistentPreRun: func(cmd *cobra.Command, args []string) {
 			if commandUsesContext(cmd.CommandPath()) {
-				globalEulaPreRun(cmd, p)
 				if err := p.SetUpQliksenseDefaultContext(); err != nil {
 					panic(err)
 				}
@@ -114,25 +112,10 @@ func getRootCmd(p *qliksense.Qliksense) *cobra.Command {
 				if err := pf.Initialize(); err != nil {
 					panic(err)
 				}
-				globalEulaPostRun(cmd, p)
-			}
-		},
-		PersistentPostRun: func(cmd *cobra.Command, args []string) {
-			if commandUsesContext(cmd.CommandPath()) {
-				globalEulaPostRun(cmd, p)
 			}
 		},
 		SilenceUsage: true,
 	}
-	origHelpFunc := cmd.HelpFunc()
-	cmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
-		if !commandUsesContext(cmd.CommandPath()) {
-			cmd.Flags().MarkHidden("acceptEULA")
-		}
-		origHelpFunc(cmd, args)
-	})
-	accept := ""
-	cmd.PersistentFlags().StringVarP(&accept, "acceptEULA", "a", "", "Accept EULA for qliksense")
 	cmd.Flags().SetInterspersed(false)
 	return cmd
 }
@@ -168,7 +151,9 @@ func rootCmd(p *qliksense.Qliksense) *cobra.Command {
 	// add config command
 	configCmd := configCmd(p)
 	cmd.AddCommand(configCmd)
+	/** disabling for now
 	configCmd.AddCommand(configApplyCmd(p))
+	**/
 	configCmd.AddCommand(configViewCmd(p))
 
 	viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
@@ -238,34 +223,6 @@ func rootCmd(p *qliksense.Qliksense) *cobra.Command {
 	return cmd
 }
 
-func copy(src, dst string) (int64, error) {
-	var (
-		source, destination *os.File
-		sourceFileStat      os.FileInfo
-		err                 error
-		nBytes              int64
-	)
-	if sourceFileStat, err = os.Stat(src); err != nil {
-		return 0, err
-	}
-
-	if !sourceFileStat.Mode().IsRegular() {
-		return 0, fmt.Errorf("%s is not a regular file", src)
-	}
-
-	if source, err = os.Open(src); err != nil {
-		return 0, err
-	}
-	defer source.Close()
-
-	if destination, err = os.Create(dst); err != nil {
-		return 0, err
-	}
-	defer destination.Close()
-	nBytes, err = io.Copy(destination, source)
-	return nBytes, err
-}
-
 func levenstein(cmd *cobra.Command) {
 	cmd.SuggestionsMinimumDistance = 2
 	if len(os.Args) > 1 {

docs/command_reference.md

@@ -130,7 +130,6 @@ In this case, the result of `qliksense about` command would display information
 
 It supports the following flags:
 
-- `qliksense config apply` - generate the patches and apply manifests to K8s
 - `qliksense config list-contexts` - get and list contexts
 - `qliksense config set` - configure a key-value pair into the current context
 - `qliksense config set-configs` - set configurations into qliksense context as key-value pairs

docs/concepts.md

@@ -50,7 +50,7 @@ In this mode `qliksense` CLI downloads the specified version from [qliksense-k8s
 
 The qliksense cli creates a CR for the QlikSense operator and all config operations are performed to edit the CR.
 
-`qliksense install` or `qliksense config apply` will generate patches in local file system (i.e `~/.qliksense/contexts/<context-name>/qlik-k8s`) and
+`qliksense install` will generate patches in local file system (i.e `~/.qliksense/contexts/<context-name>/qlik-k8s`) and
 
 - Install those manifests into the cluster 
 - Create a custom resource (CR) for the `qliksene operator`.
@@ -68,7 +68,7 @@ qliksense config set git.repository="https://github.com/my-org/qliksense-k8s"
 qliksense config set git.accessToken="<mySecretToken>"
 ```
 
-When you perform `qliksense install` or `qliksene config apply`, qliksense operator performs these tasks:
+When you perform `qliksense install`, qliksense operator performs these tasks:
 
 - Download corresponding version of manifests from the your git repo
 - Generate kustomize patches

go.mod

@@ -10,7 +10,7 @@ replace (
 	k8s.io/client-go => k8s.io/client-go v0.17.0
 	k8s.io/kubectl => k8s.io/kubectl v0.0.0-20191219154910-1528d4eea6dd
 
-	sigs.k8s.io/kustomize/api => github.com/qlik-oss/kustomize/api v0.3.3-0.20200604075616-c46582ece468
+	sigs.k8s.io/kustomize/api => github.com/qlik-oss/kustomize/api v0.3.3-0.20200612023448-4c1f2f38ea9b
 )
 
 require (
@@ -40,7 +40,7 @@ require (
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/otiai10/copy v1.1.1
 	github.com/pkg/errors v0.9.1
-	github.com/qlik-oss/k-apis v0.1.5
+	github.com/qlik-oss/k-apis v0.1.7
 	github.com/robfig/cron/v3 v3.0.1
 	github.com/rogpeppe/go-internal v1.5.2 // indirect
 	github.com/spf13/cobra v0.0.6

go.sum

@@ -471,10 +471,6 @@ github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-github v17.0.0+incompatible h1:N0LgJ1j65A7kfXrZnUDaYCs/Sf4rEjNlfyDHW9dolSY=
-github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
-github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk=
-github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
 github.com/google/go-replayers/grpcreplay v0.1.0 h1:eNb1y9rZFmY4ax45uEEECSa8fsxGRU+8Bil52ASAwic=
 github.com/google/go-replayers/grpcreplay v0.1.0/go.mod h1:8Ig2Idjpr6gifRd6pNVggX6TC1Zw6Jx74AKp7QNH2QE=
 github.com/google/go-replayers/httpreplay v0.1.0 h1:AX7FUb4BjrrzNvblr/OlgwrmFiep6soj5K2QSDW7BGk=
@@ -885,10 +881,10 @@ github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDa
 github.com/prometheus/procfs v0.0.5 h1:3+auTFlqw+ZaQYJARz6ArODtkaIwtvBTx3N2NehQlL8=
 github.com/prometheus/procfs v0.0.5/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
-github.com/qlik-oss/k-apis v0.1.5 h1:IeqHuF1IIQCsuSmsUhL7GjdfkOFsNgh3z2UyX59GTsk=
-github.com/qlik-oss/k-apis v0.1.5/go.mod h1:yoYGgPJ/H0t9H3NSq64dWfyQY6QWi2L9c+hCJoVO03U=
-github.com/qlik-oss/kustomize/api v0.3.3-0.20200604075616-c46582ece468 h1:fAo9wsK2zNiKkOAo0OPCrrrtt/X1Y5W5YEx0t/Y4jwg=
-github.com/qlik-oss/kustomize/api v0.3.3-0.20200604075616-c46582ece468/go.mod h1:zh3yFgE5zFk1kreqzVyyj1eXyIxQJT53l4zSg8Wt4SA=
+github.com/qlik-oss/k-apis v0.1.7 h1:3QPymn+xMhwslm1F0oqdVqtJ/FdfAJn4vNnmS9NFIoY=
+github.com/qlik-oss/k-apis v0.1.7/go.mod h1:r5hXo1mrHOzIdI0Ri9TI4SKjEXft1TZnAyJzOSm9pi0=
+github.com/qlik-oss/kustomize/api v0.3.3-0.20200612023448-4c1f2f38ea9b h1:RDh3OZJOriy/ap1NUHVKsPG07N4DALaCzaqXFFK57T0=
+github.com/qlik-oss/kustomize/api v0.3.3-0.20200612023448-4c1f2f38ea9b/go.mod h1:zh3yFgE5zFk1kreqzVyyj1eXyIxQJT53l4zSg8Wt4SA=
 github.com/quasilyte/go-consistent v0.0.0-20190521200055-c6f3937de18c/go.mod h1:5STLWrekHfjyYwxBRVRXNOSewLJ3PWfDJd1VyTS21fI=
 github.com/rainycape/unidecode v0.0.0-20150907023854-cb7f23ec59be h1:ta7tUOvsPHVHGom5hKW5VXNc2xZIkfCKP8iaqOyYtUQ=
 github.com/rainycape/unidecode v0.0.0-20150907023854-cb7f23ec59be/go.mod h1:MIDFMn7db1kT65GmV94GzpX9Qdi7N/pQlwb+AN8wh+Q=
@@ -1166,8 +1162,6 @@ golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553 h1:efeOvDhwQ29Dj3SdAV/MJf8ou
 golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa h1:F+8P+gmewFQYRk6JoLQLwjBCTu3mcIURZfNkVweuRKA=
 golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200202094626-16171245cfb2 h1:CCH4IOTTfewWjGOlSp+zGcjutRKlBEZQ6wTn8ozI/nI=
-golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b h1:0mm1VjtFUOIlE1SbDlwjYaDxZVDP2S5ou6y0gSgXHu8=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200301022130-244492dfa37a h1:GuSPYbZzB5/dcLNCwLQLsg3obCJtX9IJhpXkvY7kzk0=

pkg/api/clientgo_utils.go

@@ -371,7 +371,6 @@ func (p *ClientGoUtils) GetPodContainerLogs(clientset kubernetes.Interface, pod
 		return "", err
 	}
 	defer podLogs.Close()
-	// time.Sleep(15 * time.Second)
 	buf := new(bytes.Buffer)
 	_, err = io.Copy(buf, podLogs)
 	if err != nil {

pkg/api/clientgo_utils_test.go

@@ -19,6 +19,7 @@ import (
 )
 
 func TestClientGoUtils_getDeployment(t *testing.T) {
+	t.Parallel()
 	type fields struct {
 		Verbose bool
 	}
@@ -85,6 +86,7 @@ func TestClientGoUtils_getDeployment(t *testing.T) {
 }
 
 func TestClientGoUtils_DeleteDeployment(t *testing.T) {
+	t.Parallel()
 	type fields struct {
 		Verbose bool
 	}
@@ -138,6 +140,7 @@ func TestClientGoUtils_DeleteDeployment(t *testing.T) {
 }
 
 func TestClientGoUtils_GetService(t *testing.T) {
+	t.Parallel()
 	type fields struct {
 		Verbose bool
 	}
@@ -204,6 +207,7 @@ func TestClientGoUtils_GetService(t *testing.T) {
 }
 
 func TestClientGoUtils_CreatePreflightTestDeployment(t *testing.T) {
+	t.Parallel()
 	fk := fake.NewSimpleClientset()
 	fk.Fake.PrependReactor("create", "deployments", func(action k8stesting.Action) (handled bool, ret runtime.Object, err error) {
 		return true, &appsv1.Deployment{}, errors.New("Error creating deployment")
@@ -303,6 +307,7 @@ func TestClientGoUtils_CreatePreflightTestDeployment(t *testing.T) {
 }
 
 func TestClientGoUtils_DeleteService(t *testing.T) {
+	t.Parallel()
 	type fields struct {
 		Verbose bool
 	}
@@ -360,6 +365,7 @@ func TestClientGoUtils_DeleteService(t *testing.T) {
 }
 
 func TestClientGoUtils_DeletePod(t *testing.T) {
+	t.Parallel()
 	type fields struct {
 		Verbose bool
 	}
@@ -417,6 +423,7 @@ func TestClientGoUtils_DeletePod(t *testing.T) {
 }
 
 func TestClientGoUtils_CreatePreflightTestPod(t *testing.T) {
+	t.Parallel()
 	fk := fake.NewSimpleClientset()
 	fk.Fake.PrependReactor("create", "pods", func(action k8stesting.Action) (handled bool, ret runtime.Object, err error) {
 		return true, &apiv1.Pod{}, errors.New("Error creating pod")
@@ -560,6 +567,7 @@ func TestClientGoUtils_CreatePreflightTestPod(t *testing.T) {
 }
 
 func TestClientGoUtils_getPod(t *testing.T) {
+	t.Parallel()
 	type fields struct {
 		Verbose bool
 	}
@@ -632,6 +640,7 @@ func TestClientGoUtils_getPod(t *testing.T) {
 // There is an issue with mocking logs: https://github.com/kubernetes/kubernetes/issues/84203
 // We are waiting for this PR: https://github.com/kubernetes/kubernetes/pull/91485/files to be merged to be able to test this feature
 func TestClientGoUtils_GetPodContainerLogs(t *testing.T) {
+	t.SkipNow()
 	type fields struct {
 		Verbose bool
 	}
@@ -645,6 +654,7 @@ func TestClientGoUtils_GetPodContainerLogs(t *testing.T) {
 		fields  fields
 		args    args
 		want    string
+		mockLog string
 		wantErr bool
 	}{
 		{
@@ -666,6 +676,7 @@ func TestClientGoUtils_GetPodContainerLogs(t *testing.T) {
 				container: "",
 			},
 			want:    "blah",
+			mockLog: "blah",
 			wantErr: false,
 		},
 	}
@@ -687,7 +698,8 @@ func TestClientGoUtils_GetPodContainerLogs(t *testing.T) {
 }
 
 func TestClientGoUtils_WaitForDeployment(t *testing.T) {
-	waitTimeout = 30 * time.Second
+	t.Parallel()
+	waitTimeout = 10 * time.Second
 	dep := &appsv1.Deployment{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "test-dep",
@@ -725,7 +737,7 @@ func TestClientGoUtils_WaitForDeployment(t *testing.T) {
 				pfDeployment: dep,
 			},
 			wantErr:                        false,
-			timeoutForChangingReplicaCount: 10 * time.Second,
+			timeoutForChangingReplicaCount: 6 * time.Second,
 			mockErr:                        false,
 		},
 		{
@@ -823,7 +835,8 @@ func TestClientGoUtils_WaitForDeployment(t *testing.T) {
 }
 
 func TestClientGoUtils_WaitForPod(t *testing.T) {
-	waitTimeout = 30 * time.Second
+	t.Parallel()
+	waitTimeout = 10 * time.Second
 	po := &apiv1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "test-dep",
@@ -866,7 +879,7 @@ func TestClientGoUtils_WaitForPod(t *testing.T) {
 				pod:       po,
 			},
 			wantErr:                        false,
-			timeoutForChangingReplicaCount: 10 * time.Second,
+			timeoutForChangingReplicaCount: 6 * time.Second,
 			mockErr:                        false,
 		},
 		{
@@ -1037,7 +1050,8 @@ func TestClientGoUtils_WaitForPod(t *testing.T) {
 }
 
 func TestClientGoUtils_WaitForPodToDie(t *testing.T) {
-	waitTimeout = 30 * time.Second
+	t.Parallel()
+	waitTimeout = 10 * time.Second
 	po := &apiv1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "test-dep",
@@ -1080,7 +1094,7 @@ func TestClientGoUtils_WaitForPodToDie(t *testing.T) {
 				pod:       po,
 			},
 			wantErr:                        false,
-			timeoutForChangingReplicaCount: 10 * time.Second,
+			timeoutForChangingReplicaCount: 6 * time.Second,
 			mockErr:                        false,
 		},
 		{
@@ -1191,7 +1205,8 @@ func TestClientGoUtils_WaitForPodToDie(t *testing.T) {
 }
 
 func TestClientGoUtils_waitForPodToDelete(t *testing.T) {
-	waitTimeout = 30 * time.Second
+	t.Parallel()
+	waitTimeout = 10 * time.Second
 	po := &apiv1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "test-pod",
@@ -1225,7 +1240,7 @@ func TestClientGoUtils_waitForPodToDelete(t *testing.T) {
 				pod:       "test-pod",
 			},
 			wantErr:                        false,
-			timeoutForChangingReplicaCount: 10 * time.Second,
+			timeoutForChangingReplicaCount: 6 * time.Second,
 		},
 		{
 			name: "valid case instant",
@@ -1273,7 +1288,8 @@ func TestClientGoUtils_waitForPodToDelete(t *testing.T) {
 }
 
 func TestClientGoUtils_WaitForDeploymentToDelete(t *testing.T) {
-	waitTimeout = 30 * time.Second
+	t.Parallel()
+	waitTimeout = 10 * time.Second
 	dep := &appsv1.Deployment{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "test-dep",
@@ -1309,7 +1325,7 @@ func TestClientGoUtils_WaitForDeploymentToDelete(t *testing.T) {
 				deploymentName: dep.Name,
 			},
 			wantErr:                        false,
-			timeoutForChangingReplicaCount: 10 * time.Second,
+			timeoutForChangingReplicaCount: 6 * time.Second,
 		},
 		{
 			name: "valid case instant",
@@ -1357,6 +1373,7 @@ func TestClientGoUtils_WaitForDeploymentToDelete(t *testing.T) {
 }
 
 func TestClientGoUtils_CreatePreflightTestSecret(t *testing.T) {
+	t.Parallel()
 	fk := fake.NewSimpleClientset()
 	fk.Fake.PrependReactor("create", "secrets", func(action k8stesting.Action) (handled bool, ret runtime.Object, err error) {
 		return true, &apiv1.Secret{}, errors.New("Error creating deployment")
@@ -1431,6 +1448,7 @@ func TestClientGoUtils_CreatePreflightTestSecret(t *testing.T) {
 }
 
 func TestClientGoUtils_DeleteK8sSecret(t *testing.T) {
+	t.Parallel()
 	type fields struct {
 		Verbose bool
 	}
@@ -1484,6 +1502,7 @@ func TestClientGoUtils_DeleteK8sSecret(t *testing.T) {
 }
 
 func TestClientGoUtils_CreateStatefulSet(t *testing.T) {
+	t.Parallel()
 	fk := fake.NewSimpleClientset()
 	fk.Fake.PrependReactor("create", "statefulsets", func(action k8stesting.Action) (handled bool, ret runtime.Object, err error) {
 		return true, &appsv1.StatefulSet{}, errors.New("Error")
@@ -1586,3 +1605,346 @@ func TestClientGoUtils_CreateStatefulSet(t *testing.T) {
 		})
 	}
 }
+
+func TestClientGoUtils_waitForStatefulSet(t *testing.T) {
+	t.Parallel()
+	waitTimeout = 10 * time.Second
+	ss := &appsv1.StatefulSet{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "test-ss",
+			Namespace: "test-ns",
+		},
+		Status: appsv1.StatefulSetStatus{
+			ReadyReplicas: 0,
+		},
+	}
+
+	type fields struct {
+		Verbose bool
+	}
+	type args struct {
+		clientset     kubernetes.Interface
+		namespace     string
+		pfStatefulset *appsv1.StatefulSet
+	}
+	tests := []struct {
+		name                           string
+		fields                         fields
+		args                           args
+		wantErr                        bool
+		timeoutForChangingReplicaCount time.Duration
+		mockErr                        bool
+	}{
+		{
+			name: "valid case",
+			fields: fields{
+				Verbose: true,
+			},
+			args: args{
+				clientset:     fake.NewSimpleClientset(ss),
+				namespace:     "test-ns",
+				pfStatefulset: ss,
+			},
+			wantErr:                        false,
+			timeoutForChangingReplicaCount: 6 * time.Second,
+			mockErr:                        false,
+		},
+		{
+			name: "valid case instantly ready",
+			fields: fields{
+				Verbose: true,
+			},
+			args: args{
+				clientset: fake.NewSimpleClientset(&appsv1.StatefulSet{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      "test-ss",
+						Namespace: "test-ns",
+					},
+					Status: appsv1.StatefulSetStatus{
+						ReadyReplicas: 1,
+					},
+				}),
+				namespace:     "test-ns",
+				pfStatefulset: ss,
+			},
+			wantErr: false,
+			mockErr: false,
+		},
+		{
+			name: "k8s returning error case",
+			fields: fields{
+				Verbose: true,
+			},
+			args: args{
+				clientset:     fake.NewSimpleClientset(ss),
+				namespace:     "test-ns",
+				pfStatefulset: ss,
+			},
+			wantErr: true,
+			mockErr: true,
+		},
+		{
+			name: "timeout",
+			fields: fields{
+				Verbose: true,
+			},
+			args: args{
+				clientset:     fake.NewSimpleClientset(ss),
+				namespace:     "test-ns",
+				pfStatefulset: ss,
+			},
+			wantErr: true,
+			mockErr: false,
+		},
+		{
+			name: "statefulset goes missing",
+			fields: fields{
+				Verbose: true,
+			},
+			args: args{
+				clientset:     fake.NewSimpleClientset(),
+				namespace:     "test-ns",
+				pfStatefulset: ss,
+			},
+			wantErr: true,
+			mockErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.timeoutForChangingReplicaCount.Seconds() > 0 {
+				go func() {
+					time.Sleep(tt.timeoutForChangingReplicaCount)
+					tt.args.clientset.(*fake.Clientset).Fake.PrependReactor("get", "statefulsets", func(action k8stesting.Action) (handled bool, ret runtime.Object, err error) {
+						return true, &appsv1.StatefulSet{
+							ObjectMeta: metav1.ObjectMeta{
+								Name:      "test-ss",
+								Namespace: "test-ns",
+							},
+							Status: appsv1.StatefulSetStatus{
+								ReadyReplicas: 1,
+							},
+						}, nil
+					})
+				}()
+			}
+			if tt.mockErr {
+				tt.args.clientset.(*fake.Clientset).Fake.PrependReactor("get", "statefulsets", func(action k8stesting.Action) (handled bool, ret runtime.Object, err error) {
+					return true, &appsv1.StatefulSet{}, fmt.Errorf("error")
+				})
+			}
+			p := &ClientGoUtils{
+				Verbose: tt.fields.Verbose,
+			}
+			if err := p.waitForStatefulSet(tt.args.clientset, tt.args.namespace, tt.args.pfStatefulset); (err != nil) != tt.wantErr {
+				t.Errorf("ClientGoUtils.waitForStatefulSet() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestClientGoUtils_getStatefulset(t *testing.T) {
+	t.Parallel()
+	type fields struct {
+		Verbose bool
+	}
+	type args struct {
+		clientset       kubernetes.Interface
+		namespace       string
+		statefulsetName string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    *appsv1.StatefulSet
+		wantErr bool
+	}{
+		{
+			name:   "valid case",
+			fields: fields{Verbose: true},
+			args: args{
+				clientset: fake.NewSimpleClientset(&appsv1.StatefulSet{
+					ObjectMeta: v1.ObjectMeta{
+						Name:      "test-ss",
+						Namespace: "test-ns",
+					},
+				}),
+				namespace:       "test-ns",
+				statefulsetName: "test-ss",
+			},
+			want: &appsv1.StatefulSet{
+				ObjectMeta: v1.ObjectMeta{
+					Name:      "test-ss",
+					Namespace: "test-ns",
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name:   "retrieve non-existent ss",
+			fields: fields{Verbose: true},
+			args: args{
+				clientset:       fake.NewSimpleClientset(),
+				namespace:       "test-ns",
+				statefulsetName: "test-ss",
+			},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &ClientGoUtils{
+				Verbose: tt.fields.Verbose,
+			}
+			got, err := p.getStatefulset(tt.args.clientset, tt.args.namespace, tt.args.statefulsetName)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ClientGoUtils.getStatefulset() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("ClientGoUtils.getStatefulset() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestClientGoUtils_deleteStatefulSet(t *testing.T) {
+	t.Parallel()
+	type fields struct {
+		Verbose bool
+	}
+	type args struct {
+		clientset kubernetes.Interface
+		namespace string
+		name      string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		{
+			name:   "valid case",
+			fields: fields{Verbose: true},
+			args: args{
+				clientset: fake.NewSimpleClientset(&appsv1.StatefulSet{
+					ObjectMeta: v1.ObjectMeta{
+						Name:      "test-ss",
+						Namespace: "test-ns",
+					},
+				}),
+				name:      "test-ss",
+				namespace: "test-ns",
+			},
+			wantErr: false,
+		},
+		{
+			name:   "delete non-existent ss case",
+			fields: fields{Verbose: true},
+			args: args{
+				clientset: fake.NewSimpleClientset(),
+				name:      "test-ss",
+				namespace: "test-ns",
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &ClientGoUtils{
+				Verbose: tt.fields.Verbose,
+			}
+			if err := p.deleteStatefulSet(tt.args.clientset, tt.args.namespace, tt.args.name); (err != nil) != tt.wantErr {
+				t.Errorf("ClientGoUtils.deleteStatefulSet() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestClientGoUtils_waitForStatefulsetToDelete(t *testing.T) {
+	t.Parallel()
+	waitTimeout = 10 * time.Second
+	ss := &appsv1.StatefulSet{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "test-ss",
+			Namespace: "test-ns",
+		},
+		Status: appsv1.StatefulSetStatus{
+			ReadyReplicas: 0,
+		},
+	}
+	type fields struct {
+		Verbose bool
+	}
+	type args struct {
+		clientset       kubernetes.Interface
+		namespace       string
+		statefulsetName string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+		timeoutForChangingReplicaCount time.Duration
+	}{
+		{
+			name: "valid case",
+			fields: fields{
+				Verbose: true,
+			},
+			args: args{
+				clientset:      fake.NewSimpleClientset(ss),
+				namespace:      "test-ns",
+				statefulsetName: ss.Name,
+			},
+			wantErr:                        false,
+			timeoutForChangingReplicaCount: 6 * time.Second,
+		},
+		{
+			name: "valid case instant",
+			fields: fields{
+				Verbose: true,
+			},
+			args: args{
+				clientset:      fake.NewSimpleClientset(),
+				namespace:      "test-ns",
+				statefulsetName: ss.Name,
+			},
+			wantErr:                        false,
+		},
+		{
+			name: "timeout",
+			fields: fields{
+				Verbose: true,
+			},
+			args: args{
+				clientset:      fake.NewSimpleClientset(ss),
+				namespace:      "test-ns",
+				statefulsetName: ss.Name,
+			},
+			wantErr:                        true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.timeoutForChangingReplicaCount.Seconds() > 0 {
+				go func() {
+					time.Sleep(tt.timeoutForChangingReplicaCount)
+					tt.args.clientset.(*fake.Clientset).Fake.PrependReactor("get", "statefulsets", func(action k8stesting.Action) (handled bool, ret runtime.Object, err error) {
+						return true, &appsv1.StatefulSet{}, fmt.Errorf("error")
+					})
+				}()
+			}
+			p := &ClientGoUtils{
+				Verbose: tt.fields.Verbose,
+			}
+			if err := p.waitForStatefulsetToDelete(tt.args.clientset, tt.args.namespace, tt.args.statefulsetName); (err != nil) != tt.wantErr {
+				t.Errorf("ClientGoUtils.waitForStatefulsetToDelete() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

pkg/api/context_apis.go

@@ -7,6 +7,7 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
+	"strings"
 
 	"github.com/qlik-oss/k-apis/pkg/config"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -40,7 +41,7 @@ func (qliksenseCR *QliksenseCR) AddCommonConfig(contextName string) {
 		Profile:    QliksenseDefaultProfile,
 		RotateKeys: DefaultRotateKeys,
 	}
-	qliksenseCR.Spec.AddToSecrets("qliksense", DefaultMongodbUriKey, DefaultMongodbUri, "")
+	qliksenseCR.Spec.AddToSecrets("qliksense", DefaultMongodbUriKey, strings.Replace(DefaultMongodbUri, "qlik-default", contextName, 1), "")
 }
 
 // AddBaseQliksenseConfigs adds configs into config.yaml

pkg/api/context_apis_test.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"reflect"
+	"strings"
 	"testing"
 
 	"github.com/qlik-oss/k-apis/pkg/config"
@@ -27,7 +28,7 @@ func TestAddCommonConfig(t *testing.T) {
 		Secrets: map[string]config.NameValues{
 			"qliksense": []config.NameValue{{
 				Name:  DefaultMongodbUriKey,
-				Value: DefaultMongodbUri,
+				Value: strings.Replace(DefaultMongodbUri, "qlik-default", "myqliksense", 1),
 			},
 			},
 		},

pkg/api/preflight_apis.go

@@ -131,8 +131,8 @@ func (p *PreflightConfig) Initialize() error {
 	}
 	p.AddMinK8sV("1.15")
 	p.AddMinMongoV("3.6")
-	p.AddImage("nginx", "nginx")
-	p.AddImage("netcat", "subfuzion/netcat")
-	p.AddImage("preflight-mongo", "qlik-docker-oss.bintray.io/preflight-mongo")
+	p.AddImage("nginx", "nginx:1.19.0-alpine")
+	p.AddImage("netcat", "qlik-docker-oss.bintray.io/preflight-netcat:v1.0.0")
+	p.AddImage("preflight-mongo", "qlik-docker-oss.bintray.io/preflight-mongo:v1.0.0")
 	return p.Write()
 }

pkg/preflight/all_checks.go

@@ -15,90 +15,90 @@ func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, n
 	out := ansi.NewColorableStdout()
 	// Preflight minimum kuberenetes version check
 	if err := qp.CheckK8sVersion(namespace, kubeConfigContents); err != nil {
-		fmt.Fprintf(out, "%s\n", Red("Preflight kubernetes minimum version check FAILED"))
+		fmt.Fprintf(out, "%s\n", Red("FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
-		fmt.Fprintf(out, "%s\n\n", Green("Preflight kubernetes minimum version check PASSED"))
+		fmt.Fprintf(out, "%s\n\n", Green("PASSED"))
 		checkCount++
 	}
 	totalCount++
 
 	// Preflight deployment check
 	if err := qp.CheckDeployment(namespace, kubeConfigContents, false); err != nil {
-		fmt.Fprintf(out, "%s\n", Red("Preflight deployment check FAILED"))
+		fmt.Fprintf(out, "%s\n", Red("FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
-		fmt.Fprintf(out, "%s\n\n", Green("Preflight deployment check PASSED"))
+		fmt.Fprintf(out, "%s\n\n", Green("PASSED"))
 		checkCount++
 	}
 	totalCount++
 
 	// Preflight service check
 	if err := qp.CheckService(namespace, kubeConfigContents, false); err != nil {
-		fmt.Fprintf(out, "%s\n", Red("Preflight service check FAILED"))
+		fmt.Fprintf(out, "%s\n", Red("FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
-		fmt.Fprintf(out, "%s\n\n", Green("Preflight service check PASSED"))
+		fmt.Fprintf(out, "%s\n\n", Green("PASSED"))
 		checkCount++
 	}
 	totalCount++
 
 	// Preflight pod check
 	if err := qp.CheckPod(namespace, kubeConfigContents, false); err != nil {
-		fmt.Fprintf(out, "%s\n", Red("Preflight pod check FAILED"))
+		fmt.Fprintf(out, "%s\n", Red("FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
-		fmt.Fprintf(out, "%s\n\n", Green("Preflight pod check PASSED"))
+		fmt.Fprintf(out, "%s\n\n", Green("PASSED"))
 		checkCount++
 	}
 	totalCount++
 
 	// Preflight role check
 	if err := qp.CheckCreateRole(namespace, false); err != nil {
-		fmt.Fprintf(out, "%s\n", Red("Preflight role check FAILED"))
+		fmt.Fprintf(out, "%s\n", Red("FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
-		fmt.Fprintf(out, "%s\n\n", Green("Preflight role check PASSED"))
+		fmt.Fprintf(out, "%s\n\n", Green("PASSED"))
 		checkCount++
 	}
 	totalCount++
 
 	// Preflight rolebinding check
 	if err := qp.CheckCreateRoleBinding(namespace, false); err != nil {
-		fmt.Fprintf(out, "%s\n", Red(" Preflight rolebinding check FAILED"))
+		fmt.Fprintf(out, "%s\n", Red("FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
-		fmt.Fprintf(out, "%s\n\n", Green("Preflight rolebinding check PASSED"))
+		fmt.Fprintf(out, "%s\n\n", Green("PASSED"))
 		checkCount++
 	}
 	totalCount++
 
 	// Preflight serviceaccount check
 	if err := qp.CheckCreateServiceAccount(namespace, false); err != nil {
-		fmt.Fprintf(out, "%s\n", Red(" Preflight serviceaccount check FAILED"))
+		fmt.Fprintf(out, "%s\n", Red("FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
-		fmt.Fprintf(out, "%s\n\n", Green("Preflight serviceaccount check PASSED"))
+		fmt.Fprintf(out, "%s\n\n", Green("PASSED"))
 		checkCount++
 	}
 	totalCount++
 
 	// Preflight mongo check
 	if err := qp.CheckMongo(kubeConfigContents, namespace, preflightOpts, false); err != nil {
-		fmt.Fprintf(out, "%s\n", Red(" Preflight mongo check FAILED"))
+		fmt.Fprintf(out, "%s\n", Red("FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
-		fmt.Fprintf(out, "%s\n\n", Green("Preflight mongo check PASSED"))
+		fmt.Fprintf(out, "%s\n\n", Green("PASSED"))
 		checkCount++
 	}
 	totalCount++
 
 	// Preflight DNS check
 	if err := qp.CheckDns(namespace, kubeConfigContents, false); err != nil {
-		fmt.Fprintf(out, "%s\n", Red(" Preflight DNS check FAILED"))
+		fmt.Fprintf(out, "%s\n", Red("FAILED"))
 		fmt.Printf("Error: %v\n\n", err)
 	} else {
-		fmt.Fprintf(out, "%s\n\n", Green("Preflight DNS check PASSED"))
+		fmt.Fprintf(out, "%s\n\n", Green("PASSED"))
 		checkCount++
 	}
 	totalCount++

pkg/preflight/deployability.go

@@ -15,8 +15,8 @@ func (p *QliksensePreflight) CheckDeployment(namespace string, kubeConfigContent
 
 	// Deployment check
 	if !cleanup {
-		p.CG.LogVerboseMessage("Preflight deployment check: \n")
-		p.CG.LogVerboseMessage("--------------------------- \n")
+		fmt.Print("Preflight deployment check... ")
+		p.CG.LogVerboseMessage("\n--------------------------- \n")
 	}
 	err = p.checkPfDeployment(clientset, namespace, cleanup)
 	if err != nil {
@@ -38,8 +38,8 @@ func (p *QliksensePreflight) CheckService(namespace string, kubeConfigContents [
 	}
 	// Service check
 	if !cleanup {
-		p.CG.LogVerboseMessage("Preflight service check: \n")
-		p.CG.LogVerboseMessage("------------------------ \n")
+		fmt.Print("Preflight service check... ")
+		p.CG.LogVerboseMessage("\n------------------------ \n")
 	}
 	err = p.checkPfService(clientset, namespace, cleanup)
 	if err != nil {
@@ -61,8 +61,8 @@ func (p *QliksensePreflight) CheckPod(namespace string, kubeConfigContents []byt
 	}
 	// Pod check
 	if !cleanup {
-		p.CG.LogVerboseMessage("Preflight pod check: \n")
-		p.CG.LogVerboseMessage("-------------------- \n")
+		fmt.Print("Preflight pod check... ")
+		p.CG.LogVerboseMessage("\n-------------------- \n")
 	}
 	err = p.checkPfPod(clientset, namespace, cleanup)
 	if err != nil {

pkg/preflight/dns_check.go

@@ -18,8 +18,8 @@ func (p *QliksensePreflight) CheckDns(namespace string, kubeConfigContents []byt
 	podName := "pf-pod-1"
 
 	if !cleanup {
-		p.CG.LogVerboseMessage("Preflight DNS check: \n")
-		p.CG.LogVerboseMessage("------------------- \n")
+		fmt.Print("Preflight DNS check... ")
+		p.CG.LogVerboseMessage("\n------------------- \n")
 	}
 	clientset, _, err := p.CG.GetK8SClientSet(kubeConfigContents, "")
 	if err != nil {

pkg/preflight/mongo_check.go

@@ -22,8 +22,8 @@ const (
 
 func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions, cleanup bool) error {
 	if !cleanup {
-		qp.CG.LogVerboseMessage("Preflight mongodb check: \n")
-		qp.CG.LogVerboseMessage("------------------------ \n")
+		fmt.Print("Preflight mongodb check... ")
+		qp.CG.LogVerboseMessage("\n------------------------ \n")
 	}
 	var currentCR *qapi.QliksenseCR
 	var err error

pkg/preflight/preflight_utils.go

@@ -10,13 +10,6 @@ type PreflightOptions struct {
 	MongoOptions *MongoOptions
 }
 
-// // LogVerboseMessage logs a verbose message
-// func (p *PreflightOptions) LogVerboseMessage(strMessage string, args ...interface{}) {
-// 	if p.Verbose || os.Getenv("QLIKSENSE_DEBUG") == "true" {
-// 		fmt.Printf(strMessage, args...)
-// 	}
-// }
-
 type MongoOptions struct {
 	MongodbUrl string
 	CaCertFile string

pkg/preflight/role_check.go

@@ -14,8 +14,8 @@ import (
 func (qp *QliksensePreflight) CheckCreateRole(namespace string, cleanup bool) error {
 	// create a Role
 	if !cleanup {
-		qp.CG.LogVerboseMessage("Preflight role check: \n")
-		qp.CG.LogVerboseMessage("--------------------- \n")
+		fmt.Print("Preflight role check... ")
+		qp.CG.LogVerboseMessage("\n--------------------- \n")
 	}
 	err := qp.checkCreateEntity(namespace, "Role", cleanup)
 	if err != nil {
@@ -30,8 +30,8 @@ func (qp *QliksensePreflight) CheckCreateRole(namespace string, cleanup bool) er
 func (qp *QliksensePreflight) CheckCreateRoleBinding(namespace string, cleanup bool) error {
 	// create a RoleBinding
 	if !cleanup {
-		qp.CG.LogVerboseMessage("Preflight rolebinding check: \n")
-		qp.CG.LogVerboseMessage("---------------------------- \n")
+		fmt.Print("Preflight rolebinding check... ")
+		qp.CG.LogVerboseMessage("\n---------------------------- \n")
 	}
 	err := qp.checkCreateEntity(namespace, "RoleBinding", cleanup)
 	if err != nil {
@@ -46,8 +46,8 @@ func (qp *QliksensePreflight) CheckCreateRoleBinding(namespace string, cleanup b
 func (qp *QliksensePreflight) CheckCreateServiceAccount(namespace string, cleanup bool) error {
 	// create a service account
 	if !cleanup {
-		qp.CG.LogVerboseMessage("Preflight serviceaccount check: \n")
-		qp.CG.LogVerboseMessage("------------------------------- \n")
+		fmt.Print("Preflight serviceaccount check... ")
+		qp.CG.LogVerboseMessage("\n------------------------------- \n")
 	}
 	err := qp.checkCreateEntity(namespace, "ServiceAccount", cleanup)
 	if err != nil {
@@ -95,7 +95,8 @@ func (qp *QliksensePreflight) checkCreateEntity(namespace, entityToTest string,
 	if sa != "" {
 		sa = strings.Replace(sa, "name: qliksense", "name: preflight", -1)
 	} else {
-		err := fmt.Errorf("Unable to retrieve yamls to apply on cluster from dir: %s, error: %v", kusDir, err)
+		err = fmt.Errorf(`We were unable to retrieve valid %ss from running "kustomize" in your %s directory. 
+Please check the value in the "Profile" field of your CR. `, strings.ToLower(entityToTest), kusDir)
 		return err
 	}
 	namespace = "" // namespace is handled when generating the manifests

pkg/preflight/version_check.go

@@ -9,8 +9,8 @@ import (
 )
 
 func (p *QliksensePreflight) CheckK8sVersion(namespace string, kubeConfigContents []byte) error {
-	p.CG.LogVerboseMessage("Preflight kubernetes version check: \n")
-	p.CG.LogVerboseMessage("----------------------------------- \n")
+	fmt.Print("Preflight kubernetes version check... ")
+	p.CG.LogVerboseMessage("\n----------------------------------- \n")
 	var currentVersion *semver.Version
 
 	clientset, _, err := p.CG.GetK8SClientSet(kubeConfigContents, "")

pkg/qliksense/about.go

@@ -23,13 +23,12 @@ type patch struct {
 	Patch string `yaml:"patch"`
 }
 
-type selectivePatch struct {
+type annotationTransformer struct {
 	APIVersion string `yaml:"apiVersion"`
 	Metadata   struct {
 		Name string `yaml:"name"`
 	} `yaml:"metadata"`
-	Enabled bool    `yaml:"enabled"`
-	Patches []patch `yaml:"patches"`
+	Annotations map[string]string `json:"annotations,omitempty" yaml:"annotations,omitempty"`
 }
 
 type helmChart struct {
@@ -73,7 +72,7 @@ func (q *Qliksense) About(gitRef, profile string) (*VersionOutput, error) {
 }
 
 func (q *Qliksense) AboutDir(configDirectory, profile string) (*VersionOutput, error) {
-	if chartVersion, err := getChartVersion(filepath.Join(configDirectory, "transformers", "qseokversion.yaml"), "qliksense"); err != nil {
+	if chartVersion, err := getChartVersion(filepath.Join(configDirectory, "manifests", "base", "transformers", "release", "annotations.yaml"), "app.kubernetes.io/version"); err != nil {
 		return nil, err
 	} else if kuzManifest, err := executeKustomizeBuildWithStdoutProgress(filepath.Join(configDirectory, "manifests", profile)); err != nil {
 		return nil, err
@@ -223,22 +222,16 @@ func traverseYamlDecodedMapRecursively(val reflect.Value, path []string, visitor
 	}
 }
 
-func getChartVersion(versionFile, chartName string) (string, error) {
-	var patchInst patch
-	var selPatch selectivePatch
-	var chart helmChart
+func getChartVersion(versionFile, versionAnnotation string) (string, error) {
+	var annTransformer annotationTransformer
 
 	if bytes, err := ioutil.ReadFile(versionFile); err != nil {
 		return "", err
-	} else if err = yaml.Unmarshal(bytes, &selPatch); err != nil {
+	} else if err = yaml.Unmarshal(bytes, &annTransformer); err != nil {
 		return "", err
 	}
-	for _, patchInst = range selPatch.Patches {
-		if err := yaml.Unmarshal([]byte(patchInst.Patch), &chart); err == nil {
-			if chart.ChartName == chartName {
-				return chart.ChartVersion, nil
-			}
-		}
+	if version, ok := annTransformer.Annotations[versionAnnotation]; ok {
+		return version, nil
 	}
 	return "", nil
 }

pkg/qliksense/apply.go

@@ -1,61 +1,8 @@
 package qliksense
 
-import (
-	"fmt"
-	"io"
-
-	qapi "github.com/qlik-oss/sense-installer/pkg/api"
-)
-
-func (q *Qliksense) ApplyCRFromReader(r io.Reader, opts *InstallCommandOptions, keepPatchFiles, overwriteExistingContext, pull, push bool) error {
-	if err := q.LoadCr(r, overwriteExistingContext); err != nil {
+func (q *Qliksense) ApplyCRFromBytes(crBytes []byte, opts *InstallCommandOptions, overwriteExistingContext bool) error {
+	if err := q.LoadCr(crBytes, overwriteExistingContext); err != nil {
 		return err
 	}
-	qConfig := qapi.NewQConfig(q.QliksenseHome)
-	cr, err := qConfig.GetCurrentCR()
-	if err != nil {
-		return err
-	}
-	version := cr.GetLabelFromCr("version")
-
-	if pull {
-		fmt.Println("Pulling images...")
-		if err := q.PullImages(version, ""); err != nil {
-			return err
-		}
-	}
-	if push {
-		fmt.Println("Pushing images...")
-		if err := q.PushImagesForCurrentCR(); err != nil {
-			return err
-		}
-	}
-
-	if IsQliksenseInstalled(cr.GetName()) {
-		// it is needed in case want to upgrade from one version to another
-		if cr.Spec.ManifestsRoot == "" && cr.Spec.Git == nil {
-			if !qConfig.IsRepoExistForCurrent(version) {
-				if err := q.FetchQK8s(version); err != nil {
-					return err
-				}
-			}
-		}
-		return q.UpgradeQK8s(keepPatchFiles)
-	}
-	return q.InstallQK8s(version, opts, keepPatchFiles)
-}
-
-func IsQliksenseInstalled(crName string) bool {
-	args := []string{
-		"get",
-		"qliksense",
-		crName,
-		"-ogo-template",
-		`--template='{{ .metadata.name}}'`,
-	}
-	_, err := qapi.KubectlDirectOps(args, "")
-	if err != nil {
-		return false
-	}
-	return true
+	return q.InstallQK8s("", opts)
 }

pkg/qliksense/context_configs.go

@@ -519,8 +519,8 @@ func (q *Qliksense) SetUpQliksenseContext(contextName string) error {
 		return err
 	}
 
-	// set the encrypted default mongo
-	return q.SetSecrets([]string{`qliksense.mongodbUri="mongodb://qlik-default-mongodb:27017/qliksense?ssl=false"`}, false, false)
+	// set the encrypted default mongo for the context in current CR
+	return q.SetSecrets([]string{fmt.Sprintf("qliksense.mongodbUri=mongodb://%s-mongodb:27017/qliksense?ssl=false", contextName)}, false, false)
 }
 
 func validateInput(input string) (string, error) {

pkg/qliksense/docker.go

@@ -30,19 +30,14 @@ const (
 
 func (q *Qliksense) PullImages(version, profile string) error {
 	qConfig := qapi.NewQConfig(q.QliksenseHome)
-	if version != "" {
-		if !qConfig.IsRepoExistForCurrent(version) {
-			if err := q.FetchQK8s(version); err != nil {
-				return err
-			}
-		}
-	}
 	qcr, err := qConfig.GetCurrentCR()
 	if err != nil {
 		return err
 	}
 	if !qcr.IsRepoExist() {
-		return errors.New("ManifestsRoot not found")
+		if err := fetchAndUpdateCR(qConfig, version); err != nil {
+			return err
+		}
 	}
 	if profile != "" {
 		qcr.Spec.Profile = profile
@@ -160,7 +155,10 @@ func (q *Qliksense) PushImagesForCurrentCR() error {
 	qcr, err := qConfig.GetCurrentCR()
 	if err != nil {
 		return err
+	} else if err := ensureImageRegistrySetInCR(qcr); err != nil {
+		return err
 	}
+
 	version := qcr.GetLabelFromCr("version")
 	profile := qcr.Spec.Profile
 	repoDir := qcr.Spec.ManifestsRoot
@@ -344,3 +342,20 @@ func (q *Qliksense) writeVersionOutput(versionOut *VersionOutput, imagesDir, ver
 	}
 	return nil
 }
+
+func validatePullPushFlagsOnInstall(cr *qapi.QliksenseCR, pull, push bool) error {
+	if pull && !push {
+		fmt.Printf("WARNING: pulling images without pushing them\n")
+	}
+	if push {
+		return ensureImageRegistrySetInCR(cr)
+	}
+	return nil
+}
+
+func ensureImageRegistrySetInCR(cr *qapi.QliksenseCR) error {
+	if registry := cr.Spec.GetImageRegistry(); registry == "" {
+		return errors.New("no image registry set in the CR; to set it use: qliksense config set-image-registry")
+	}
+	return nil
+}

pkg/qliksense/docker_test.go

@@ -235,17 +235,17 @@ spec:
 		t.Fatal("expected to find the GitOps image in the list, but it wasn't there")
 	}
 	if !haveMatchingImage(func(image string) bool {
-		return image == "nginx"
+		return strings.Contains(image, "nginx")
 	}) {
 		t.Fatal("expected to find the nginx Preflight image in the list, but it wasn't there")
 	}
 	if !haveMatchingImage(func(image string) bool {
-		return image == "subfuzion/netcat"
+		return strings.Contains(image, "preflight-netcat")
 	}) {
 		t.Fatal("expected to find the netcat Preflight image in the list, but it wasn't there")
 	}
 	if !haveMatchingImage(func(image string) bool {
-		return image == "qlik-docker-oss.bintray.io/preflight-mongo"
+		return strings.Contains(image, "qlik-docker-oss.bintray.io/preflight-mongo")
 	}) {
 		t.Fatal("expected to find the preflight-mongo image in the list, but it wasn't there")
 	}
@@ -315,23 +315,23 @@ spec:
 		return err
 	}
 
-	transformersDir := path.Join(manifestsRootDir, "transformers")
+	transformersDir := path.Join(manifestsRootDir, "manifests", "base", "transformers", "release")
 	if err := os.MkdirAll(transformersDir, os.ModePerm); err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(path.Join(transformersDir, "qseokversion.yaml"), []byte(`
-apiVersion: qlik.com/v1
-kind: SelectivePatch
+	if err := ioutil.WriteFile(path.Join(transformersDir, "annotations.yaml"), []byte(`
+apiVersion: builtin
+kind: AnnotationsTransformer
 metadata:
-  name: qseokversion
-enabled: true
-patches:
-- target:
-    kind: HelmChart
-    labelSelector: name!=qliksense-init
-  patch: |-
-    chartName: qliksense
-    chartVersion: 1.21.23
+  name: common-annotations
+annotations:
+  app.kubernetes.io/name: qliksense
+  app.kubernetes.io/instance: $(PREFIX)
+  app.kubernetes.io/version: 1.21.23
+  app.kubernetes.io/managed-by: qliksense-operator
+fieldSpecs:
+  - path: metadata/annotations
+    create: true
 `), os.ModePerm); err != nil {
 		return err
 	}

pkg/qliksense/fetch.go

@@ -138,7 +138,7 @@ func getVersion(opts *FetchCommandOptions, qcr *qapi.QliksenseCR) string {
 
 func getVerionsOverwriteConfirmation(version string) string {
 	reader := bufio.NewReader(os.Stdin)
-	fmt.Println("The version  [" + version + "] already exist")
+	fmt.Println("The version  [" + version + "] already exists")
 	cfm := "n"
 	for {
 		fmt.Print("Do you want to delete and fetch again [y/N]: ")

pkg/qliksense/install.go

@@ -7,6 +7,9 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"strings"
+
+	"github.com/mattn/go-tty"
 
 	"github.com/mitchellh/go-homedir"
 	"github.com/qlik-oss/k-apis/pkg/config"
@@ -17,34 +20,38 @@ import (
 )
 
 type InstallCommandOptions struct {
-	StorageClass string
-	MongodbUri   string
-	RotateKeys   string
-	DryRun       bool
+	StorageClass    string
+	MongodbUri      string
+	RotateKeys      string
+	AcceptEULA      string
+	DryRun          bool
+	Pull            bool
+	Push            bool
+	CleanPatchFiles bool
 }
 
-func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, keepPatchFiles bool) error {
+const (
+	eulaText             = "Please read the end user license agreement at: https://www.qlik.com/us/legal/license-terms"
+	eulaPrompt           = "Do you accept our EULA? (y/n): "
+	eulaErrorInstruction = `You must enter "y" to continue or execute the command with the acceptEULA flag set to "yes"`
+)
 
-	// step1: fetch 1.0.0 # pull down qliksense-k8s@1.0.0
-	// step2: operator view | kubectl apply -f # operator manifest (CRD)
-	// step3: config apply | kubectl apply -f # generates patches (if required) in configuration directory, applies manifest
-	// step4: config view | kubectl apply -f # generates Custom Resource manifest (CR)
+func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions) error {
 
-	// fetch the version
 	qConfig := qapi.NewQConfig(q.QliksenseHome)
-	if !keepPatchFiles {
-		if err := q.DiscardAllUnstagedChangesFromGitRepo(qConfig); err != nil {
-			fmt.Printf("error removing temporary changes to the config: %v\n", err)
-		}
-	}
-
 	qcr, err := qConfig.GetCurrentCR()
 	if err != nil {
 		fmt.Println("cannot get the current-context cr", err)
 		return err
 	}
 
+	if opts.AcceptEULA != "" && opts.AcceptEULA != "yes" {
+		enforceEula()
+	} else if opts.AcceptEULA == "" && !qcr.IsEULA() {
+		enforceEula()
+	}
 	qcr.SetEULA("yes")
+
 	if opts.MongodbUri != "" {
 		qcr.Spec.AddToSecrets("qliksense", "mongodbUri", opts.MongodbUri, "")
 	}
@@ -54,6 +61,13 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 	if opts.RotateKeys != "" {
 		qcr.Spec.RotateKeys = opts.RotateKeys
 	}
+
+	if opts.CleanPatchFiles {
+		if err := q.DiscardAllUnstagedChangesFromGitRepo(qConfig); err != nil {
+			fmt.Printf("error removing temporary changes to the config: %v\n", err)
+		}
+	}
+
 	// for debugging purpose
 	if opts.DryRun {
 		// generate patches
@@ -72,6 +86,22 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 		return errors.New(`please install CRDs by executing: $ qliksense crds install`)
 	}
 
+	if err := validatePullPushFlagsOnInstall(qcr, opts.Pull, opts.Push); err != nil {
+		return err
+	}
+	if opts.Pull {
+		fmt.Println("Pulling images...")
+		if err := q.PullImages(version, ""); err != nil {
+			return err
+		}
+	}
+	if opts.Push {
+		fmt.Println("Pushing images...")
+		if err := q.PushImagesForCurrentCR(); err != nil {
+			return err
+		}
+	}
+
 	if err := applyImagePullSecret(qConfig); err != nil {
 		return err
 	}
@@ -108,11 +138,7 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 		}
 	}
 
-	qcr, err = qConfig.GetCurrentCR()
-	if err != nil {
-		fmt.Println("cannot get the current-context cr", err)
-		return err
-	} else if qcr.Spec.GetManifestsRoot() == "" {
+	if qcr.Spec.GetManifestsRoot() == "" {
 		return errors.New("cannot get the manifest root. Use qliksense fetch <version> or qliksense set manifestsRoot")
 	}
 
@@ -123,7 +149,7 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 		return err
 	} else {
 		if IsQliksenseInstalled(dcr.GetName()) {
-			return q.UpgradeQK8s(keepPatchFiles)
+			return q.UpgradeQK8s(opts.CleanPatchFiles)
 		}
 		if err := q.applyConfigToK8s(dcr); err != nil {
 			fmt.Println("cannot do kubectl apply on manifests")
@@ -134,6 +160,21 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 	}
 }
 
+func IsQliksenseInstalled(crName string) bool {
+	args := []string{
+		"get",
+		"qliksense",
+		crName,
+		"-ogo-template",
+		`--template='{{ .metadata.name}}'`,
+	}
+	_, err := qapi.KubectlDirectOps(args, "")
+	if err != nil {
+		return false
+	}
+	return true
+}
+
 func (q *Qliksense) getProcessedOperatorControllerString(qcr *qapi.QliksenseCR) (string, error) {
 	operatorControllerString := q.GetOperatorControllerString()
 	if imageRegistry := qcr.Spec.GetImageRegistry(); imageRegistry != "" {
@@ -226,3 +267,26 @@ func (q *Qliksense) createK8sResourceBeforePatch(qcr *qapi.QliksenseCR) error {
 func isK8sSecretNeedToCreate(nv config.NameValue) bool {
 	return nv.ValueFrom != nil
 }
+
+func enforceEula() {
+	fmt.Println(eulaText)
+	fmt.Print(eulaPrompt)
+	answer := readAnswerFromTty()
+	if strings.ToLower(answer) != "y" {
+		fmt.Println(eulaErrorInstruction)
+		os.Exit(1)
+	}
+}
+
+func readAnswerFromTty() string {
+	t, err := tty.Open()
+	if err != nil {
+		panic(err)
+	}
+	defer t.Close()
+	answer, err := t.ReadString()
+	if err != nil {
+		panic(err)
+	}
+	return answer
+}

pkg/qliksense/install_test.go

@@ -5,7 +5,6 @@ import (
 	"io/ioutil"
 	"os"
 	"path"
-	"path/filepath"
 	"strings"
 	"testing"
 
@@ -48,15 +47,8 @@ spec:
   profile: docker-desktop
   rotateKeys: "yes"`
 
-	crFile := filepath.Join(testDir, "install_test.yaml")
-	ioutil.WriteFile(crFile, []byte(sampleCr), 0644)
 	q := New(testDir)
-	file, e := os.Open(crFile)
-	if e != nil {
-		t.Log(e)
-		t.FailNow()
-	}
-	if err := q.LoadCr(file, false); err != nil {
+	if err := q.LoadCr([]byte(sampleCr), false); err != nil {
 		t.Log(err)
 		t.FailNow()
 	}

pkg/qliksense/load_cr.go

@@ -3,17 +3,13 @@ package qliksense
 import (
 	"errors"
 	"fmt"
-	"io"
-	"io/ioutil"
 	"strings"
 
 	qapi "github.com/qlik-oss/sense-installer/pkg/api"
 )
 
-func (q *Qliksense) LoadCr(reader io.Reader, overwriteExistingContext bool) error {
-	if crBytes, err := ioutil.ReadAll(reader); err != nil {
-		return err
-	} else if crName, err := q.loadCrStringIntoFileSystem(string(crBytes), overwriteExistingContext); err != nil {
+func (q *Qliksense) LoadCr(crBytes []byte, overwriteExistingContext bool) error {
+	if crName, err := q.loadCrStringIntoFileSystem(string(crBytes), overwriteExistingContext); err != nil {
 		return err
 	} else {
 		fmt.Println("cr name: [ " + crName + " ] has been loaded")
@@ -21,16 +17,6 @@ func (q *Qliksense) LoadCr(reader io.Reader, overwriteExistingContext bool) erro
 	return nil
 }
 
-func (q *Qliksense) IsEulaAcceptedInCrFile(reader io.Reader) (bool, error) {
-	if crBytes, err := ioutil.ReadAll(reader); err != nil {
-		return false, err
-	} else if cr, err := qapi.CreateCRObjectFromString(string(crBytes)); err != nil {
-		return false, err
-	} else {
-		return cr.IsEULA(), nil
-	}
-}
-
 func (q *Qliksense) loadCrStringIntoFileSystem(crstr string, overwriteExistingContext bool) (string, error) {
 	cr, err := qapi.CreateCRObjectFromString(crstr)
 	if err != nil {

pkg/qliksense/load_cr_test.go

@@ -1,9 +1,6 @@
 package qliksense
 
 import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
 	"testing"
 
 	qapi "github.com/qlik-oss/sense-installer/pkg/api"
@@ -79,30 +76,13 @@ spec:
     repository: https://github.com/ffoysal/qliksense-k8s
     accessToken: abababababababaab
     userName: "blblbl"`
-	crFile1 := filepath.Join(testDir, "testcr1.yaml")
-	ioutil.WriteFile(crFile1, []byte(sampleCr1), 0644)
-	crFile2 := filepath.Join(testDir, "testcr2.yaml")
-	ioutil.WriteFile(crFile2, []byte(sampleCr2), 0644)
-
-	dupCrFile := filepath.Join(testDir, "dupcr.yaml")
-	ioutil.WriteFile(dupCrFile, []byte(duplicateCr), 0644)
 
 	q := New(testDir)
-	file1, e := os.Open(crFile1)
-	if e != nil {
-		t.Log(e)
-		t.FailNow()
-	}
-	if err := q.LoadCr(file1, false); err != nil {
+	if err := q.LoadCr([]byte(sampleCr1), false); err != nil {
 		t.Log(err)
 		t.FailNow()
 	}
-	file2, e := os.Open(crFile2)
-	if e != nil {
-		t.Log(e)
-		t.FailNow()
-	}
-	if err := q.LoadCr(file2, false); err != nil {
+	if err := q.LoadCr([]byte(sampleCr2), false); err != nil {
 		t.Log(err)
 		t.FailNow()
 	}
@@ -128,12 +108,7 @@ spec:
 	if qConfig.Spec.CurrentContext != "qlik-test3" {
 		t.FailNow()
 	}
-	file, e := os.Open(dupCrFile)
-	if e != nil {
-		t.Log(e)
-		t.FailNow()
-	}
-	if err := q.LoadCr(file, false); err == nil {
+	if err := q.LoadCr([]byte(duplicateCr), false); err == nil {
 		t.FailNow()
 	}
 	td()

pkg/qliksense/upgrade.go

@@ -6,7 +6,7 @@ import (
 	qapi "github.com/qlik-oss/sense-installer/pkg/api"
 )
 
-func (q *Qliksense) UpgradeQK8s(keepPatchFiles bool) error {
+func (q *Qliksense) UpgradeQK8s(cleanPatchFiles bool) error {
 
 	// step1: get CR
 	// step2: run kustomize
@@ -14,12 +14,10 @@ func (q *Qliksense) UpgradeQK8s(keepPatchFiles bool) error {
 
 	// fetch the version
 	qConfig := qapi.NewQConfig(q.QliksenseHome)
-	if !keepPatchFiles {
-		defer func() {
-			if err := q.DiscardAllUnstagedChangesFromGitRepo(qConfig); err != nil {
-				fmt.Printf("error removing temporary changes to the config: %v\n", err)
-			}
-		}()
+	if cleanPatchFiles {
+		if err := q.DiscardAllUnstagedChangesFromGitRepo(qConfig); err != nil {
+			fmt.Printf("error removing temporary changes to the config: %v\n", err)
+		}
 	}
 
 	qcr, err := qConfig.GetCurrentCR()