Checking if CRDs are installed before allowing install to proceed (#387)

* mongo check working when ca cert and client cert put in same file
* updated code to use image from bintray

.github/workflows/build.yml

@@ -16,7 +16,7 @@ jobs:
 
     steps:
     - name: Set up Go ${{ matrix.go }}
-      uses: actions/setup-go@v2
+      uses: actions/setup-go@v2-beta
       with:
         go-version: ${{ matrix.go }}
 
@@ -35,7 +35,7 @@ jobs:
 
     steps:
     - name: Set up Go 1.13
-      uses: actions/setup-go@v2
+      uses: actions/setup-go@v2-beta
       with:
         go-version: 1.13
 

.github/workflows/release.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Set up Go 1.13
-      uses: actions/setup-go@v2
+      uses: actions/setup-go@v2-beta
       with:
         go-version: 1.13
 

Makefile

@@ -78,7 +78,7 @@ $(BINDIR)/$(VERSION)/$(MIXIN)-$(CLIENT_PLATFORM)-$(CLIENT_ARCH)$(FILE_EXT):
 	GOOS=$(CLIENT_PLATFORM) GOARCH=$(CLIENT_ARCH) $(XBUILD) -o $@ ./cmd/$(MIXIN)
 
 ifeq ($(CLIENT_PLATFORM),windows)
-	zip -j $(BINDIR)/$(VERSION)/$(MIXIN)-$(CLIENT_PLATFORM)-$(CLIENT_ARCH).zip $(BINDIR)/$(VERSION)/$(MIXIN)-$(CLIENT_PLATFORM)-$(CLIENT_ARCH)$(FILE_EXT)
+	zip $(BINDIR)/$(VERSION)/$(MIXIN)-$(CLIENT_PLATFORM)-$(CLIENT_ARCH).zip $(BINDIR)/$(VERSION)/$(MIXIN)-$(CLIENT_PLATFORM)-$(CLIENT_ARCH)$(FILE_EXT)
 else
 	tar -czvf $(BINDIR)/$(VERSION)/$(MIXIN)-$(CLIENT_PLATFORM)-$(CLIENT_ARCH).tar.gz -C $(BINDIR)/$(VERSION)/ $(MIXIN)-$(CLIENT_PLATFORM)-$(CLIENT_ARCH)$(FILE_EXT)
 endif

cmd/qliksense/apply.go

@@ -37,7 +37,7 @@ func applyCmd(q *qliksense.Qliksense) *cobra.Command {
 	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.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)

cmd/qliksense/context.go

@@ -220,3 +220,27 @@ func cleanConfigRepoPatchesCmd(q *qliksense.Qliksense) *cobra.Command {
 		},
 	}
 }
+
+func unsetCmd(q *qliksense.Qliksense) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "unset",
+		Short: "remove a key from a context or a secrets or a configs from the context",
+		Example: `
+# remove the key from CR
+qliksense config unset <key>
+
+# remove the key from service inside configs/secrets of CR
+qliksense config unset <service>.<key> 
+
+# remove the service from inside configs/secrets of CR
+qliksense config usnet <servcie> 
+
+all of the above supports space separated multiple arguments
+`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return q.UnsetCmd(args)
+		},
+		Args: cobra.MinimumNArgs(1),
+	}
+	return cmd
+}

cmd/qliksense/eula.go

@@ -41,7 +41,7 @@ func (e *eulaPreRunHooksT) getPostValidationArtifact(artifactName string) interf
 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`
+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{}),
@@ -54,7 +54,10 @@ func commandAlwaysRequiresEulaAcceptance(commandName string) bool {
 
 func globalEulaPreRun(cmd *cobra.Command, q *qliksense.Qliksense) {
 	if isEulaEnforced(cmd.CommandPath()) {
-		if strings.TrimSpace(strings.ToLower(cmd.Flag("acceptEULA").Value.String())) != "yes" {
+		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)

cmd/qliksense/install.go

@@ -61,9 +61,9 @@ func installCmd(q *qliksense.Qliksense) *cobra.Command {
 		if filePath != "" {
 			return loadOrApplyCommandEulaPreRunHook(cmd, q)
 		} else if qConfig, err := qapi.NewQConfigE(q.QliksenseHome); err != nil {
-			return false, err
+			return false, nil
 		} else if qcr, err := qConfig.GetCurrentCR(); err != nil {
-			return false, err
+			return false, nil
 		} else {
 			return qcr.IsEULA(), nil
 		}
@@ -71,11 +71,13 @@ func installCmd(q *qliksense.Qliksense) *cobra.Command {
 
 	f := c.Flags()
 	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.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.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)
 

cmd/qliksense/preflight.go

@@ -136,12 +136,7 @@ func pfAllChecksCmd(q *qliksense.Qliksense) *cobra.Command {
 	f := preflightAllChecksCmd.Flags()
 	f.BoolVarP(&preflightOpts.Verbose, "verbose", "v", false, "verbose mode")
 	f.StringVarP(&preflightOpts.MongoOptions.MongodbUrl, "mongodb-url", "", "", "mongodbUrl to try connecting to")
-	f.StringVarP(&preflightOpts.MongoOptions.Username, "mongodb-username", "", "", "username to connect to mongodb")
-	f.StringVarP(&preflightOpts.MongoOptions.Password, "mongodb-password", "", "", "password to connect to mongodb")
 	f.StringVarP(&preflightOpts.MongoOptions.CaCertFile, "mongodb-ca-cert", "", "", "certificate to use for mongodb check")
-	f.StringVarP(&preflightOpts.MongoOptions.ClientCertFile, "mongodb-client-cert", "", "", "client-certificate to use for mongodb check")
-	f.BoolVar(&preflightOpts.MongoOptions.Tls, "mongodb-tls", false, "enable tls?")
-
 	return preflightAllChecksCmd
 }
 
@@ -152,7 +147,7 @@ func pfDeploymentCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 	}
 	var pfDeploymentCheckCmd = &cobra.Command{
 		Use:     "deployment",
-		Short:   "perform preflight deploymwnt check",
+		Short:   "perform preflight deployment check",
 		Long:    `perform preflight deployment check to ensure that we can create deployments in the cluster`,
 		Example: `qliksense preflight deployment`,
 		RunE: func(cmd *cobra.Command, args []string) error {
@@ -337,7 +332,7 @@ func pfCreateServiceAccountCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 
 	var preflightServiceAccountCmd = &cobra.Command{
 		Use:     "serviceaccount",
-		Short:   "preflight create ServiceAccount check",
+		Short:   "preflight create serviceaccount check",
 		Long:    `perform preflight serviceaccount check to ensure we are able to create a service account in the cluster`,
 		Example: `qliksense preflight serviceaccount`,
 		RunE: func(cmd *cobra.Command, args []string) error {
@@ -434,11 +429,7 @@ func pfMongoCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 	f := preflightMongoCmd.Flags()
 	f.BoolVarP(&preflightOpts.Verbose, "verbose", "v", false, "verbose mode")
 	f.StringVarP(&preflightOpts.MongoOptions.MongodbUrl, "url", "", "", "mongodbUrl to try connecting to")
-	f.StringVarP(&preflightOpts.MongoOptions.Username, "username", "", "", "username to connect to mongodb")
-	f.StringVarP(&preflightOpts.MongoOptions.Password, "password", "", "", "password to connect to mongodb")
 	f.StringVarP(&preflightOpts.MongoOptions.CaCertFile, "ca-cert", "", "", "ca certificate to use for mongodb check")
-	f.StringVarP(&preflightOpts.MongoOptions.ClientCertFile, "client-cert", "", "", "client-certificate to use for mongodb check")
-	f.BoolVar(&preflightOpts.MongoOptions.Tls, "tls", false, "enable tls?")
 	return preflightMongoCmd
 }
 

cmd/qliksense/root.go

@@ -122,6 +122,7 @@ func getRootCmd(p *qliksense.Qliksense) *cobra.Command {
 				globalEulaPostRun(cmd, p)
 			}
 		},
+		SilenceUsage: true,
 	}
 	origHelpFunc := cmd.HelpFunc()
 	cmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
@@ -198,6 +199,10 @@ func rootCmd(p *qliksense.Qliksense) *cobra.Command {
 
 	// open editor for config
 	configCmd.AddCommand(configEditCmd(p))
+
+	// add unset for config
+	configCmd.AddCommand((unsetCmd(p)))
+
 	// add uninstall command
 	cmd.AddCommand(uninstallCmd(p))
 

docs/command_reference.md

@@ -63,7 +63,7 @@ spec:
       value: "yes"
   secrets:
     qliksense:
-    - name: mongoDbUri
+    - name: mongodbUri
       value: mongodb://qlik-test-mongodb:27017/qliksense?ssl=false
   profile: docker-desktop
   rotateKeys: "yes"
@@ -104,7 +104,7 @@ spec:
       value: "yes"
   secrets:
     qliksense:
-    - name: mongoDbUri
+    - name: mongodbUri
       value: "mongo://mongo:3307"
     - name: messagingPassword
       valueFromKey: messagingPassword

docs/concepts.md

@@ -23,7 +23,7 @@ spec:
   profile: docker-desktop
   secrets:
     qliksense:
-    - name: mongoDbUri
+    - name: mongodbUri
       value: mongodb://qlik-default-mongodb:27017/qliksense?ssl=false
   rotateKeys: "yes"
   releaseName: qlik-default

docs/preflight_checks.md

@@ -16,9 +16,18 @@ Examples:
 qliksense preflight <preflight_check_to_run>
 
 Available Commands:
-  all         perform all checks
-  dns         perform preflight dns check
-  k8s-version check k8s version
+  all            perform all checks
+  authcheck      preflight authcheck
+  clean          perform preflight clean
+  deployment     perform preflight deployment check
+  dns            perform preflight dns check
+  kube-version   check kubernetes version
+  mongo          preflight mongo OR preflight mongo --url=<url>
+  pod            perform preflight pod check
+  role           preflight create role check
+  rolebinding    preflight create rolebinding check
+  service        perform preflight service check
+  serviceaccount preflight create ServiceAccount check
 
 Flags:
   -h, --help   help for preflight
@@ -200,8 +209,8 @@ We can check if we are able to connect to an instance of mongodb on the cluster
 qliksense preflight mongo --url=<url> -v OR
 qliksense preflight mongo -v
 qliksense preflight mongo --url=<mongo-server url> --ca-cert=<path to ca-cert file> -v
-
-
+```
+```shell
 Preflight mongo check
 ---------------------
 Preflight mongodb check: 
@@ -217,7 +226,29 @@ Deleted pod: pf-mongo-pod
 Completed preflight mongodb check
 ```
 
+#### Mongodb check with mutual tls
+In order to perform mutual tls with mongo we need to:
+- append client certificate to the beginning/end of CA certificate. Make sure to include the beginning and end tags on each certificate. 
+The CA certificate file should look like this in the end:
+```shell
+<existing contents of CA cert>
+...
+-----BEGIN RSA PRIVATE KEY-----
+<private key>
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+<public key>
+-----END CERTIFICATE-----
+```
+- Run the command below to set the ca certificate into the CR
+```shell
+cat <path_to_ca.crt> | base64 | qliksense config set-secrets qliksense.caCertificates --base64
+```
 
+Next, run: 
+```shell
+qliksense preflight mongo -v
+```
 
 ### Running all checks
 Run the command shown below to execute all preflight checks.

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.20200424070349-b0312eb71568
+	sigs.k8s.io/kustomize/api => github.com/qlik-oss/kustomize/api v0.3.3-0.20200514233516-4ac83864b7bd
 )
 
 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.2
+	github.com/qlik-oss/k-apis v0.1.4
 	github.com/robfig/cron/v3 v3.0.1
 	github.com/rogpeppe/go-internal v1.5.2 // indirect
 	github.com/spf13/cobra v0.0.6
@@ -52,6 +52,7 @@ require (
 	google.golang.org/genproto v0.0.0-20200128133413-58ce757ed39b // indirect
 	gopkg.in/yaml.v2 v2.2.8
 	k8s.io/api v0.17.2
+	k8s.io/apiextensions-apiserver v0.17.2
 	k8s.io/apimachinery v0.17.2
 	k8s.io/client-go v11.0.0+incompatible
 	sigs.k8s.io/kustomize/api v0.3.2

go.sum

@@ -883,12 +883,12 @@ 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.1 h1:aZ4eTMB3mSn03Kuj7+RI0eFLkjK9+0qxADBioRb3qVA=
-github.com/qlik-oss/k-apis v0.1.1/go.mod h1:yoYGgPJ/H0t9H3NSq64dWfyQY6QWi2L9c+hCJoVO03U=
 github.com/qlik-oss/k-apis v0.1.2 h1:BBcrXl+NxdsvuRsZuJbvIFxMv5QIXqWBzhXOcr5KUX8=
 github.com/qlik-oss/k-apis v0.1.2/go.mod h1:yoYGgPJ/H0t9H3NSq64dWfyQY6QWi2L9c+hCJoVO03U=
-github.com/qlik-oss/kustomize/api v0.3.3-0.20200424070349-b0312eb71568 h1:wHOUCGfnmgYqW3aCjuP3fXmB2T/uZXMvltO+F3us83E=
-github.com/qlik-oss/kustomize/api v0.3.3-0.20200424070349-b0312eb71568/go.mod h1:Yg8bqX8Mq/eSgXfcenxCxhZuSXg+NCsKq6NBdch/oUc=
+github.com/qlik-oss/k-apis v0.1.4 h1:YXnjKXm/yhPblzYYyVCtD0dNbIkLPLlDdBKnjeYW0IY=
+github.com/qlik-oss/k-apis v0.1.4/go.mod h1:yoYGgPJ/H0t9H3NSq64dWfyQY6QWi2L9c+hCJoVO03U=
+github.com/qlik-oss/kustomize/api v0.3.3-0.20200514233516-4ac83864b7bd h1:dYd6duTr54L7OqykGkd3Z+336frAvzsibWNYruYkYVc=
+github.com/qlik-oss/kustomize/api v0.3.3-0.20200514233516-4ac83864b7bd/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=

pkg/api/apis_test.go

@@ -107,7 +107,7 @@ func TestGetDecryptedCr(t *testing.T) {
 	key, _ := setupGenerateKey(dir)
 	ecn, _ := EncryptData([]byte("mongodb://qlik-default-mongodb:27017/qliksense?ssl=false"), key)
 	b := b64.StdEncoding.EncodeToString(ecn)
-	qcr.Spec.AddToSecrets("qliksense", "mongoDbUri", b, "")
+	qcr.Spec.AddToSecrets("qliksense", "mongodbUri", b, "")
 
 	qcr.SetFetchAccessToken("mytoken", key)
 
@@ -117,8 +117,8 @@ func TestGetDecryptedCr(t *testing.T) {
 		t.Log(err)
 	}
 
-	decryptedValue := newCr.Spec.GetFromSecrets("qliksense", "mongoDbUri")
-	orignalValue := qcr.Spec.GetFromSecrets("qliksense", "mongoDbUri")
+	decryptedValue := newCr.Spec.GetFromSecrets("qliksense", "mongodbUri")
+	orignalValue := qcr.Spec.GetFromSecrets("qliksense", "mongodbUri")
 	if decryptedValue != "mongodb://qlik-default-mongodb:27017/qliksense?ssl=false" {
 		t.Fail()
 		b, _ := K8sToYaml(newCr)

pkg/api/context_apis.go

@@ -24,8 +24,8 @@ const (
 	QliksenseDefaultProfile = "docker-desktop"
 	DefaultRotateKeys       = "yes"
 	QliksenseMetadataName   = "QliksenseConfigMetadata"
-	DefaultMongoDbUri       = "mongodb://qlik-default-mongodb:27017/qliksense?ssl=false"
-	DefaultMongoDbUriKey    = "mongoDbUri"
+	DefaultMongodbUri       = "mongodb://qlik-default-mongodb:27017/qliksense?ssl=false"
+	DefaultMongodbUriKey    = "mongodbUri"
 )
 
 // AddCommonConfig adds common configs into CRs
@@ -40,7 +40,7 @@ func (qliksenseCR *QliksenseCR) AddCommonConfig(contextName string) {
 		Profile:    QliksenseDefaultProfile,
 		RotateKeys: DefaultRotateKeys,
 	}
-	qliksenseCR.Spec.AddToSecrets("qliksense", DefaultMongoDbUriKey, DefaultMongoDbUri, "")
+	qliksenseCR.Spec.AddToSecrets("qliksense", DefaultMongodbUriKey, DefaultMongodbUri, "")
 }
 
 // AddBaseQliksenseConfigs adds configs into config.yaml

pkg/api/context_apis_test.go

@@ -26,8 +26,8 @@ func TestAddCommonConfig(t *testing.T) {
 		RotateKeys: DefaultRotateKeys,
 		Secrets: map[string]config.NameValues{
 			"qliksense": []config.NameValue{{
-				Name:  DefaultMongoDbUriKey,
-				Value: DefaultMongoDbUri,
+				Name:  DefaultMongodbUriKey,
+				Value: DefaultMongodbUri,
 			},
 			},
 		},

pkg/api/preflight_apis.go

@@ -133,6 +133,6 @@ func (p *PreflightConfig) Initialize() error {
 	p.AddMinMongoV("3.6")
 	p.AddImage("nginx", "nginx")
 	p.AddImage("netcat", "subfuzion/netcat")
-	p.AddImage("mongo", "mongo")
+	p.AddImage("preflight-mongo", "qlik-docker-oss.bintray.io/preflight-mongo")
 	return p.Write()
 }

pkg/preflight/mongo_check.go

@@ -16,7 +16,8 @@ import (
 )
 
 const (
-	mongo = "mongo"
+	preflight_mongo = "preflight-mongo"
+	caCertMountPath = "/etc/ssl/certs/ca-certificates.crt"
 )
 
 func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions, cleanup bool) error {
@@ -24,47 +25,37 @@ func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace st
 		qp.P.LogVerboseMessage("Preflight mongodb check: \n")
 		qp.P.LogVerboseMessage("------------------------ \n")
 	}
-	if preflightOpts != nil && preflightOpts.MongoOptions.MongodbUrl == "" && !cleanup {
+	var currentCR *qapi.QliksenseCR
+	var err error
+	qConfig := qapi.NewQConfig(qp.Q.QliksenseHome)
+	qConfig.SetNamespace(namespace)
+	currentCR, err = qConfig.GetCurrentCR()
+	if err != nil {
+		qp.P.LogVerboseMessage("Unable to retrieve current CR: %v\n", err)
+		return err
+	}
+	decryptedCR, err := qConfig.GetDecryptedCr(currentCR)
+	if err != nil {
+		qp.P.LogVerboseMessage("An error occurred while retrieving mongodbUrl from current CR: %v\n", err)
+		return err
+	}
+	if preflightOpts.MongoOptions.MongodbUrl == "" && !cleanup {
 		// infer mongoDbUrl from currentCR
-		qp.P.LogVerboseMessage("MongoDbUri is empty, infer from CR\n")
-		qConfig := qapi.NewQConfig(qp.Q.QliksenseHome)
-		var currentCR *qapi.QliksenseCR
+		qp.P.LogVerboseMessage("mongodbUri is empty, infer from CR\n")
+		preflightOpts.MongoOptions.MongodbUrl = strings.TrimSpace(decryptedCR.Spec.GetFromSecrets("qliksense", "mongodbUri"))
+	}
 
-		var err error
-		qConfig.SetNamespace(namespace)
-		currentCR, err = qConfig.GetCurrentCR()
-		if err != nil {
-			qp.P.LogVerboseMessage("Unable to retrieve current CR: %v\n", err)
-			return err
-		}
-		decryptedCR, err := qConfig.GetDecryptedCr(currentCR)
-		if err != nil {
-			qp.P.LogVerboseMessage("An error occurred while retrieving mongodbUrl from current CR: %v\n", err)
-			return err
-		}
-		preflightOpts.MongoOptions.MongodbUrl = strings.TrimSpace(decryptedCR.Spec.GetFromSecrets("qliksense", "mongoDbUri"))
+	if preflightOpts.MongoOptions.CaCertFile == "" && !cleanup {
+		caCertStr := decryptedCR.Spec.GetFromSecrets("qliksense", "caCertificates")
 		tmpDir := os.TempDir()
 		caCrtFile := filepath.Join(tmpDir, "rootCA.crt")
-		clientCrtFile := filepath.Join(tmpDir, "mongoClient.crt")
-		caCertStr := decryptedCR.Spec.GetFromSecrets("qliksense", "caCertificates")
-		clientCertStr := decryptedCR.Spec.GetFromSecrets("qliksense", "mongoDbClientCrt")
-
-		if preflightOpts.MongoOptions.CaCertFile == "" && caCertStr != "" {
-			api.LogDebugMessage("received ca crt: %s\n", caCertStr)
-			if err := ioutil.WriteFile(caCrtFile, []byte(caCertStr), 0644); err != nil {
-				return fmt.Errorf("unable to write CA crt to file: %v", err)
-			}
-			preflightOpts.MongoOptions.CaCertFile = caCrtFile
-		}
-
-		if preflightOpts.MongoOptions.ClientCertFile == "" && clientCertStr != "" {
-			api.LogDebugMessage("received client crt: %s\n", clientCertStr)
-			if err := ioutil.WriteFile(clientCrtFile, []byte(clientCertStr), 0644); err != nil {
-				return fmt.Errorf("unable to write client crt to file: %v", err)
-			}
-			preflightOpts.MongoOptions.ClientCertFile = clientCrtFile
+		api.LogDebugMessage("received ca crt: %s\n", caCertStr)
+		if err := ioutil.WriteFile(caCrtFile, []byte(caCertStr), 0644); err != nil {
+			return fmt.Errorf("unable to write CA crt to file: %v", err)
 		}
+		preflightOpts.MongoOptions.CaCertFile = caCrtFile
 	}
+
 	if !cleanup {
 		qp.P.LogVerboseMessage("MongodbUrl: %s\n", preflightOpts.MongoOptions.MongodbUrl)
 
@@ -74,9 +65,11 @@ func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace st
 			return errors.New("MongoDbUrl is empty")
 		}
 	}
+
 	if err := qp.mongoConnCheck(kubeConfigContents, namespace, preflightOpts, cleanup); err != nil {
 		return err
 	}
+
 	if !cleanup {
 		qp.P.LogVerboseMessage("Completed preflight mongodb check\n")
 	}
@@ -84,8 +77,7 @@ func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace st
 }
 
 func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespace string, preflightOpts *PreflightOptions, cleanup bool) error {
-	caCertSecretName := "preflight-mongo-test-cacert"
-	clientCertSecretName := "preflight-mongo-test-clientcert"
+	caCertSecretName := "ca-certificates-crt"
 	mongoPodName := "pf-mongo-pod"
 	clientset, _, err := getK8SClientSet(kubeConfigContents, "")
 	if err != nil {
@@ -94,11 +86,11 @@ func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespac
 	}
 
 	// cleanup before starting check
-	qp.runMongoCleanup(clientset, namespace, mongoPodName, caCertSecretName, clientCertSecretName)
+	qp.runMongoCleanup(clientset, namespace, mongoPodName, caCertSecretName)
 	if cleanup {
 		return nil
 	}
-	var secrets []string
+	secrets := map[string]string{}
 	if preflightOpts.MongoOptions.CaCertFile != "" {
 		caCertSecret, err := qp.createSecret(clientset, namespace, preflightOpts.MongoOptions.CaCertFile, caCertSecretName)
 		if err != nil {
@@ -107,52 +99,19 @@ func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespac
 		}
 
 		defer qp.deleteK8sSecret(clientset, namespace, caCertSecret.Name)
-		secrets = append(secrets, caCertSecretName)
-	}
-	if preflightOpts.MongoOptions.ClientCertFile != "" {
-		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)
-		secrets = append(secrets, clientCertSecretName)
+		secrets[caCertSecretName] = caCertMountPath
 	}
 
-	mongoCommand := strings.Builder{}
-	mongoCommand.WriteString(fmt.Sprintf("sleep 10;mongo %s", preflightOpts.MongoOptions.MongodbUrl))
-	if preflightOpts.MongoOptions.Username != "" {
-		mongoCommand.WriteString(fmt.Sprintf(" --username %s", preflightOpts.MongoOptions.Username))
-		api.LogDebugMessage("Adding username: Mongo command: %s\n", mongoCommand.String())
-	}
-	if preflightOpts.MongoOptions.Password != "" {
-		mongoCommand.WriteString(fmt.Sprintf(" --password %s", preflightOpts.MongoOptions.Password))
-		api.LogDebugMessage("Adding username and password\n")
-	}
-	if preflightOpts.MongoOptions.Tls || preflightOpts.MongoOptions.ClientCertFile != "" {
-		mongoCommand.WriteString(" --tls")
-		api.LogDebugMessage("Adding --tls: Mongo command: %s\n", mongoCommand.String())
-	}
-	if preflightOpts.MongoOptions.CaCertFile != "" {
-		mongoCommand.WriteString(fmt.Sprintf(" --tlsCAFile=/etc/ssl/%s/%[1]s", caCertSecretName))
-		api.LogDebugMessage("Adding caCertFile:  Mongo command: %s\n", mongoCommand.String())
-	}
-	if preflightOpts.MongoOptions.ClientCertFile != "" {
-		mongoCommand.WriteString(fmt.Sprintf(" --tlsCertificateKeyFile=/etc/ssl/%s/%[1]s", clientCertSecretName))
-		api.LogDebugMessage("Adding clientCertFile:  Mongo command: %s\n", mongoCommand.String())
-	}
-	mongoCommand.WriteString(` --eval "print(\"connected to mongo\")"`)
-
-	commandToRun := []string{"sh", "-c", mongoCommand.String()}
+	commandToRun := []string{"./preflight-mongo", fmt.Sprintf(`-url="%s"`, preflightOpts.MongoOptions.MongodbUrl)}
 	api.LogDebugMessage("Mongo command: %s\n", strings.Join(commandToRun, " "))
 
 	// create a pod
-	imageName, err := qp.GetPreflightConfigObj().GetImageName(mongo, true)
+	imageName, err := qp.GetPreflightConfigObj().GetImageName(preflight_mongo, true)
 	if err != nil {
 		err = fmt.Errorf("unable to retrieve image : %v\n", err)
 		return err
 	}
+	api.LogDebugMessage("image name to be used: %s\n", imageName)
 	mongoPod, err := qp.createPreflightTestPod(clientset, namespace, mongoPodName, imageName, secrets, commandToRun)
 	if err != nil {
 		err = fmt.Errorf("unable to create pod : %v\n", err)
@@ -181,7 +140,7 @@ func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespac
 	}
 
 	// check if connection succeeded
-	stringToCheck := "Implicit session:"
+	stringToCheck := "qlik - connection succeeded!!"
 	if strings.Contains(logStr, stringToCheck) {
 		qp.P.LogVerboseMessage("Preflight mongo check: PASSED\n")
 	} else {
@@ -194,7 +153,7 @@ func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespac
 func (qp *QliksensePreflight) checkMongoVersion(logStr string) (bool, error) {
 	// check mongo server version
 	api.LogDebugMessage("Minimum required mongo version: %s\n", qp.GetPreflightConfigObj().GetMinMongoVersion())
-	mongoVersionStrToCheck := "MongoDB server version:"
+	mongoVersionStrToCheck := "qlik mongo server version:"
 	if strings.Contains(logStr, mongoVersionStrToCheck) {
 		logLines := strings.Split(logStr, "\n")
 		for _, eachline := range logLines {
@@ -203,7 +162,7 @@ func (qp *QliksensePreflight) checkMongoVersion(logStr string) (bool, error) {
 				if len(mongoVersionLog) < 2 {
 					continue
 				}
-				mongoVersionStr := strings.TrimSpace(mongoVersionLog[1])
+				mongoVersionStr := strings.ReplaceAll(strings.TrimSpace(mongoVersionLog[1]), `"`, "")
 				api.LogDebugMessage("Extracted mongo version from pod log: %s\n", mongoVersionStr)
 				currentMongoVersionSemver, err := semver.NewVersion(mongoVersionStr)
 				if err != nil {
@@ -242,8 +201,7 @@ func (qp *QliksensePreflight) createSecret(clientset *kubernetes.Clientset, name
 	return certSecret, nil
 }
 
-func (qp *QliksensePreflight) runMongoCleanup(clientset *kubernetes.Clientset, namespace, mongoPodName, caCertSecretName, clientCertSecretName string) {
+func (qp *QliksensePreflight) runMongoCleanup(clientset *kubernetes.Clientset, namespace, mongoPodName, caCertSecretName string) {
 	qp.deletePod(clientset, namespace, mongoPodName)
 	qp.deleteK8sSecret(clientset, namespace, caCertSecretName)
-	qp.deleteK8sSecret(clientset, namespace, clientCertSecretName)
 }

pkg/preflight/preflight_utils.go

@@ -12,7 +12,6 @@ import (
 	"time"
 
 	"github.com/mitchellh/go-homedir"
-	"github.com/pkg/errors"
 	"github.com/qlik-oss/sense-installer/pkg/api"
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 	appsv1 "k8s.io/api/apps/v1"
@@ -40,12 +39,8 @@ func (p *PreflightOptions) LogVerboseMessage(strMessage string, args ...interfac
 }
 
 type MongoOptions struct {
-	MongodbUrl     string
-	Username       string
-	Password       string
-	CaCertFile     string
-	ClientCertFile string
-	Tls            bool
+	MongodbUrl string
+	CaCertFile string
 }
 
 var gracePeriod int64 = 0
@@ -115,13 +110,13 @@ func getK8SClientSet(kubeconfig []byte, contextName string) (*kubernetes.Clients
 	if len(kubeconfig) == 0 {
 		clientConfig, err = rest.InClusterConfig()
 		if err != nil {
-			err = errors.Wrap(err, "Unable to load in-cluster kubeconfig")
+			err = fmt.Errorf("Unable to load in-cluster kubeconfig: %w", err)
 			return nil, nil, err
 		}
 	} else {
 		config, err := clientcmd.Load(kubeconfig)
 		if err != nil {
-			err = errors.Wrap(err, "Unable to load kubeconfig")
+			err = fmt.Errorf("Unable to load kubeconfig: %w", err)
 			return nil, nil, err
 		}
 		if contextName != "" {
@@ -129,13 +124,13 @@ func getK8SClientSet(kubeconfig []byte, contextName string) (*kubernetes.Clients
 		}
 		clientConfig, err = clientcmd.NewDefaultClientConfig(*config, &clientcmd.ConfigOverrides{}).ClientConfig()
 		if err != nil {
-			err = errors.Wrap(err, "Unable to create client config from config")
+			err = fmt.Errorf("Unable to create client config from config: %w", err)
 			return nil, nil, err
 		}
 	}
 	clientset, err := kubernetes.NewForConfig(clientConfig)
 	if err != nil {
-		err = errors.Wrap(err, "Unable to create clientset")
+		err = fmt.Errorf("Unable to create clientset: %w", err)
 		return nil, nil, err
 	}
 	return clientset, clientConfig, nil
@@ -186,7 +181,7 @@ func (qp *QliksensePreflight) createPreflightTestDeployment(clientset *kubernete
 		result, err = deploymentsClient.Create(deployment)
 		return err
 	}); err != nil {
-		err = errors.Wrapf(err, "unable to create deployments in the %s namespace", namespace)
+		err = fmt.Errorf("unable to create deployments in the %s namespace: %w", namespace, err)
 		return nil, err
 	}
 	qp.P.LogVerboseMessage("Created deployment %q\n", result.GetObjectMeta().GetName())
@@ -201,7 +196,7 @@ func getDeployment(clientset *kubernetes.Clientset, namespace, depName string) (
 		deployment, err = deploymentsClient.Get(depName, v1.GetOptions{})
 		return err
 	}); err != nil {
-		err = errors.Wrapf(err, "unable to get deployments in the %s namespace", namespace)
+		err = fmt.Errorf("unable to get deployments in the %s namespace: %w", namespace, err)
 		api.LogDebugMessage("%v\n", err)
 		return nil, err
 	}
@@ -271,7 +266,7 @@ func getService(clientset *kubernetes.Clientset, namespace, svcName string) (*ap
 		svc, err = servicesClient.Get(svcName, v1.GetOptions{})
 		return err
 	}); err != nil {
-		err = errors.Wrapf(err, "unable to get services in the %s namespace", namespace)
+		err = fmt.Errorf("unable to get services in the %s namespace: %w", namespace, err)
 		return nil, err
 	}
 
@@ -314,7 +309,7 @@ func (qp *QliksensePreflight) deletePod(clientset *kubernetes.Clientset, namespa
 	return nil
 }
 
-func (qp *QliksensePreflight) createPreflightTestPod(clientset *kubernetes.Clientset, namespace, podName, imageName string, secretNames []string, commandToRun []string) (*apiv1.Pod, error) {
+func (qp *QliksensePreflight) createPreflightTestPod(clientset *kubernetes.Clientset, namespace, podName, imageName string, secretNames map[string]string, commandToRun []string) (*apiv1.Pod, error) {
 	// build the pod definition we want to deploy
 	pod := &apiv1.Pod{
 		ObjectMeta: v1.ObjectMeta{
@@ -337,7 +332,7 @@ func (qp *QliksensePreflight) createPreflightTestPod(clientset *kubernetes.Clien
 		},
 	}
 	if len(secretNames) > 0 {
-		for _, secretName := range secretNames {
+		for secretName, mountPath := range secretNames {
 			pod.Spec.Volumes = append(pod.Spec.Volumes, apiv1.Volume{
 				Name: secretName,
 				VolumeSource: apiv1.VolumeSource{
@@ -346,7 +341,7 @@ func (qp *QliksensePreflight) createPreflightTestPod(clientset *kubernetes.Clien
 						Items: []apiv1.KeyToPath{
 							{
 								Key:  secretName,
-								Path: secretName,
+								Path: filepath.Base(mountPath),
 							},
 						},
 					},
@@ -355,7 +350,7 @@ func (qp *QliksensePreflight) createPreflightTestPod(clientset *kubernetes.Clien
 			if len(pod.Spec.Containers) > 0 {
 				pod.Spec.Containers[0].VolumeMounts = append(pod.Spec.Containers[0].VolumeMounts, apiv1.VolumeMount{
 					Name:      secretName,
-					MountPath: "/etc/ssl/" + secretName,
+					MountPath: filepath.Dir(mountPath),
 					ReadOnly:  true,
 				})
 			}
@@ -470,13 +465,13 @@ func waitForPod(clientset *kubernetes.Clientset, namespace string, pod *apiv1.Po
 	}
 	validateFunc := func(data interface{}) bool {
 		po := data.(*apiv1.Pod)
-		return len(po.Status.ContainerStatuses) > 0 && po.Status.ContainerStatuses[0].Ready
+		return po.Status.Phase == apiv1.PodRunning || po.Status.Phase == apiv1.PodSucceeded || po.Status.Phase == apiv1.PodFailed
 	}
 
 	if err := waitForResource(checkFunc, validateFunc); err != nil {
 		return err
 	}
-	if len(pod.Status.ContainerStatuses) == 0 || !pod.Status.ContainerStatuses[0].Ready {
+	if pod.Status.Phase != apiv1.PodRunning && pod.Status.Phase != apiv1.PodSucceeded && pod.Status.Phase != apiv1.PodFailed {
 		err = fmt.Errorf("container is taking much longer than expected")
 		return err
 	}
@@ -491,7 +486,6 @@ func waitForPodToDie(clientset *kubernetes.Clientset, namespace string, pod *api
 			err = fmt.Errorf("unable to retrieve %s pod by name", podName)
 			return nil, err
 		}
-		api.LogDebugMessage("pod status: %v\n", po.Status.Phase)
 		return po, nil
 	}
 	validateFunc := func(r interface{}) bool {

pkg/qliksense/config.go

@@ -40,7 +40,7 @@ func (q *Qliksense) ConfigApplyQK8s() error {
 	}
 
 	// create patch dependent resoruces
-	fmt.Println("Installing resoruces used kuztomize patch")
+	fmt.Println("Installing resources used by the kuztomize patch")
 	if err := q.createK8sResoruceBeforePatch(qcr); err != nil {
 		return err
 	}
@@ -89,11 +89,13 @@ func (q *Qliksense) applyConfigToK8s(qcr *qapi.QliksenseCR) error {
 	cr.GeneratePatches(&qcr.KApiCr, path.Join(userHomeDir, ".kube", "config"))
 	// apply generated manifests
 	profilePath := filepath.Join(qcr.Spec.GetManifestsRoot(), qcr.Spec.GetProfileDir())
+	fmt.Printf("Generating manifests for profile: %v\n", profilePath)
 	mByte, err := ExecuteKustomizeBuild(profilePath)
 	if err != nil {
-		fmt.Println("cannot generate manifests for "+profilePath, err)
+		fmt.Printf("error generating manifests: %v\n", err)
 		return err
 	}
+	fmt.Println("Applying manifests to the cluster")
 	if err = qapi.KubectlApply(string(mByte), qcr.GetNamespace()); err != nil {
 		return err
 	}

pkg/qliksense/context_configs.go

@@ -522,7 +522,7 @@ func (q *Qliksense) SetUpQliksenseContext(contextName string) error {
 	}
 
 	// set the encrypted default mongo
-	return q.SetSecrets([]string{`qliksense.mongoDbUri="mongodb://qlik-default-mongodb:27017/qliksense?ssl=false"`}, false, false)
+	return q.SetSecrets([]string{`qliksense.mongodbUri="mongodb://qlik-default-mongodb:27017/qliksense?ssl=false"`}, false, false)
 }
 
 func validateInput(input string) (string, error) {

pkg/qliksense/context_configs_test.go

@@ -29,7 +29,7 @@ const (
 var targetFileStringTemplate = `
 apiVersion: v1
 data:
-  mongoDbUri: %s
+  mongodbUri: %s
 kind: Secret
 metadata:
   name: testctx-qliksense-senseinstaller
@@ -296,7 +296,7 @@ func TestSetConfigs(t *testing.T) {
 				q: &Qliksense{
 					QliksenseHome: testDir,
 				},
-				args: []string{"qliksense.acceptEULA=\"yes\"", "qliksense.mongoDbUri=\"mongo://mongo:3307\""},
+				args: []string{"qliksense.acceptEULA=\"yes\"", "qliksense.mongodbUri=\"mongo://mongo:3307\""},
 			},
 			wantErr: false,
 		},
@@ -572,7 +572,7 @@ func Test_SetSecrets(t *testing.T) {
 				QliksenseHome: testDir,
 			},
 			args: args{
-				args:        []string{"qliksense.mongoDbUri=\"mongodb://qlik-default-mongodb:27017/qliksense?ssl=false\""},
+				args:        []string{"qliksense.mongodbUri=\"mongodb://qlik-default-mongodb:27017/qliksense?ssl=false\""},
 				isSecretSet: false,
 			},
 			wantErr: false,
@@ -583,7 +583,7 @@ func Test_SetSecrets(t *testing.T) {
 				QliksenseHome: testDir,
 			},
 			args: args{
-				args:        []string{"qliksense.mongoDbUri=bW9uZ29kYjovL3FsaWstZGVmYXVsdC1tb25nb2RiOjI3MDE3L3FsaWtzZW5zZT9zc2w9ZmFsc2U="},
+				args:        []string{"qliksense.mongodbUri=bW9uZ29kYjovL3FsaWstZGVmYXVsdC1tb25nb2RiOjI3MDE3L3FsaWtzZW5zZT9zc2w9ZmFsc2U="},
 				isSecretSet: false,
 				base64:      true,
 			},
@@ -595,7 +595,7 @@ func Test_SetSecrets(t *testing.T) {
 				QliksenseHome: testDir,
 			},
 			args: args{
-				args:        []string{"qliksense.mongoDbUri=\"mongo://mongo:3307\""},
+				args:        []string{"qliksense.mongodbUri=\"mongo://mongo:3307\""},
 				isSecretSet: true,
 			},
 			wantErr: false,
@@ -606,7 +606,7 @@ func Test_SetSecrets(t *testing.T) {
 				QliksenseHome: testDir,
 			},
 			args: args{
-				args:        []string{"qliksense.mongoDbUri=\"mongodb://qlik-default-mongodb:27017/qliksense?ssl=false\""},
+				args:        []string{"qliksense.mongodbUri=\"mongodb://qlik-default-mongodb:27017/qliksense?ssl=false\""},
 				isSecretSet: true,
 			},
 			wantErr: false,

pkg/qliksense/context_configs_unset.go

@@ -0,0 +1,109 @@
+package qliksense
+
+import (
+	"fmt"
+	"strings"
+
+	"reflect"
+
+	kconfig "github.com/qlik-oss/k-apis/pkg/config"
+	"github.com/qlik-oss/sense-installer/pkg/api"
+)
+
+func (q *Qliksense) UnsetCmd(args []string) error {
+	return unsetAll(q.QliksenseHome, args)
+}
+func unsetAll(qHome string, args []string) error {
+	qConfig := api.NewQConfig(qHome)
+
+	qcr, err := qConfig.GetCurrentCR()
+	if err != nil {
+		return err
+	}
+
+	// either delete all args or none
+	for _, arg := range args {
+		isRemoved := false
+		// delete if key present
+		if !strings.Contains(arg, ".") {
+			if isRemoved = unsetOnlyKey(arg, qcr); isRemoved {
+				//continue to the next arg
+				continue
+			} else if isRemoved = unsetServiceName(arg, qcr); isRemoved {
+				//continue to the next arg
+				continue
+			} else {
+				return fmt.Errorf("%s not found in the context", arg)
+			}
+		}
+		// delete key inside configs if present
+		// delete key inside secrets if present
+		if isRemoved = unsetServiceKey(arg, qcr); !isRemoved {
+			return fmt.Errorf("%s not found in the context", arg)
+		}
+	}
+
+	return qConfig.WriteCR(qcr)
+}
+func unsetOnlyKey(key string, qcr *api.QliksenseCR) bool {
+
+	v := reflect.ValueOf(qcr.Spec).Elem().FieldByName(strings.Title(key))
+	if v.IsValid() && v.CanSet() {
+		v.SetString("")
+		return true
+	}
+	return false
+}
+
+func unsetServiceName(svc string, qcr *api.QliksenseCR) bool {
+	if qcr.Spec.Configs != nil && qcr.Spec.Configs[svc] != nil {
+		delete(qcr.Spec.Configs, svc)
+		return true
+	}
+
+	if qcr.Spec.Secrets != nil && qcr.Spec.Secrets[svc] != nil {
+		delete(qcr.Spec.Secrets, svc)
+		return true
+	}
+	return false
+}
+
+func unsetServiceKey(svcKey string, qcr *api.QliksenseCR) bool {
+	sk := strings.Split(svcKey, ".")
+	svc := sk[0]
+	key := sk[1]
+
+	if qcr.Spec.Configs != nil && qcr.Spec.Configs[svc] != nil {
+		index := findIndex(key, qcr.Spec.Configs[svc])
+		if index > -1 {
+			qcr.Spec.Configs[svc][index] = qcr.Spec.Configs[svc][len(qcr.Spec.Configs[svc])-1]
+			qcr.Spec.Configs[svc] = qcr.Spec.Configs[svc][:len(qcr.Spec.Configs[svc])-1]
+			if len(qcr.Spec.Configs[svc]) == 0 {
+				delete(qcr.Spec.Configs, svc)
+			}
+			return true
+		}
+	}
+
+	if qcr.Spec.Secrets != nil && qcr.Spec.Secrets[svc] != nil {
+		index := findIndex(key, qcr.Spec.Secrets[svc])
+		if index > -1 {
+			qcr.Spec.Secrets[svc][index] = qcr.Spec.Secrets[svc][len(qcr.Spec.Secrets[svc])-1]
+			qcr.Spec.Secrets[svc] = qcr.Spec.Secrets[svc][:len(qcr.Spec.Secrets[svc])-1]
+			if len(qcr.Spec.Secrets[svc]) == 0 {
+				delete(qcr.Spec.Secrets, svc)
+			}
+			return true
+		}
+	}
+	return false
+}
+
+func findIndex(elem string, nvs kconfig.NameValues) int {
+	for i, nv := range nvs {
+		if nv.Name == elem {
+			return i
+		}
+	}
+	return -1
+}

pkg/qliksense/context_configs_unset_test.go

@@ -0,0 +1,99 @@
+package qliksense
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/qlik-oss/sense-installer/pkg/api"
+	_ "gopkg.in/yaml.v2"
+)
+
+func TestUnsetAll(t *testing.T) {
+	qHome, _ := ioutil.TempDir("", "")
+	testPepareDir(qHome)
+	defer os.RemoveAll(qHome)
+	//fmt.Print(qHome)
+	args := []string{"rotateKeys", "qliksense", "qliksense2.acceptEula3", "serviceA.acceptEula"}
+	if err := unsetAll(qHome, args); err != nil {
+		t.Log("error during unset", err)
+		t.FailNow()
+	}
+	qc := api.NewQConfig(qHome)
+	qcr, err := qc.GetCurrentCR()
+	if err != nil {
+		t.Log("error while getting current cr", err)
+		t.FailNow()
+	}
+	if qcr.Spec.RotateKeys != "" {
+		t.Log("Expected empty rotateKeys but got: " + qcr.Spec.RotateKeys)
+		t.Fail()
+	}
+
+	if qcr.Spec.Configs["qliksense"] != nil {
+		t.Log("qliksense in configs not deleted")
+		t.Fail()
+	}
+	if len(qcr.Spec.Configs["qliksense2"]) != 1 {
+		t.Log("qliksense2.acceptEula3 not deleted")
+		t.Fail()
+	}
+	if qcr.Spec.Configs["serviceA"] != nil {
+		t.Log("serviceA not deleted")
+		t.Fail()
+	}
+}
+
+func testPepareDir(qHome string) {
+
+	config :=
+		`
+apiVersion: config.qlik.com/v1
+kind: QliksenseConfig
+metadata:
+  name: qliksenseConfig
+spec:
+  contexts:
+  - name: qlik-default
+    crFile: contexts/qlik-default/qlik-default.yaml
+  currentContext: qlik-default
+`
+	configFile := filepath.Join(qHome, "config.yaml")
+	// tests/config.yaml exists
+	ioutil.WriteFile(configFile, []byte(config), 0777)
+
+	contextYaml :=
+		`
+apiVersion: qlik.com/v1
+kind: Qliksense
+metadata:
+  name: qlik-default
+spec:
+  profile: docker-desktop
+  rotateKeys: "yes"
+  configs:
+    qliksense:
+    - name: acceptEula
+      value: some
+    qliksense2:
+    - name: acceptEula2
+      value: some
+    - name: acceptEula3
+      value: some
+    serviceA:
+    - name: acceptEula
+      value: some
+`
+	qlikDefaultContext := "qlik-default"
+	// create contexts/qlik-default/ under tests/
+	contexts := "contexts"
+	contextsDir := filepath.Join(qHome, contexts, qlikDefaultContext)
+	if err := os.MkdirAll(contextsDir, 0777); err != nil {
+		err = fmt.Errorf("Not able to create directories")
+	}
+
+	contextFile := filepath.Join(contextsDir, qlikDefaultContext+".yaml")
+	ioutil.WriteFile(contextFile, []byte(contextYaml), 0777)
+}

pkg/qliksense/crds.go

@@ -5,7 +5,15 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/mitchellh/go-homedir"
 	qapi "github.com/qlik-oss/sense-installer/pkg/api"
+	apixv1beta1client "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/tools/clientcmd"
+	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
+	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/resource"
 )
 
 type CrdCommandOptions struct {
@@ -20,11 +28,11 @@ func (q *Qliksense) ViewCrds(opts *CrdCommandOptions) error {
 		fmt.Println("cannot get the current-context cr", err)
 		return err
 	}
-	engineCRD, err := getQliksenseInitCrd(qcr)
+	engineCRD, err := getQliksenseInitCrds(qcr)
 	if err != nil {
 		return err
 	}
-	customCrd, err := getCustomCrd(qcr)
+	customCrd, err := getCustomCrds(qcr)
 	if err != nil {
 		return nil
 	}
@@ -51,12 +59,12 @@ func (q *Qliksense) InstallCrds(opts *CrdCommandOptions) error {
 		return err
 	}
 
-	if engineCRD, err := getQliksenseInitCrd(qcr); err != nil {
+	if engineCRD, err := getQliksenseInitCrds(qcr); err != nil {
 		return err
 	} else if err = qapi.KubectlApply(engineCRD, ""); err != nil {
 		return err
 	}
-	if customCrd, err := getCustomCrd(qcr); err != nil {
+	if customCrd, err := getCustomCrds(qcr); err != nil {
 		return err
 	} else if customCrd != "" {
 		if err = qapi.KubectlApply(customCrd, ""); err != nil {
@@ -73,7 +81,7 @@ func (q *Qliksense) InstallCrds(opts *CrdCommandOptions) error {
 	return nil
 }
 
-func getQliksenseInitCrd(qcr *qapi.QliksenseCR) (string, error) {
+func getQliksenseInitCrds(qcr *qapi.QliksenseCR) (string, error) {
 	var repoPath string
 	var err error
 
@@ -98,7 +106,7 @@ func getQliksenseInitCrd(qcr *qapi.QliksenseCR) (string, error) {
 	return string(qInitByte), nil
 }
 
-func getCustomCrd(qcr *qapi.QliksenseCR) (string, error) {
+func getCustomCrds(qcr *qapi.QliksenseCR) (string, error) {
 	crdPath := qcr.GetCustomCrdsPath()
 	if crdPath == "" {
 		return "", nil
@@ -110,3 +118,77 @@ func getCustomCrd(qcr *qapi.QliksenseCR) (string, error) {
 	}
 	return string(qInitByte), nil
 }
+
+func (q *Qliksense) CheckAllCrdsInstalled() (bool, error) {
+	qConfig := qapi.NewQConfig(q.QliksenseHome)
+	qcr, err := qConfig.GetCurrentCR()
+	if err != nil {
+		return false, err
+	}
+
+	customResourceDefinitionInterface, err := getCustomResourceDefinitionInterface()
+	if err != nil {
+		return false, err
+	}
+
+	if engineCRDs, err := getQliksenseInitCrds(qcr); err != nil {
+		return false, err
+	} else if allInstalled, err := checkCrdsInstalled(engineCRDs, customResourceDefinitionInterface); err != nil {
+		return false, err
+	} else if !allInstalled {
+		return false, nil
+	}
+
+	if customCrds, err := getCustomCrds(qcr); err != nil {
+		return false, err
+	} else if allInstalled, err := checkCrdsInstalled(customCrds, customResourceDefinitionInterface); err != nil {
+		return false, err
+	} else if !allInstalled {
+		return false, nil
+	}
+
+	if allInstalled, err := checkCrdsInstalled(q.GetOperatorCRDString(), customResourceDefinitionInterface); err != nil {
+		return false, err
+	} else if !allInstalled {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+func checkCrdsInstalled(crds string, customResourceDefinitionInterface apixv1beta1client.CustomResourceDefinitionInterface) (bool, error) {
+	kuzResourceFactory := resmap.NewFactory(resource.NewFactory(kunstruct.NewKunstructuredFactoryImpl()), nil)
+	if kuzResMap, err := kuzResourceFactory.NewResMapFromBytes([]byte(crds)); err != nil {
+		return false, err
+	} else {
+		for _, kuzRes := range kuzResMap.Resources() {
+			if customResourceDefinition, err := customResourceDefinitionInterface.Get(kuzRes.GetName(), v1.GetOptions{}); err != nil && apierrors.IsNotFound(err) {
+				return false, nil
+			} else if err != nil {
+				return false, err
+			} else if customResourceDefinition == nil {
+				return false, fmt.Errorf("failed looking up crd: %v", kuzRes.GetName())
+			}
+		}
+		return true, nil
+	}
+}
+
+func getCustomResourceDefinitionInterface() (apixv1beta1client.CustomResourceDefinitionInterface, error) {
+	homeDir, err := homedir.Dir()
+	if err != nil {
+		return nil, err
+	}
+	kubeconfigPath := filepath.Join(homeDir, ".kube", "config")
+	k8sRestConfig, err := clientcmd.BuildConfigFromFlags("", kubeconfigPath)
+	if err != nil {
+		return nil, err
+	}
+
+	apixClient, err := apixv1beta1client.NewForConfig(k8sRestConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	return apixClient.CustomResourceDefinitions(), nil
+}

pkg/qliksense/crds_test.go

@@ -1,8 +1,18 @@
 package qliksense
 
 import (
+	"io/ioutil"
+	"os"
 	"testing"
 
+	apixv1beta1client "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
+	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/resource"
+
+	"github.com/gobuffalo/packr/v2"
+
 	kapi_config "github.com/qlik-oss/k-apis/pkg/config"
 	qapi "github.com/qlik-oss/sense-installer/pkg/api"
 )
@@ -13,7 +23,7 @@ func TestGetQliksenseInitCrd(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	crdFromContextConfig, err := getQliksenseInitCrd(&qapi.QliksenseCR{
+	crdFromContextConfig, err := getQliksenseInitCrds(&qapi.QliksenseCR{
 		KApiCr: kapi_config.KApiCr{
 			Spec: &kapi_config.CRSpec{
 				ManifestsRoot: someTmpRepoPath,
@@ -24,7 +34,7 @@ func TestGetQliksenseInitCrd(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	crdFromDownloadedConfig, err := getQliksenseInitCrd(&qapi.QliksenseCR{
+	crdFromDownloadedConfig, err := getQliksenseInitCrds(&qapi.QliksenseCR{
 		KApiCr: kapi_config.KApiCr{
 			Spec: &kapi_config.CRSpec{
 				ManifestsRoot: "",
@@ -39,3 +49,87 @@ func TestGetQliksenseInitCrd(t *testing.T) {
 		t.Fatalf("expected %v to equal %v, but they didn't", crdFromContextConfig, crdFromDownloadedConfig)
 	}
 }
+
+func TestCheckAllCrdsInstalled(t *testing.T) {
+	t.Skip("Skipping this test because it makes kubernetes calls")
+
+	tmpQlikSenseHome, err := ioutil.TempDir("", "tmp-qlik-sense-home-")
+	if err != nil {
+		t.Fatalf("unexpected error creating tmp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpQlikSenseHome)
+
+	setupQliksenseTestDefaultContext(t, tmpQlikSenseHome, `
+apiVersion: qlik.com/v1
+kind: Qliksense
+metadata:
+  name: qlik-default
+spec:
+  profile: docker-desktop
+`)
+
+	q := &Qliksense{
+		QliksenseHome: tmpQlikSenseHome,
+		CrdBox:        packr.New("crds", "./crds"),
+	}
+
+	if err := q.FetchQK8s("v1.50.3"); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if allInstalled, err := q.CheckAllCrdsInstalled(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	} else if allInstalled {
+		t.Fatal("expected crds to NOT be installed at this point")
+	}
+
+	if err := q.InstallCrds(&CrdCommandOptions{All: true}); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	} else if allInstalled, err := q.CheckAllCrdsInstalled(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	} else if !allInstalled {
+		t.Fatal("expected crds to BE installed at this point")
+	}
+
+	//cleanup:
+	qConfig := qapi.NewQConfig(q.QliksenseHome)
+	qcr, err := qConfig.GetCurrentCR()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	customResourceDefinitionInterface, err := getCustomResourceDefinitionInterface()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if engineCRDs, err := getQliksenseInitCrds(qcr); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	} else if err := deleteCrds(engineCRDs, customResourceDefinitionInterface); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if customCrd, err := getCustomCrds(qcr); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	} else if err := deleteCrds(customCrd, customResourceDefinitionInterface); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if err := deleteCrds(q.GetOperatorCRDString(), customResourceDefinitionInterface); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func deleteCrds(crds string, customResourceDefinitionInterface apixv1beta1client.CustomResourceDefinitionInterface) error {
+	kuzResourceFactory := resmap.NewFactory(resource.NewFactory(kunstruct.NewKunstructuredFactoryImpl()), nil)
+	if kuzResMap, err := kuzResourceFactory.NewResMapFromBytes([]byte(crds)); err != nil {
+		return err
+	} else {
+		for _, kuzRes := range kuzResMap.Resources() {
+			if err := customResourceDefinitionInterface.Delete(kuzRes.GetName(), &v1.DeleteOptions{}); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+}

pkg/qliksense/docker_test.go

@@ -225,7 +225,7 @@ spec:
 		return false
 	}
 	if !haveMatchingImage(func(image string) bool {
-		return strings.Contains(image, "qlik-docker-oss.bintray.io/qliksense-operator:v")
+		return strings.Contains(image, "qlik-docker-oss.bintray.io/qliksense-operator:")
 	}) {
 		t.Fatal("expected to find the operator image in the list, but it wasn't there")
 	}
@@ -245,7 +245,7 @@ spec:
 		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 == "mongo"
+		return image == "qlik-docker-oss.bintray.io/preflight-mongo"
 	}) {
 		t.Fatal("expected to find the mongo Preflight image in the list, but it wasn't there")
 	}

pkg/qliksense/fetch.go

@@ -2,7 +2,6 @@ package qliksense
 
 import (
 	"bufio"
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -54,10 +53,7 @@ func (q *Qliksense) FetchK8sWithOpts(opts *FetchCommandOptions) error {
 		cr.SetFetchUrl(opts.GitUrl)
 	}
 	v := getVersion(opts, cr)
-	if v == "" {
-		return errors.New("Cannot find gitref/tag/branch/version to fetch")
-	}
-	if qConfig.IsRepoExistForCurrent(v) {
+	if v != "" && qConfig.IsRepoExistForCurrent(v) {
 		if opts.Overwrite || getVerionsOverwriteConfirmation(v) == "y" {
 			if err := qConfig.DeleteRepoForCurrent(v); err != nil {
 				return err

pkg/qliksense/get_installable_versions.go

@@ -144,7 +144,7 @@ func getLatestTag(repoUrl, accessToken string) (string, error) {
 		v, err := semver.NewVersion(sv)
 		if err != nil {
 			// it may happen, in the repo some tags may not conform to semver
-			fmt.Print("Unconform tags: " + sv)
+			//fmt.Println("the tag is not conform to semver: " + sv)
 			continue
 		}
 		if maxSem == nil || maxSem.LessThan(v) {

pkg/qliksense/get_installable_versions_test.go

@@ -17,9 +17,9 @@ func TestGetLatestTag(t *testing.T) {
 		t.Log(err)
 		t.Log(sv)
 	}
-	baseV, _ := semver.NewVersion("v0.0.7")
+	baseV, _ := semver.NewVersion("v0.0.8")
 	if !sv.GreaterThan(baseV) {
-		t.Log("Expected greater than v0.0.7, but got:  " + s)
+		t.Log("Expected greater than v0.0.8, but got:  " + s)
 		t.Fail()
 	}
 }

pkg/qliksense/install.go

@@ -8,7 +8,9 @@ import (
 	"path"
 	"path/filepath"
 
+	"github.com/mitchellh/go-homedir"
 	"github.com/qlik-oss/k-apis/pkg/config"
+	"github.com/qlik-oss/k-apis/pkg/cr"
 	"sigs.k8s.io/kustomize/api/filesys"
 
 	qapi "github.com/qlik-oss/sense-installer/pkg/api"
@@ -16,8 +18,9 @@ import (
 
 type InstallCommandOptions struct {
 	StorageClass string
-	MongoDbUri   string
+	MongodbUri   string
 	RotateKeys   string
+	DryRun       bool
 }
 
 func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, keepPatchFiles bool) error {
@@ -42,8 +45,8 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 	}
 
 	qcr.SetEULA("yes")
-	if opts.MongoDbUri != "" {
-		qcr.Spec.AddToSecrets("qliksense", "mongoDbUri", opts.MongoDbUri, "")
+	if opts.MongodbUri != "" {
+		qcr.Spec.AddToSecrets("qliksense", "mongodbUri", opts.MongodbUri, "")
 	}
 	if opts.StorageClass != "" {
 		qcr.Spec.StorageClassName = opts.StorageClass
@@ -51,17 +54,28 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 	if opts.RotateKeys != "" {
 		qcr.Spec.RotateKeys = opts.RotateKeys
 	}
+	// for debugging purpose
+	if opts.DryRun {
+		// generate patches
+		qcr.Spec.RotateKeys = "None"
+		userHomeDir, _ := homedir.Dir()
+		fmt.Println("Generating patches only")
+		cr.GeneratePatches(&qcr.KApiCr, path.Join(userHomeDir, ".kube", "config"))
+		return nil
+	}
 	qConfig.WriteCurrentContextCR(qcr)
 
+	if installed, err := q.CheckAllCrdsInstalled(); err != nil {
+		fmt.Println("error verifying whether CRDs are installed", err)
+		return err
+	} else if !installed {
+		return errors.New(`please install CRDs by executing: $ qliksense crds install --all`)
+	}
+
 	if err := applyImagePullSecret(qConfig); err != nil {
 		return err
 	}
 
-	// check if acceptEULA is yes or not
-	if !qcr.IsEULA() {
-		return errors.New(agreementTempalte + "\n Please do $ qliksense install --acceptEULA=yes\n")
-	}
-
 	//CRD will be installed outside of operator
 	//install operator controller into the namespace
 	fmt.Println("Installing operator controller")
@@ -74,7 +88,7 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 	}
 
 	// create patch dependent resoruces
-	fmt.Println("Installing resoruces used kuztomize patch")
+	fmt.Println("Installing resources used by the kuztomize patch")
 	if err := q.createK8sResoruceBeforePatch(qcr); err != nil {
 		return err
 	}
@@ -103,7 +117,7 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 	}
 
 	// install generated manifests into cluster
-	fmt.Println("Installing generated manifests into cluster")
+	fmt.Println("Installing generated manifests into the cluster")
 
 	if dcr, err := qConfig.GetDecryptedCr(qcr); err != nil {
 		return err
@@ -181,7 +195,7 @@ images:
 func (q *Qliksense) applyCR(cr *qapi.QliksenseCR) error {
 	// install operator cr into cluster
 	//get the current context cr
-	fmt.Println("Install operator CR into cluster")
+	fmt.Println("Installing operator CR into the cluster")
 	r, err := cr.GetString()
 	if err != nil {
 		return err

pkg/qliksense/install_test.go

@@ -43,7 +43,7 @@ spec:
       value: "yes"
   secrets:
     qliksense:
-    - name: mongoDbUri
+    - name: mongodbUri
       value: mongodb://qlik-default-mongodb:27017/qliksense?ssl=false
   profile: docker-desktop
   rotateKeys: "yes"`

pkg/qliksense/load_cr_test.go

@@ -35,7 +35,7 @@ spec:
       value: "yes"
   secrets:
     qliksense:
-    - name: mongoDbUri
+    - name: mongodbUri
       value: mongodb://qlik-default-mongodb:27017/qliksense?ssl=false
   profile: docker-desktop
   rotateKeys: "yes"`
@@ -62,7 +62,7 @@ spec:
       value: "yes"
   secrets:
     qliksense:
-    - name: mongoDbUri
+    - name: mongodbUri
       value: mongodb://qlik-default-mongodb:27017/qliksense?ssl=false
   profile: docker-desktop
   rotateKeys: "yes"`