[action] Remove MacOS from matrix

* preflight mongo check working with ca cert

.github/workflows/build.yml

@@ -4,24 +4,43 @@ on: [pull_request]
 
 jobs:
 
+  test:
+    name: Test
+    env:
+      CGO_ENABLED: 0
+    strategy:
+      matrix:
+        go: [1.13.x]
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - name: Set up Go ${{ matrix.go }}
+      uses: actions/setup-go@v2-beta
+      with:
+        go-version: ${{ matrix.go }}
+
+    - uses: actions/checkout@v2
+
+    - name: setup make (Windows)
+      if: matrix.os == 'windows-latest'
+      run: choco install make -y
+
+    - run: make test
+
   build:
     name: Build
     runs-on: ubuntu-latest
+    needs: test
+
     steps:
     - name: Set up Go 1.13
-      uses: actions/setup-go@v1
+      uses: actions/setup-go@v2-beta
       with:
         go-version: 1.13
 
     - uses: actions/checkout@v2
-    - run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
-    - name: Set GOPATH
-        # temporary fix
-        # see https://github.com/actions/setup-go/issues/14
-      run: |
-        echo "##[set-env name=GOPATH;]$(dirname $GITHUB_WORKSPACE)"
-        echo "##[add-path]$(dirname $GITHUB_WORKSPACE)/bin"
-      shell: bash
 
-    - run: make test
+    - run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
+
     - run: make xbuild-all

.github/workflows/release.yml

@@ -12,19 +12,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Set up Go 1.13
-      uses: actions/setup-go@v1
+      uses: actions/setup-go@v2-beta
       with:
         go-version: 1.13
 
     - uses: actions/checkout@v2
     - run: git fetch --depth=1 origin +refs/tags/*:refs/tags/* # Needed in makefile for versioning
-    - name: Set GOPATH
-        # temporary fix
-        # see https://github.com/actions/setup-go/issues/14
-      run: |
-        echo "##[set-env name=GOPATH;]$(dirname $GITHUB_WORKSPACE)"
-        echo "##[add-path]$(dirname $GITHUB_WORKSPACE)/bin"
-      shell: bash
 
     - run: make test
     - run: make xbuild-all

Makefile

@@ -39,18 +39,18 @@ endif
 
 .PHONY: build
 build: clean generate
-	mkdir -p $(BINDIR)
+	go run _make_support/mkdir_all/do.go $(BINDIR)
 	go build -ldflags '$(LDFLAGS)' -tags "$(BUILDTAGS)" -o $(BINDIR)/$(MIXIN)$(FILE_EXT) ./cmd/$(MIXIN)
 	$(MAKE) clean
 
 .PHONY: test-setup
 test-setup: clean generate
 ifeq ($(shell ${WHICH} docker-registry 2>${DEVNUL}),)
-	$(eval TMP-docker-distribution := $(shell mktemp -d))
-	git clone https://github.com/docker/distribution.git $(TMP-docker-distribution)/docker-distribution
-	cd $(TMP-docker-distribution)/docker-distribution; git checkout -b v2.7.1; make
-	cp $(TMP-docker-distribution)/docker-distribution/bin/registry pkg/qliksense/docker-registry
-	-rm -rf $(TMP-docker-distribution)
+	$(eval TMP-docker-distribution := $(shell go run _make_support/get_tmp_dir/do.go))
+	git clone https://github.com/docker/distribution.git "$(TMP-docker-distribution)/docker-distribution"
+	cd "$(TMP-docker-distribution)/docker-distribution" && git checkout -b v2.7.1 && $(MAKE)
+	go run _make_support/copy/do.go --src "$(TMP-docker-distribution)/docker-distribution/bin/registry" --dst pkg/qliksense/docker-registry$(FILE_EXT)
+	go run _make_support/remove_all/do.go "$(TMP-docker-distribution)"
 endif
 
 .PHONY: test-short
@@ -86,6 +86,7 @@ endif
 
 generate: get-crds packr2
 	go generate ./...
+	go run _make_support/remove_all/do.go pkg/qliksense/crds
 
 packr2:
 ifeq ($(shell ${WHICH} packr2 2>${DEVNUL}),)
@@ -93,22 +94,22 @@ ifeq ($(shell ${WHICH} packr2 2>${DEVNUL}),)
 endif
 
 clean: clean-packr
-	-rm -fr pkg/qliksense/crds
+	go run _make_support/remove_all/do.go pkg/qliksense/crds
 
 clean-packr: packr2
 	cd pkg/qliksense && packr2 clean
 
 get-crds:
 ifeq ($(QLIKSENSE_OPERATOR_DIR),)
-	$(eval TMP-operator := $(shell mktemp -d))
+	$(eval TMP-operator := $(shell go run _make_support/get_tmp_dir/do.go))
 	git clone https://github.com/qlik-oss/qliksense-operator.git -b master $(TMP-operator)/operator
-	$(MAKE) QLIKSENSE_OPERATOR_DIR=$(TMP-operator)/operator get-crds
-	-rm -rf $(TMP-operator)
+	$(MAKE) QLIKSENSE_OPERATOR_DIR="$(TMP-operator)/operator" get-crds
+	go run _make_support/remove_all/do.go "$(TMP-operator)"
 else
-	mkdir -p pkg/qliksense/crds/cr
-	mkdir -p pkg/qliksense/crds/crd
-	mkdir -p pkg/qliksense/crds/crd-deploy
-	cp $(QLIKSENSE_OPERATOR_DIR)/deploy/*.yaml pkg/qliksense/crds/crd-deploy
-	cp $(QLIKSENSE_OPERATOR_DIR)/deploy/crds/*_crd.yaml pkg/qliksense/crds/crd
-	cp $(QLIKSENSE_OPERATOR_DIR)/deploy/crds/*_cr.yaml pkg/qliksense/crds/cr
+	go run _make_support/mkdir_all/do.go pkg/qliksense/crds/cr
+	go run _make_support/mkdir_all/do.go pkg/qliksense/crds/crd
+	go run _make_support/mkdir_all/do.go pkg/qliksense/crds/crd-deploy
+	go run _make_support/copy/do.go --src-pattern "$(QLIKSENSE_OPERATOR_DIR)/deploy/*.yaml" --dst pkg/qliksense/crds/crd-deploy
+	go run _make_support/copy/do.go --src-pattern "$(QLIKSENSE_OPERATOR_DIR)/deploy/crds/*_crd.yaml" --dst pkg/qliksense/crds/crd
+	go run _make_support/copy/do.go --src-pattern "$(QLIKSENSE_OPERATOR_DIR)/deploy/crds/*_cr.yaml" --dst pkg/qliksense/crds/cr
 endif

README.md

@@ -1,16 +1,12 @@
-# (WIP) Qlik Sense installation and operations CLI
+# (WIP) Qlik Sense on Kubernetes installation and operations CLI
 
 ## Documentation
 
-To learn more about Qlik Sense installer go to https://qlik-oss.github.io/sense-installer/
+To learn more about Qlik Sense on Kubernetes CLI go to https://qlik-oss.github.io/sense-installer/
 
 ## About
 
-The Qlik Sense installer CLI (qliksense) provides an imperative interface to many of the configurations that need to be applied against the declarative structure described in [qliksense-k8s](https://github.com/qlik-oss/qliksense-k8s). This cli facilitates:
-
-- installation of QSEoK
-- installation of qliksense operator to manage QSEoK
-- air gapped installation of QSEoK
+The QSEoK CLI (qliksense) provides an imperative interface to many of the configurations that need to be applied against the declarative structure described in [qliksense-k8s](https://github.com/qlik-oss/qliksense-k8s).
 
 This is a technology preview that uses Qlik modified [kustomize](https://github.com/qlik-oss/kustomize) to kubernetes manifests of the versions of the [qliksense-k8s](https://github.com/qlik-oss/qliksense-k8s) repository.
 

_make_support/copy/do.go

@@ -0,0 +1,109 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/otiai10/copy"
+)
+
+func main() {
+	srcPattern := flag.String("src-pattern", "", "Source file pattern")
+	src := flag.String("src", "", "Source file or directory")
+	dst := flag.String("dst", "", "Destination file or directory")
+	flag.Parse()
+
+	if *srcPattern != "" {
+		if dstInfo, err := os.Lstat(*dst); err != nil {
+			panic(err)
+		} else if !dstInfo.IsDir() {
+			panic(fmt.Errorf("%v must be a directory", *dst))
+		}
+
+		if matches, err := filepath.Glob(*srcPattern); err != nil {
+			panic(err)
+		} else {
+			for _, match := range matches {
+				srcInfo, err := os.Lstat(match)
+				if err != nil {
+					panic(err)
+				}
+				if srcInfo.IsDir() {
+					if err := copy.Copy(match, *dst, copy.Options{
+						OnSymlink: func(p string) copy.SymlinkAction {
+							return copy.Skip
+						},
+					}); err != nil {
+						panic(err)
+					}
+				} else if srcInfo.Mode().IsRegular() {
+					if err := fcopy(match, filepath.Join(*dst, filepath.Base(match)), srcInfo); err != nil {
+						panic(err)
+					}
+				}
+			}
+		}
+	} else if *src != "" {
+		srcInfo, err := os.Lstat(*src)
+		if err != nil {
+			panic(err)
+		}
+		if srcInfo.IsDir() {
+			if err := copy.Copy(*src, *dst, copy.Options{
+				OnSymlink: func(p string) copy.SymlinkAction {
+					return copy.Skip
+				},
+			}); err != nil {
+				panic(err)
+			}
+		} else if srcInfo.Mode().IsRegular() {
+			finalDestination := *dst
+			if dstInfo, err := os.Lstat(*dst); err != nil {
+				if !os.IsNotExist(err) {
+					panic(err)
+				}
+			} else if dstInfo.IsDir() {
+				finalDestination = filepath.Join(*dst, filepath.Base(*src))
+			} else if dstInfo.Mode().IsRegular() {
+				fmt.Println("WARNING: over-writing existing file: ", *dst)
+				if err := os.Remove(*dst); err != nil {
+					panic(err)
+				}
+			} else {
+				panic(fmt.Errorf("not sure how to copy to this dst: %v", *dst))
+			}
+			if err := fcopy(*src, finalDestination, srcInfo); err != nil {
+				panic(err)
+			}
+		}
+	}
+}
+
+func fcopy(src, dest string, info os.FileInfo) (err error) {
+
+	if err := os.MkdirAll(filepath.Dir(dest), os.ModePerm); err != nil {
+		return err
+	}
+
+	f, err := os.Create(dest)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	if err = os.Chmod(f.Name(), info.Mode()); err != nil {
+		return err
+	}
+
+	s, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer s.Close()
+
+	_, err = io.Copy(f, s)
+	return err
+}

_make_support/copy/go.mod

@@ -0,0 +1,5 @@
+module github.com/qlik-oss/sense-installer/_make_support/copy
+
+go 1.13
+
+require github.com/otiai10/copy v1.1.1

_make_support/copy/go.sum

@@ -0,0 +1,8 @@
+github.com/otiai10/copy v1.1.1 h1:PH7IFlRQ6Fv9vYmuXbDRLdgTHoP1w483kPNUP2bskpo=
+github.com/otiai10/copy v1.1.1/go.mod h1:rrF5dJ5F0t/EWSYODDu4j9/vEeYHMkc8jt0zJChqQWw=
+github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE=
+github.com/otiai10/curr v1.0.0 h1:TJIWdbX0B+kpNagQrjgq8bCMrbhiuX73M2XwgtDMoOI=
+github.com/otiai10/curr v1.0.0/go.mod h1:LskTG5wDwr8Rs+nNQ+1LlxRjAtTZZjtJW4rMXl6j4vs=
+github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT91xUo=
+github.com/otiai10/mint v1.3.1 h1:BCmzIS3n71sGfHB5NMNDB3lHYPz8fWSkCAErHed//qc=
+github.com/otiai10/mint v1.3.1/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc=

_make_support/get_tmp_dir/do.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+)
+
+func main() {
+	if tmpDir, err := ioutil.TempDir("", ""); err != nil {
+		panic(err)
+	} else {
+		fmt.Print(tmpDir)
+	}
+}

_make_support/get_tmp_dir/go.mod

@@ -0,0 +1,3 @@
+module github.com/qlik-oss/sense-installer/_make_support/get_tmp_dir
+
+go 1.13

_make_support/mkdir_all/do.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"os"
+)
+
+func main() {
+	if err := os.MkdirAll(os.Args[1], os.ModePerm); err != nil {
+		panic(err)
+	}
+}

_make_support/mkdir_all/go.mod

@@ -0,0 +1,3 @@
+module github.com/qlik-oss/sense-installer/_make_support/mkdir_all
+
+go 1.13

_make_support/remove_all/do.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"os"
+)
+
+func main() {
+	if err := os.RemoveAll(os.Args[1]); err != nil {
+		panic(err)
+	}
+}

_make_support/remove_all/go.mod

@@ -0,0 +1,3 @@
+module github.com/qlik-oss/sense-installer/_make_support/remove_all
+
+go 1.13

cmd/qliksense/about.go

@@ -39,7 +39,7 @@ qliksense about --profile=test
     then get version information based on the default profile in the qliksense-k8s repo master
 `,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if gitRef, err := getAboutCommandGitRef(args); err != nil {
+			if gitRef, err := getSingleArg(args); err != nil {
 				return err
 			} else if vout, err := q.About(gitRef, opts.Profile); err != nil {
 				return err
@@ -56,7 +56,7 @@ qliksense about --profile=test
 	return c
 }
 
-func getAboutCommandGitRef(args []string) (string, error) {
+func getSingleArg(args []string) (string, error) {
 	if len(args) > 1 {
 		return "", errors.New("too many arguments, only 1 expected")
 	} else if len(args) == 1 {

cmd/qliksense/apply.go

@@ -1,7 +1,11 @@
 package main
 
 import (
-	"io"
+	"bytes"
+	"errors"
+	"fmt"
+
+	qapi "github.com/qlik-oss/sense-installer/pkg/api"
 
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 	"github.com/spf13/cobra"
@@ -10,15 +14,21 @@ import (
 func applyCmd(q *qliksense.Qliksense) *cobra.Command {
 	opts := &qliksense.InstallCommandOptions{}
 	filePath := ""
-	keepPatchFiles := false
+	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(reader io.Reader) error {
-				return q.ApplyCRFromReader(reader, opts, keepPatchFiles, true)
+			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)
+				}
 			})
 		},
 	}
@@ -30,8 +40,35 @@ func applyCmd(q *qliksense.Qliksense) *cobra.Command {
 	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(c.Name(), loadOrApplyCommandEulaPreRunHook)
+	eulaPreRunHooks.addValidator(fmt.Sprintf("%v %v", rootCommandName, c.Name()), loadOrApplyCommandEulaPreRunHook)
 
 	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
+	} else {
+		cr.SetEULA("yes")
+		if crBytesWithEula, err := qapi.K8sToYaml(cr); err != nil {
+			return nil, nil, err
+		} else {
+			return cr, crBytesWithEula, nil
+		}
+	}
+}

cmd/qliksense/context.go

@@ -139,15 +139,18 @@ func deleteContextConfigCmd(q *qliksense.Qliksense) *cobra.Command {
 	var (
 		cmd *cobra.Command
 	)
-
+	skipConfirmation := false
 	cmd = &cobra.Command{
 		Use:     "delete-context",
 		Short:   "deletes a specific context locally (not in-cluster)",
 		Example: `qliksense config delete-contexts <context_name>`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return q.DeleteContextConfig(args)
+			return q.DeleteContextConfig(args, skipConfirmation)
 		},
 	}
+	f := cmd.Flags()
+
+	f.BoolVar(&skipConfirmation, "yes", skipConfirmation, "skips confirmation")
 	return cmd
 }
 

cmd/qliksense/eula.go

@@ -48,13 +48,14 @@ var eulaPreRunHooks = eulaPreRunHooksT{
 }
 
 func commandAlwaysRequiresEulaAcceptance(commandName string) bool {
-	return commandName == "install" || commandName == "upgrade" || commandName == "apply"
+	return commandName == fmt.Sprintf("%v install", rootCommandName) ||
+		commandName == fmt.Sprintf("%v apply", rootCommandName)
 }
 
 func globalEulaPreRun(cmd *cobra.Command, q *qliksense.Qliksense) {
-	if isEulaEnforced(cmd.Name()) {
+	if isEulaEnforced(cmd.CommandPath()) {
 		if strings.TrimSpace(strings.ToLower(cmd.Flag("acceptEULA").Value.String())) != "yes" {
-			if eulaPreRunHook := eulaPreRunHooks.getValidator(cmd.Name()); eulaPreRunHook != nil {
+			if eulaPreRunHook := eulaPreRunHooks.getValidator(cmd.CommandPath()); eulaPreRunHook != nil {
 				if eulaAccepted, err := eulaPreRunHook(cmd, q); err != nil {
 					panic(err)
 				} else if !eulaAccepted {
@@ -70,7 +71,7 @@ func globalEulaPreRun(cmd *cobra.Command, q *qliksense.Qliksense) {
 }
 
 func globalEulaPostRun(cmd *cobra.Command, q *qliksense.Qliksense) {
-	if isEulaEnforced(cmd.Name()) {
+	if isEulaEnforced(cmd.CommandPath()) {
 		if err := q.SetEulaAccepted(); err != nil {
 			panic(err)
 		}

cmd/qliksense/install.go

@@ -1,13 +1,15 @@
 package main
 
 import (
+	"fmt"
+
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 	"github.com/spf13/cobra"
 )
 
 func installCmd(q *qliksense.Qliksense) *cobra.Command {
 	opts := &qliksense.InstallCommandOptions{}
-	keepPatchFiles := false
+	keepPatchFiles, pull, push := false, false, false
 	c := &cobra.Command{
 		Use:     "install",
 		Short:   "install a qliksense release",
@@ -18,6 +20,21 @@ func installCmd(q *qliksense.Qliksense) *cobra.Command {
 			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)
 		},
 	}
@@ -27,6 +44,19 @@ func installCmd(q *qliksense.Qliksense) *cobra.Command {
 	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)
 	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

@@ -2,7 +2,7 @@ package main
 
 import (
 	"bytes"
-	"io"
+	"fmt"
 	"io/ioutil"
 	"os"
 
@@ -20,8 +20,8 @@ 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(reader io.Reader) error {
-				return q.LoadCr(reader, overwriteExistingContext)
+			return runLoadOrApplyCommandE(cmd, func(buffer []byte) error {
+				return q.LoadCr(bytes.NewReader(buffer), overwriteExistingContext)
 			})
 		},
 	}
@@ -30,7 +30,7 @@ func loadCrFile(q *qliksense.Qliksense) *cobra.Command {
 	c.MarkFlagRequired("file")
 	f.BoolVarP(&overwriteExistingContext, "overwrite", "o", overwriteExistingContext, "Overwrite any existing contexts with the same name")
 
-	eulaPreRunHooks.addValidator(c.Name(), loadOrApplyCommandEulaPreRunHook)
+	eulaPreRunHooks.addValidator(fmt.Sprintf("%v %v", rootCommandName, c.Name()), loadOrApplyCommandEulaPreRunHook)
 	return c
 }
 
@@ -70,15 +70,19 @@ func loadOrApplyCommandEulaPreRunHook(cmd *cobra.Command, q *qliksense.Qliksense
 	}
 }
 
-func runLoadOrApplyCommandE(cmd *cobra.Command, callBack func(io.Reader) error) error {
+func runLoadOrApplyCommandE(cmd *cobra.Command, callBack func(buffer []byte) error) error {
 	if crBytes := eulaPreRunHooks.getPostValidationArtifact("CR"); crBytes != nil {
-		return callBack(bytes.NewBuffer(crBytes.([]byte)))
+		return callBack(crBytes.([]byte))
 	} else {
 		file, err := getCrFileFromFlag(cmd, "file")
 		if err != nil {
 			return err
 		}
 		defer file.Close()
-		return callBack(file)
+		if crBytes, err := ioutil.ReadAll(file); err != nil {
+			return err
+		} else {
+			return callBack(crBytes)
+		}
 	}
 }

cmd/qliksense/preflight.go

@@ -80,7 +80,9 @@ func pfK8sVersionCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 }
 
 func pfAllChecksCmd(q *qliksense.Qliksense) *cobra.Command {
-	var mongodbUrl string
+
+	preflightOpts := &preflight.PreflightMongoOptions{}
+
 	var preflightAllChecksCmd = &cobra.Command{
 		Use:     "all",
 		Short:   "perform all checks",
@@ -100,13 +102,19 @@ func pfAllChecksCmd(q *qliksense.Qliksense) *cobra.Command {
 			if namespace == "" {
 				namespace = "default"
 			}
-			qp.RunAllPreflightChecks(namespace, kubeConfigContents, mongodbUrl)
+			qp.RunAllPreflightChecks(kubeConfigContents, namespace, preflightOpts)
 			return nil
 
 		},
 	}
 	f := preflightAllChecksCmd.Flags()
-	f.StringVarP(&mongodbUrl, "mongodb-url", "", "", "mongodbUrl to try connecting to")
+	f.StringVarP(&preflightOpts.MongodbUrl, "mongodb-url", "", "", "mongodbUrl to try connecting to")
+	f.StringVarP(&preflightOpts.Username, "mongodb-username", "", "", "username to connect to mongodb")
+	f.StringVarP(&preflightOpts.Password, "mongodb-password", "", "", "password to connect to mongodb")
+	f.StringVarP(&preflightOpts.CaCertFile, "mongodb-ca-cert", "", "", "certificate to use for mongodb check")
+	f.StringVarP(&preflightOpts.ClientCertFile, "mongodb-client-cert", "", "", "client-certificate to use for mongodb check")
+	f.BoolVar(&preflightOpts.Tls, "mongodb-tls", false, "enable tls?")
+
 	return preflightAllChecksCmd
 }
 
@@ -316,7 +324,8 @@ func pfCreateAuthCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 }
 
 func pfMongoCheckCmd(q *qliksense.Qliksense) *cobra.Command {
-	var mongodbUrl string
+
+	preflightOpts := &preflight.PreflightMongoOptions{}
 	var preflightMongoCmd = &cobra.Command{
 		Use:     "mongo",
 		Short:   "preflight mongo OR preflight mongo --url=<url>",
@@ -336,7 +345,7 @@ func pfMongoCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 			if namespace == "" {
 				namespace = "default"
 			}
-			if err = qp.CheckMongo(kubeConfigContents, namespace, mongodbUrl); err != nil {
+			if err = qp.CheckMongo(kubeConfigContents, namespace, preflightOpts); err != nil {
 				fmt.Println(err)
 				fmt.Print("Preflight mongo check FAILED\n")
 				log.Fatal()
@@ -345,6 +354,11 @@ func pfMongoCheckCmd(q *qliksense.Qliksense) *cobra.Command {
 		},
 	}
 	f := preflightMongoCmd.Flags()
-	f.StringVarP(&mongodbUrl, "url", "", "", "mongodbUrl to try connecting to")
+	f.StringVarP(&preflightOpts.MongodbUrl, "url", "", "", "mongodbUrl to try connecting to")
+	f.StringVarP(&preflightOpts.Username, "username", "", "", "username to connect to mongodb")
+	f.StringVarP(&preflightOpts.Password, "password", "", "", "password to connect to mongodb")
+	f.StringVarP(&preflightOpts.CaCertFile, "ca-cert", "", "", "ca certificate to use for mongodb check")
+	f.StringVarP(&preflightOpts.ClientCertFile, "client-cert", "", "", "client-certificate to use for mongodb check")
+	f.BoolVar(&preflightOpts.Tls, "tls", false, "enable tls?")
 	return preflightMongoCmd
 }

cmd/qliksense/pull_push.go

@@ -16,7 +16,7 @@ func pullQliksenseImages(q *qliksense.Qliksense) *cobra.Command {
 		Short:   "Pull docker images for offline install",
 		Example: `qliksense pull`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			version, err := getAboutCommandGitRef(args)
+			version, err := getSingleArg(args)
 			if err != nil {
 				return err
 			}
@@ -34,11 +34,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 {
-			qConfig := qapi.NewQConfig(q.QliksenseHome)
-			if qcr, err := qConfig.GetCurrentCR(); err != nil {
+			if err := ensureImageRegistrySetInCR(q); err != nil {
 				return err
-			} else if registry := qcr.Spec.GetImageRegistry(); registry == "" {
-				return errors.New("no image registry in config")
 			} else {
 				return q.PushImagesForCurrentCR()
 			}
@@ -46,3 +43,13 @@ func pushQliksenseImages(q *qliksense.Qliksense) *cobra.Command {
 	}
 	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

@@ -27,6 +27,13 @@ const (
 	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"
 )
 
 func initAndExecute() error {
@@ -85,17 +92,20 @@ var versionCmd = &cobra.Command{
 }
 
 func commandUsesContext(commandName string) bool {
-	return commandName != "" && commandName != "qliksense" && commandName != "help" && commandName != "version"
+	return commandName != "" &&
+		commandName != rootCommandName &&
+		commandName != fmt.Sprintf("%v help", rootCommandName) &&
+		commandName != fmt.Sprintf("%v version", rootCommandName)
 }
 
 func getRootCmd(p *qliksense.Qliksense) *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "qliksense",
+		Use:   rootCommandName,
 		Short: "Qliksense cli tool",
 		Long:  `qliksense cli tool provides functionality to perform operations on qliksense-k8s, qliksense operator, and kubernetes cluster`,
 		Args:  cobra.ArbitraryArgs,
 		PersistentPreRun: func(cmd *cobra.Command, args []string) {
-			if commandUsesContext(cmd.Name()) {
+			if commandUsesContext(cmd.CommandPath()) {
 				globalEulaPreRun(cmd, p)
 				if err := p.SetUpQliksenseDefaultContext(); err != nil {
 					panic(err)
@@ -108,14 +118,14 @@ func getRootCmd(p *qliksense.Qliksense) *cobra.Command {
 			}
 		},
 		PersistentPostRun: func(cmd *cobra.Command, args []string) {
-			if commandUsesContext(cmd.Name()) {
+			if commandUsesContext(cmd.CommandPath()) {
 				globalEulaPostRun(cmd, p)
 			}
 		},
 	}
 	origHelpFunc := cmd.HelpFunc()
 	cmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
-		if !commandUsesContext(cmd.Name()) {
+		if !commandUsesContext(cmd.CommandPath()) {
 			cmd.Flags().MarkHidden("acceptEULA")
 		}
 		origHelpFunc(cmd, args)

cmd/qliksense/uninstall.go

@@ -6,6 +6,7 @@ import (
 )
 
 func uninstallCmd(q *qliksense.Qliksense) *cobra.Command {
+	skipConfirmation := false
 	c := &cobra.Command{
 		Use:     "uninstall",
 		Short:   "Uninstall the deployed qliksense.",
@@ -13,10 +14,15 @@ func uninstallCmd(q *qliksense.Qliksense) *cobra.Command {
 		Example: `qliksense uninstall <context-name>`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) > 0 {
-				return q.UninstallQK8s(args[0])
+				return q.UninstallQK8s(args[0], skipConfirmation)
 			}
-			return q.UninstallQK8s("")
+			return q.UninstallQK8s("", skipConfirmation)
 		},
 	}
+
+	f := c.Flags()
+
+	f.BoolVar(&skipConfirmation, "yes", skipConfirmation, "skips confirmation")
+
 	return c
 }

docs/command_reference.md

@@ -1,13 +1,47 @@
-# qliksense command reference
+# CLI reference
 
-## qliksense apply
+### qliksense preflight
 
-`qliksense apply` command takes input a cr file or input from pipe
+Preflight checks provide pre-installation cluster conformance testing and validation before we install qliksense on the cluster. We gather a suite of conformance tests that can be easily written and run on the target cluster to verify that cluster-specific requirements are met.
+
+We support the following tests at the moment as part of preflight checks, and the range of the suite will be expanded in future.
+
+Run the following command to view help about the commands supported by preflight at any moment:
+```
+qliksense preflight
+```
+
+#### Running all checks
+Run the following command to execute all preflight checks
+```
+qliksense preflight all --mongodb-url=<mongo-server url> --mongodb-ca-cert=<path to ca-cert file>
+```
+
+#### Running specific check
+Run the following command to execute a specific check
+```
+qliksense preflight dns
+```
+
+### qliksense load
+
+`qliksense load` command takes input from a file or from pipe
+
+- `qliksense load -f cr-file.yaml`
+- `cat cr-file.yaml | qliksense load -f -`
+
+This will load the Custom Resource (CR) into `${QLIKSENSE_HOME}` folder, create context structure and set the current context to that CR.
+
+This will also encrypt the secrets from CR while writing the CR into the disk.
+
+### qliksense apply
+
+`qliksense apply` command takes input from a file or from pipe
 
 - `qliksense apply -f cr-file.yaml`
 - `cat cr-file.yaml | qliksense apply -f -`
 
-the content of `cr-file.yaml` should be something similar
+The content of `cr-file.yaml` should be something like the following:
 
 ```yaml
 apiVersion: qlik.com/v1
@@ -27,33 +61,26 @@ spec:
       value: mongodb://qlik-test-mongodb:27017/qliksense?ssl=false
   profile: docker-desktop
   rotateKeys: "yes"
-  ```
+```
 
-This will do everything `qliksense load` does and install the qliksense into the cluster. 
+`qliksense apply` does everything `qliksense load` does but will install Qlik Sense into the cluster as well
 
-## qliksense load
+### qliksense about
 
-`qliksense load` command takes input a cr file or input from pipe.
+`qliksense about` command will display information about [qliksense-k8s](https://github.com/qlik-oss/qliksense-k8s) release.
 
-- `qliksense load -f cr-file.yaml`
-- `cat cr-file.yaml | qliksense load -f -`
+For example, running the following command will show information about default profile for `1.0.0` tag
 
-This will load the CR into `${QLIKSENSE_HOME}` folder, create context structure and set the current context to that CR. 
-This will also encrypt the secrets from CR while writing the CR into the disk.
+```
+qliksense about 1.0.0
+```
 
-## qliksense about
+Run the following command to view options for `about` command:
+```
+qliksense about --help
+```
 
-About action will display inside information regarding [qliksense-k8](https://github.com/qlik-oss/qliksense-k8s) release.
-
-it will support following flags
-
-- `qliksense about 1.0.0` display default profile for tag `1.0.0`.
-- `qliksense about 1.0.0 --profile=docker-desktop`
-- `qliksense about` 
-  - assuming current directory has `manifests/docker-desktop`
-  - or get version information from pull of `qliksense-k8s` `master`
-
-using other supported commands user might have built the CR into the location `~/.qliksense/myqliksense.yaml`
+Using other supported commands user might have built the CR into the location `~/.qliksense/myqliksense.yaml`
 
 ```yaml
 apiVersion: qlik.com/v1
@@ -62,7 +89,7 @@ metadata:
   name: myqliksense
 spec:
   profile: docker-desktop
-  manifestsRoot: /Usr/ddd/my-k8-repo/manifests
+  manifestsRoot: /Usr/xyz/my-k8-repo/manifests
   namespace: myqliksense
   storageClassName: efs
   configs:
@@ -77,31 +104,30 @@ spec:
       valueFromKey: messagingPassword
 ```
 
-In that case the command would be
+In this case, the result of `qliksense about` command would display information from:
 
-- `qliksense about`
-   - display from `/Usr/ddd/my-k8-repo/manifests/docker-desktop` location
-   - pull from `master` if directory invalid/empty
+- `/Usr/xyz/my-k8-repo/manifests/docker-desktop` location, or
+- Pull and show information from `master` branch if the directory is invalid or empty
 
 
-## qliksense config
+### qliksense config
 
-Config action will perform operations on configurations and contexts regarding the [qliksense-k8](https://github.com/qlik-oss/qliksense-k8s) release.
+`qliksense config` will perform operations on configurations and contexts regarding the [qliksense-k8](https://github.com/qlik-oss/qliksense-k8s) release.
 
-it will support following commands:
+It supports the following flags:
 
-- `qliksense config apply` - generate the patchs and apply manifests to k8s
-- `qliksense config list-contexts` - retrieves the contexts and lists them
-- `qliksense config set` - configure a key value pair into the current context
-- `qliksense config set-configs` - set configurations into the qliksense context as key-value pairs
-- `qliksense config set-context` - sets the context in which the Kubernetes cluster and resources live in
-- `qliksense config set-secrets <service_name>.<attribute>="<value>" --secret=false` - set secrets configurations into the qliksense context as key-value pairs and show encrypted value as part of CR
-- `qliksense config set-secrets <service_name>.<attribute>="<value>" --secret=true` - set secrets configurations into the qliksense context as key-value pairs and show a key reference to the created Kubernetes secret resource as part of the CR
+- `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
+- `qliksense config set-context` - sets the Kubernetes context where resources are located
+- `qliksense config set-secrets <service_name>.<attribute>="<value>" --secret=false` - set secrets configurations into qliksense context as key-value pairs and show encrypted value as part of CR
+- `qliksense config set-secrets <service_name>.<attribute>="<value>" --secret=true` - set secrets configurations into qliksense context as key-value pairs and show a key reference to the created Kubernetes secret resource as part of the CR
 - `qliksense config view` - view the qliksense operator CR
-- `qliksense config delete-context` - deletes a specific context locally (not in-cluster). Deletes context in spec of `config.yaml` and locally deletes entire folder of specified context (does not delete in-cluster secrets)
+- `qliksense config delete-context` - deletes a specific context locally (not in-cluster). Deletes context in spec of `config.yaml` and locally deletes entire folder of specified context (does not delete secrets from cluster)
 
 
-the global file that abstracts all the contexts is `config.yaml`, located at:  `~/.qliksense/config.yaml`:
+The global file which abstracts all contexts is `~/.qliksense/config.yaml`
 ```yaml
 apiVersion: config.qlik.com/v1
 kind: QliksenseConfig
@@ -110,10 +136,10 @@ metadata:
 spec:
   contexts:
   - name: qlik-default
-    crFile: /Users/fff/.qliksense/contexts/qlik-default/qlik-default.yaml
+    crFile: /Users/xyz/.qliksense/contexts/qlik-default/qlik-default.yaml
   - name: myqliksense
-    crFile: /Users/fff/.qliksense/contexts/myqliksense/myqliksense.yaml
+    crFile: /Users/xyz/.qliksense/contexts/myqliksense/myqliksense.yaml
   - name: hello
-    crFile: /Users/fff/.qliksense/contexts/hello/hello.yaml
+    crFile: /Users/xyz/.qliksense/contexts/hello/hello.yaml
   currentContext: hello
-```
+```

docs/concepts.md

@@ -1,4 +1,4 @@
-# How qliksense cli works
+# How CLI works
 
 At the initialization, `qliksense` cli creates few files in the director `~/.qliksene` and it contains following files:
 
@@ -48,14 +48,14 @@ qliksense config -h
 
 In this mode `qliksense` CLI downloads the specified version from [qliksense-k8s](https://github.com/qlik-oss/qliksense-k8s) and places it in `~/.qliksense/contexts/<context-name>/qlik-k8s` folder.
 
-The qliksense cli creates a CR for the QlikSense operator and all config operations are peformed to edit the CR.
+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
 
 - Install those manifests into the cluster 
-- Create a custom resoruce (CR) for the `qliksene operator`.
+- Create a custom resource (CR) for the `qliksene operator`.
 
-The operator makes the association to the installed resoruces so that when `qliksense uninstall` is performed the operator can delete all kubernetes resources related to QSEoK for the current context.
+The operator makes the association to the installed resources so that when `qliksense uninstall` is performed the operator can delete all kubernetes resources related to QSEoK for the current context.
 
 ## With a git repo
 
@@ -94,4 +94,3 @@ spec:
     image: qlik-docker-oss.bintray.io/qliksense-repo-watcher
 ....
 ```
-

docs/getting_started.md

@@ -5,7 +5,7 @@
 - Kubernetes cluster (Docker Desktop with enabled Kubernetes)
 - `kubectl` installed, configured and able to communicate with kubernetes cluster. _`qliksense` CLI uses `kubectl` under the hood to perform operations on cluster_
 
-## Installing Sense installer
+## Installing `qliksense` CLI
 
 Download the executable for your platform from [releases page](https://github.com/qlik-oss/sense-installer/releases) and rename it to `qliksense`
 

docs/index.md

@@ -1,22 +1,15 @@
 # Overview
 
-The Qlik Sense installer CLI (`qliksense`) provides an imperative interface to many of the configurations that need to be applied against the declarative structure described in [qliksense-k8s](https://github.com/qlik-oss/qliksense-k8s). This cli facilitates:
+The Qlik Sense on Kubernetes CLI (`qliksense`) provides an imperative interface to many of the configurations that need to be applied against the declarative structure described in [qliksense-k8s](https://github.com/qlik-oss/qliksense-k8s).
+
+The CLI facilitates:
 
 - Installation of QSEoK
 - Installation of qliksense operator to manage QSEoK
 - Air gapped installation of QSEoK
 
 !!! info ""
-    This is a technology preview that uses Qlik modified [kustomize](https://github.com/qlik-oss/kustomize) for kubernetes manifests on [qliksense-k8s](https://github.com/qlik-oss/qliksense-k8s) repository
+    This is a technology preview that uses Qlik modified [kustomize](https://github.com/qlik-oss/kustomize) for Kubernetes manifests on [qliksense-k8s](https://github.com/qlik-oss/qliksense-k8s) repository
 
 !!! info ""
     See QlikSense [edge releases on qliksense-k8s](https://github.com/qlik-oss/qliksense-k8s/releases) repository
-
-## Future Direction
-
-Operations:
-
-- Expand preflight checks
-- Backup/restore operations
-- Fully support airgap installation of QSEoK
-- Restore unwanted deletion of kubernetes resources

docs/preflight_checks.md

@@ -1,10 +1,11 @@
-##Preflight checks
+# Preflight checks
+
 Preflight checks provide pre-installation cluster conformance testing and validation before we install qliksense on the cluster. We gather a suite of conformance tests that can be easily written and run on the target cluster to verify that cluster-specific requirements are met.
-The suite consists of a set of `collectors` which run the specifications of every test and `analyzers` which analyze the results of every test run by the collector.
+
 We support the following tests at the moment as part of preflight checks, and the range of the suite will be expanded in future.
 
 Run the following command to view help about the commands supported by preflight at any moment:
-```console
+```shell
 $ qliksense preflight
 perform preflight checks on the cluster
 
@@ -26,7 +27,7 @@ Flags:
 ### DNS check
 Run the following command to perform preflight DNS check. We setup a kubernetes deployment and try to reach it as part of establishing DNS connectivity in this check. 
 The expected output should be similar to the one shown below.
-```console
+```shell
 $ qliksense preflight dns
 
 Preflight DNS check
@@ -49,7 +50,7 @@ Deleted deployment: dep-dns-preflight-check
 ### Kubernetes version check
 We check the version of the target kubernetes cluster and ensure that it falls in the valid range of kubernetes versions that are supported by qliksense. 
 The command to run this check and the expected similar output are as shown below:
-```console
+```shell
 $ qliksense preflight k8s-version
 
 Preflight kubernetes minimum version check
@@ -64,7 +65,7 @@ Completed Preflight kubernetes minimum version check
 
 ### Service check
 We use the commmand below to test if we are able to create a service in the cluster.
-```console
+```shell
 $ qliksense preflight service
 
 Preflight service check
@@ -80,7 +81,7 @@ Completed preflight service check
 
 ### Deployment check
 We use the commmand below to test if we are able to create a deployment in the cluster. After the test exexutes, we wait until the created deployment terminates before we exit the command. 
-```console
+```shell
 $ qliksense preflight deployment
 
 Preflight deployment check
@@ -95,7 +96,7 @@ Completed preflight deployment check
 
 ### Pod check
 We use the commmand below to test if we are able to create a pod in the cluster.
-```console
+```shell
 $ qliksense preflight pod
 
 Preflight pod check
@@ -197,6 +198,8 @@ We can check if we are able to connect to an instance of mongodb on the cluster
 ```shell
 qliksense preflight mongo --url=<url> OR
 qliksense preflight mongo
+qliksense preflight mongo --url=<mongo-server url> --ca-cert=<path to ca-cert file>
+
 
 Preflight mongo check
 ---------------------
@@ -204,7 +207,7 @@ Preflight mongodb check:
 Created pod: pf-mongo-pod
 stdout: MongoDB shell version v4.2.5
 connecting to: <url>/?compressors=disabled&gssapiServiceName=mongodb
-Implicit session: session { "id" : UUID("64f639d3-2c93-4894-80f6-ee14acaf56a5") }
+Implicit session: session { "id" : UUID("...") }
 MongoDB server version: 4.2.5
 bye
 stderr: 
@@ -217,9 +220,9 @@ Completed preflight mongodb check
 
 ### Running all checks
 Run the command shown below to execute all preflight checks.
-```console
+```shell
 $ qliksense preflight all --mongodb-url=<url> OR
-$ qliksense preflight all
+$ qliksense preflight all --mongodb-url=<mongo-server url> --mongodb-ca-cert=<path to ca-cert file> 
 
 Running all preflight checks
 

go.mod

@@ -60,6 +60,7 @@ require (
 	k8s.io/api v0.17.0
 	k8s.io/apimachinery v0.17.0
 	k8s.io/client-go v11.0.0+incompatible
+	k8s.io/kubectl v0.0.0-20191016120415-2ed914427d51
 	sigs.k8s.io/kustomize/api v0.3.2
 	sigs.k8s.io/yaml v1.1.0
 )

mkdocs.yml

@@ -1,4 +1,4 @@
-site_name: Qlik Sense installer
+site_name: Qlik Sense on Kubernetes CLI
 repo_url: 'https://github.com/qlik-oss/sense-installer'
 strict: true
 theme:
@@ -19,6 +19,5 @@ nav:
   - getting_started.md
   - command_reference.md
   - concepts.md
-  - preflight_checks.md
   - air_gap.md
   - Releases ⧉: https://github.com/qlik-oss/sense-installer/releases

pkg/api/context_apis.go

@@ -109,6 +109,7 @@ func ReadFromFile(content interface{}, sourceFile string) error {
 	if e != nil {
 		return e
 	}
+	defer file.Close()
 	return ReadFromStream(content, file)
 }
 

pkg/preflight/all_checks.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 )
 
-func (qp *QliksensePreflight) RunAllPreflightChecks(namespace string, kubeConfigContents []byte, mongodbUrl string) {
+func (qp *QliksensePreflight) RunAllPreflightChecks(kubeConfigContents []byte, namespace string, preflightOpts *PreflightMongoOptions) {
 
 	checkCount := 0
 	totalCount := 0
@@ -81,7 +81,7 @@ func (qp *QliksensePreflight) RunAllPreflightChecks(namespace string, kubeConfig
 	// Preflight mongo check
 	fmt.Printf("\nPreflight mongo check\n")
 	fmt.Println("---------------------")
-	if err := qp.CheckMongo(kubeConfigContents, namespace, mongodbUrl); err != nil {
+	if err := qp.CheckMongo(kubeConfigContents, namespace, preflightOpts); err != nil {
 		fmt.Printf("Preflight mongo check: FAILED\n")
 	} else {
 		checkCount++

pkg/preflight/deployability.go

@@ -72,7 +72,7 @@ func (qp *QliksensePreflight) checkPfPod(clientset *kubernetes.Clientset, namesp
 	if err != nil {
 		return err
 	}
-	pod, err := createPreflightTestPod(clientset, namespace, podName, imageName, commandToRun)
+	pod, err := createPreflightTestPod(clientset, namespace, podName, imageName, nil, commandToRun)
 	if err != nil {
 		err = fmt.Errorf("error: unable to create pod %s - %v\n", podName, err)
 		return err

pkg/preflight/dns_check.go

@@ -52,7 +52,7 @@ func (qp *QliksensePreflight) CheckDns(namespace string, kubeConfigContents []by
 	if err != nil {
 		return err
 	}
-	dnsPod, err := createPreflightTestPod(clientset, namespace, podName, netcatImageName, commandToRun)
+	dnsPod, err := createPreflightTestPod(clientset, namespace, podName, netcatImageName, nil, commandToRun)
 	if err != nil {
 		err = fmt.Errorf("error: unable to create pod : %s\n", podName)
 		return err

pkg/preflight/mongo_check.go

@@ -2,19 +2,23 @@ package preflight
 
 import (
 	"fmt"
+	"io/ioutil"
 	"strings"
 
+	"github.com/qlik-oss/sense-installer/pkg/api"
 	qapi "github.com/qlik-oss/sense-installer/pkg/api"
+	apiv1 "k8s.io/api/core/v1"
+	"k8s.io/client-go/kubernetes"
 )
 
 const (
 	mongo = "mongo"
 )
 
-func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace, mongodbUrl string) error {
+func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace string, preflightOpts *PreflightMongoOptions) error {
 	fmt.Printf("Preflight mongodb check: \n")
 
-	if mongodbUrl == "" {
+	if preflightOpts.MongodbUrl == "" {
 		// infer mongoDbUrl from currentCR
 		fmt.Println("MongoDbUri is empty, infer from CR")
 		qConfig := qapi.NewQConfig(qp.Q.QliksenseHome)
@@ -28,32 +32,90 @@ func (qp *QliksensePreflight) CheckMongo(kubeConfigContents []byte, namespace, m
 			return err
 		}
 		decryptedCR, err := qConfig.GetDecryptedCr(currentCR)
-		mongodbUrl = decryptedCR.Spec.GetFromSecrets("qliksense", "mongoDbUri")
+		if err != nil {
+			fmt.Printf("An error occurred while retrieving mongodbUrl from current CR: %v\n", err)
+			return err
+		}
+		preflightOpts.MongodbUrl = decryptedCR.Spec.GetFromSecrets("qliksense", "mongoDbUri")
 	}
 
-	fmt.Printf("mongodbUrl: %s\n", mongodbUrl)
-	if err := qp.mongoConnCheck(kubeConfigContents, namespace, mongodbUrl); err != nil {
+	fmt.Printf("mongodbUrl: %s\n", preflightOpts.MongodbUrl)
+	if err := qp.mongoConnCheck(kubeConfigContents, namespace, preflightOpts); err != nil {
 		return err
 	}
 	fmt.Println("Completed preflight mongodb check")
 	return nil
 }
 
-func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespace, mongodbUrl string) error {
+func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespace string, preflightOpts *PreflightMongoOptions) error {
+	var caCertSecretName, clientCertSecretName string
 	clientset, _, err := getK8SClientSet(kubeConfigContents, "")
 	if err != nil {
 		err = fmt.Errorf("error: unable to create a kubernetes client: %v\n", err)
 		fmt.Println(err)
 		return err
 	}
+	var secrets []string
+	if preflightOpts.CaCertFile != "" {
+		caCertSecretName = "preflight-mongo-test-cacert"
+		caCertSecret, err := createSecret(clientset, namespace, preflightOpts.CaCertFile, caCertSecretName)
+
+		if err != nil {
+			err = fmt.Errorf("error: unable to create a create ca cert kubernetes secret: %v\n", err)
+			fmt.Println(err)
+			return err
+		}
+
+		defer deleteK8sSecret(clientset, namespace, caCertSecret)
+		secrets = append(secrets, caCertSecretName)
+	}
+	if preflightOpts.ClientCertFile != "" {
+		clientCertSecretName = "preflight-mongo-test-clientcert"
+		clientCertSecret, err := createSecret(clientset, namespace, preflightOpts.ClientCertFile, clientCertSecretName)
+		if err != nil {
+			err = fmt.Errorf("error: unable to create a create client cert kubernetes secret: %v\n", err)
+			fmt.Println(err)
+			return err
+		}
+
+		defer deleteK8sSecret(clientset, namespace, clientCertSecret)
+		secrets = append(secrets, clientCertSecretName)
+	}
+
+	mongoCommand := strings.Builder{}
+	mongoCommand.WriteString(fmt.Sprintf("sleep 10;mongo %s", preflightOpts.MongodbUrl))
+	if preflightOpts.Username != "" {
+		mongoCommand.WriteString(fmt.Sprintf(" --username %s", preflightOpts.Username))
+		api.LogDebugMessage("Adding username: Mongo command: %s\n", mongoCommand.String())
+	}
+	if preflightOpts.Password != "" {
+		mongoCommand.WriteString(fmt.Sprintf(" --password %s", preflightOpts.Password))
+		api.LogDebugMessage("Adding username and password\n")
+	}
+	if preflightOpts.Tls || preflightOpts.CaCertFile != "" || preflightOpts.ClientCertFile != "" {
+		mongoCommand.WriteString(" --tls")
+		api.LogDebugMessage("Adding --tls: Mongo command: %s\n", mongoCommand.String())
+	}
+		mongoCommand.WriteString(fmt.Sprintf(" --tlsCAFile=/etc/ssl/%s/%[1]s", caCertSecretName))
+	if preflightOpts.CaCertFile != "" {
+		api.LogDebugMessage("Adding caCertFile:  Mongo command: %s\n", mongoCommand.String())
+	}
+	if preflightOpts.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()}
+	api.LogDebugMessage("Mongo commandToRun: %s\n", strings.Join(commandToRun, " "))
+
 	// create a pod
 	podName := "pf-mongo-pod"
-	commandToRun := []string{"sh", "-c", "sleep 10;mongo " + mongodbUrl}
 	imageName, err := qp.GetPreflightConfigObj().GetImageName(mongo, true)
 	if err != nil {
 		return err
 	}
-	mongoPod, err := createPreflightTestPod(clientset, namespace, podName, imageName, commandToRun)
+	mongoPod, err := createPreflightTestPod(clientset, namespace, podName, imageName, secrets, commandToRun)
 	if err != nil {
 		err = fmt.Errorf("error: unable to create pod : %v\n", err)
 		return err
@@ -85,3 +147,17 @@ func (qp *QliksensePreflight) mongoConnCheck(kubeConfigContents []byte, namespac
 	}
 	return nil
 }
+
+func createSecret(clientset *kubernetes.Clientset, namespace, certFile, certSecretName string) (*apiv1.Secret, error) {
+	certBytes, err := ioutil.ReadFile(certFile)
+	if err != nil {
+		return nil, err
+	}
+
+	certSecret, err := createPreflightTestSecret(clientset, namespace, certSecretName, certBytes)
+	if err != nil {
+		err = fmt.Errorf("error: unable to create secret with ca cert : %v\n", err)
+		return nil, err
+	}
+	return certSecret, nil
+}

pkg/preflight/preflight_utils.go

@@ -26,6 +26,15 @@ import (
 	"k8s.io/client-go/util/retry"
 )
 
+type PreflightMongoOptions struct {
+	MongodbUrl     string
+	Username       string
+	Password       string
+	CaCertFile     string
+	ClientCertFile string
+	Tls            bool
+}
+
 var gracePeriod int64 = 0
 
 type QliksensePreflight struct {
@@ -301,7 +310,7 @@ func deletePod(clientset *kubernetes.Clientset, namespace, name string) error {
 	return nil
 }
 
-func createPreflightTestPod(clientset *kubernetes.Clientset, namespace string, podName string, imageName string, commandToRun []string) (*apiv1.Pod, error) {
+func createPreflightTestPod(clientset *kubernetes.Clientset, namespace, podName, imageName string, secretNames []string, commandToRun []string) (*apiv1.Pod, error) {
 	// build the pod definition we want to deploy
 	pod := &apiv1.Pod{
 		ObjectMeta: v1.ObjectMeta{
@@ -323,6 +332,31 @@ func createPreflightTestPod(clientset *kubernetes.Clientset, namespace string, p
 			},
 		},
 	}
+	if len(secretNames) > 0 {
+		for _, secretName := range secretNames {
+			pod.Spec.Volumes = append(pod.Spec.Volumes, apiv1.Volume{
+				Name: secretName,
+				VolumeSource: apiv1.VolumeSource{
+					Secret: &apiv1.SecretVolumeSource{
+						SecretName: secretName,
+						Items: []apiv1.KeyToPath{
+							{
+								Key:  secretName,
+								Path: secretName,
+							},
+						},
+					},
+				},
+			})
+			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,
+					ReadOnly:  true,
+				})
+			}
+		}
+	}
 
 	// now create the pod in kubernetes cluster using the clientset
 	if err := retryOnError(func() (err error) {
@@ -561,7 +595,7 @@ func createPfRoleBinding(clientset *kubernetes.Clientset, namespace, roleBinding
 			Name:      roleBindingName,
 			Namespace: namespace,
 			Labels: map[string]string{
-				"app": "demo",
+				"app": "preflight",
 			},
 		},
 		Subjects: []v1beta1.Subject{
@@ -643,3 +677,46 @@ func deleteServiceAccount(clientset *kubernetes.Clientset, namespace string, ser
 	}
 	fmt.Printf("Deleted ServiceAccount: %s\n\n", serviceAccount.Name)
 }
+
+func createPreflightTestSecret(clientset *kubernetes.Clientset, namespace, secretName string, secretData []byte) (*apiv1.Secret, error) {
+	var secret *apiv1.Secret
+	var err error
+	// build the secret defination we want to create
+	secretSpec := &apiv1.Secret{
+		ObjectMeta: v1.ObjectMeta{
+			Name:      secretName,
+			Namespace: namespace,
+			Labels: map[string]string{
+				"app": "preflight",
+			},
+		},
+		Data: map[string][]byte{
+			secretName: secretData,
+		},
+	}
+
+	// now create the secret in kubernetes cluster using the clientset
+	if err = retryOnError(func() (err error) {
+		secret, err = clientset.CoreV1().Secrets(namespace).Create(secretSpec)
+		return err
+	}); err != nil {
+		fmt.Println(err)
+		return nil, err
+	}
+	fmt.Printf("Created Secret: %s\n", secret.Name)
+	return secret, nil
+}
+
+func deleteK8sSecret(clientset *kubernetes.Clientset, namespace string, k8sSecret *apiv1.Secret) {
+	secretClient := clientset.CoreV1().Secrets(namespace)
+
+	deletePolicy := v1.DeletePropagationForeground
+	deleteOptions := v1.DeleteOptions{
+		PropagationPolicy: &deletePolicy,
+	}
+	err := secretClient.Delete(k8sSecret.GetName(), &deleteOptions)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Printf("Deleted Secret: %s\n\n", k8sSecret.Name)
+}

pkg/preflight/role_check.go

@@ -72,7 +72,8 @@ func (qp *QliksensePreflight) checkCreateEntity(namespace, entityToTest string)
 	if len(resultYamlBytes) == 0 {
 		resultYamlBytes, err = qliksense.ExecuteKustomizeBuild(kusDir)
 		if err != nil {
-			fmt.Printf("Unable to retrieve manifests from executing kustomize: %v\n", err)
+			err := fmt.Errorf("Unable to retrieve manifests from executing kustomize from dir: %s", kusDir)
+			fmt.Println(err)
 			return err
 		}
 	}
@@ -80,7 +81,7 @@ 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")
+		err := fmt.Errorf("Unable to retrieve yamls to apply on cluster from dir: %s", kusDir)
 		fmt.Println(err)
 		return err
 	}

pkg/qliksense/about_test.go

@@ -2,13 +2,13 @@ package qliksense
 
 import (
 	"fmt"
+	qapi "github.com/qlik-oss/sense-installer/pkg/api"
 	"io/ioutil"
 	"os"
 	"path"
+	"path/filepath"
 	"reflect"
 	"testing"
-
-	qapi "github.com/qlik-oss/sense-installer/pkg/api"
 )
 
 func Test_About_getImageList(t *testing.T) {
@@ -230,15 +230,24 @@ spec:
 	}
 }
 
+func Test_foo(t *testing.T) {
+	configDir := "C:\\Users\\abulynko\\AppData\\Local\\Temp\\03994898/repo"
+	fmt.Printf("--AB: 1: %v\n", path.Dir(configDir))
+
+	sub := path.Dir(configDir)
+	fmt.Printf("--AB: 2: %v\n", path.Dir(sub))
+}
+
 func Test_About_getConfigDirectory(t *testing.T) {
 	verifyAsdBranch := func(configDir string) (ok bool, reason string) {
 		tmpDir := os.TempDir()
 
-		if (path.Clean(path.Dir(path.Dir(configDir))) != path.Clean(tmpDir)) || (path.Base(configDir) != "repo") {
+		configParentDir := filepath.Dir(configDir)
+		if (filepath.Clean(filepath.Dir(configParentDir)) != filepath.Clean(tmpDir)) || (filepath.Base(configDir) != "repo") {
 			return false, fmt.Sprintf("expected config directory path: %v to be under: %v and terminate with repo", configDir, tmpDir)
 		}
 
-		if info, err := os.Stat(path.Join(configDir, "asdczxc")); err != nil || !info.Mode().IsRegular() {
+		if info, err := os.Stat(filepath.Join(configDir, "asdczxc")); err != nil || !info.Mode().IsRegular() {
 			return false, fmt.Sprintf(`expected to find file: "asdczxc" under directory: %v`, configDir)
 		}
 		return true, ""
@@ -247,15 +256,16 @@ func Test_About_getConfigDirectory(t *testing.T) {
 	verifyMasterBranch := func(configDir string) (ok bool, reason string) {
 		tmpDir := os.TempDir()
 
-		if (path.Clean(path.Dir(path.Dir(configDir))) != path.Clean(tmpDir)) || (path.Base(configDir) != "repo") {
+		configParentDir := filepath.Dir(configDir)
+		if (filepath.Clean(filepath.Dir(configParentDir)) != filepath.Clean(tmpDir)) || (filepath.Base(configDir) != "repo") {
 			return false, fmt.Sprintf("expected config directory path: %v to be under: %v and terminate with repo", configDir, tmpDir)
 		}
 
-		if _, err := os.Stat(path.Join(configDir, "asdczxc")); err == nil || !os.IsNotExist(err) {
+		if _, err := os.Stat(filepath.Join(configDir, "asdczxc")); err == nil || !os.IsNotExist(err) {
 			return false, fmt.Sprintf(`expected to NOT find file: "asdczxc"" under directory: %v`, configDir)
 		}
 
-		if info, err := os.Stat(path.Join(configDir, "sad")); err != nil || !info.Mode().IsRegular() {
+		if info, err := os.Stat(filepath.Join(configDir, "sad")); err != nil || !info.Mode().IsRegular() {
 			return false, fmt.Sprintf(`expected to find file: "sad"" under directory: %v`, configDir)
 		}
 		return true, ""
@@ -305,7 +315,7 @@ func Test_About_getConfigDirectory(t *testing.T) {
 			cleanup: func(_ *Qliksense, configDir string) error {
 				if currentDirectory, err := os.Getwd(); err != nil {
 					return err
-				} else if err := os.RemoveAll(path.Join(currentDirectory, "manifests")); err != nil {
+				} else if err := os.RemoveAll(filepath.Join(currentDirectory, "manifests")); err != nil {
 					return err
 				}
 				return nil
@@ -320,7 +330,7 @@ func Test_About_getConfigDirectory(t *testing.T) {
 				}
 
 				profileEntered = "foo"
-				defaultProfilePath := path.Join(currentDirectory, "manifests", profileEntered)
+				defaultProfilePath := filepath.Join(currentDirectory, "manifests", profileEntered)
 				err = os.MkdirAll(defaultProfilePath, os.ModePerm)
 				if err != nil {
 					t.Fatalf("error making path: %v, err: %v\n", defaultProfilePath, err)
@@ -350,7 +360,7 @@ func Test_About_getConfigDirectory(t *testing.T) {
 			cleanup: func(_ *Qliksense, configDir string) error {
 				if currentDirectory, err := os.Getwd(); err != nil {
 					return err
-				} else if err := os.RemoveAll(path.Join(currentDirectory, "manifests")); err != nil {
+				} else if err := os.RemoveAll(filepath.Join(currentDirectory, "manifests")); err != nil {
 					return err
 				}
 				return nil
@@ -380,8 +390,8 @@ func Test_About_getConfigDirectory(t *testing.T) {
 			cleanup: func(_ *Qliksense, configDir string) error {
 				tmpDir := os.TempDir()
 
-				if path.Clean(path.Dir(path.Dir(configDir))) == path.Clean(tmpDir) && path.Base(configDir) == "repo" {
-					tmpTmpDir := path.Dir(configDir)
+				tmpTmpDir := filepath.Dir(configDir)
+				if filepath.Clean(filepath.Dir(tmpTmpDir)) == filepath.Clean(tmpDir) && filepath.Base(configDir) == "repo" {
 					if err := os.RemoveAll(tmpTmpDir); err != nil {
 						return err
 					}
@@ -413,8 +423,8 @@ func Test_About_getConfigDirectory(t *testing.T) {
 			cleanup: func(_ *Qliksense, configDir string) error {
 				tmpDir := os.TempDir()
 
-				if path.Clean(path.Dir(path.Dir(configDir))) == path.Clean(tmpDir) && path.Base(configDir) == "repo" {
-					tmpTmpDir := path.Dir(configDir)
+				tmpTmpDir := filepath.Dir(configDir)
+				if filepath.Clean(filepath.Dir(tmpTmpDir)) == filepath.Clean(tmpDir) && filepath.Base(configDir) == "repo" {
 					if err := os.RemoveAll(tmpTmpDir); err != nil {
 						return err
 					}
@@ -456,8 +466,9 @@ func Test_About_getConfigDirectory(t *testing.T) {
 			},
 			cleanup: func(q *Qliksense, configDir string) error {
 				tmpDir := os.TempDir()
-				if path.Clean(path.Dir(path.Dir(configDir))) == path.Clean(tmpDir) && path.Base(configDir) == "repo" {
-					tmpTmpDir := path.Dir(configDir)
+
+				tmpTmpDir := filepath.Dir(configDir)
+				if filepath.Clean(filepath.Dir(tmpTmpDir)) == filepath.Clean(tmpDir) && filepath.Base(configDir) == "repo" {
 					if err := os.RemoveAll(tmpTmpDir); err != nil {
 						return err
 					}
@@ -502,8 +513,9 @@ func Test_About_getConfigDirectory(t *testing.T) {
 			},
 			cleanup: func(q *Qliksense, configDir string) error {
 				tmpDir := os.TempDir()
-				if path.Clean(path.Dir(path.Dir(configDir))) == path.Clean(tmpDir) && path.Base(configDir) == "repo" {
-					tmpTmpDir := path.Dir(configDir)
+
+				tmpTmpDir := filepath.Dir(configDir)
+				if filepath.Clean(filepath.Dir(tmpTmpDir)) == filepath.Clean(tmpDir) && filepath.Base(configDir) == "repo" {
 					if err := os.RemoveAll(tmpTmpDir); err != nil {
 						return err
 					}

pkg/qliksense/apply.go

@@ -1,12 +1,13 @@
 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 bool) error {
+func (q *Qliksense) ApplyCRFromReader(r io.Reader, opts *InstallCommandOptions, keepPatchFiles, overwriteExistingContext, pull, push bool) error {
 	if err := q.LoadCr(r, overwriteExistingContext); err != nil {
 		return err
 	}
@@ -15,19 +16,33 @@ func (q *Qliksense) ApplyCRFromReader(r io.Reader, opts *InstallCommandOptions,
 	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 {
-			v := cr.GetLabelFromCr("version")
-			if !qConfig.IsRepoExistForCurrent(v) {
-				if err := q.FetchQK8s(v); err != nil {
+			if !qConfig.IsRepoExistForCurrent(version) {
+				if err := q.FetchQK8s(version); err != nil {
 					return err
 				}
 			}
 		}
 		return q.UpgradeQK8s(keepPatchFiles)
 	}
-	return q.InstallQK8s(cr.GetLabelFromCr("version"), opts, keepPatchFiles)
+	return q.InstallQK8s(version, opts, keepPatchFiles)
 }
 
 func IsQliksenseInstalled(crName string) bool {

pkg/qliksense/confirmation.go

@@ -0,0 +1,24 @@
+package qliksense
+
+import (
+	"fmt"
+	"log"
+	"strings"
+)
+
+func AskForConfirmation(s string) bool {
+	for {
+		fmt.Printf("%s [y/n]: ", s)
+		var response string
+		_, err := fmt.Scanln(&response)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if strings.EqualFold(response, "y") || strings.EqualFold(response, "yes") {
+			return true
+		} else if strings.EqualFold(response, "n") || strings.EqualFold(response, "no") {
+			return false
+		}
+	}
+}

pkg/qliksense/context_configs.go

@@ -403,7 +403,7 @@ func (q *Qliksense) ListContextConfigs() error {
 	return nil
 }
 
-func (q *Qliksense) DeleteContextConfig(args []string) error {
+func (q *Qliksense) DeleteContextConfig(args []string, flag bool) error {
 	if len(args) == 1 {
 		qliksenseConfigFile := filepath.Join(q.QliksenseHome, QliksenseConfigFile)
 		var qliksenseConfig api.QliksenseConfig
@@ -445,9 +445,17 @@ func (q *Qliksense) DeleteContextConfig(args []string) error {
 					}
 					newLength := len(qliksenseConfig.Spec.Contexts)
 					if currentLength != newLength {
-						api.WriteToFile(&qliksenseConfig, qliksenseConfigFile)
-						fmt.Fprintln(out, chalk.Yellow.Color(chalk.Underline.TextStyle("Warning: Active resources may still be running in-cluster")))
-						fmt.Fprintln(out, chalk.Green.Color("Successfully deleted context: "), chalk.Bold.TextStyle(args[0]))
+						ans := flag
+						if ans == false {
+							ans = AskForConfirmation("Are You Sure? ")
+						}
+						if ans == true {
+							api.WriteToFile(&qliksenseConfig, qliksenseConfigFile)
+							fmt.Fprintln(out, chalk.Yellow.Color(chalk.Underline.TextStyle("Warning: Active resources may still be running in-cluster")))
+							fmt.Fprintln(out, chalk.Green.Color("Successfully deleted context: "), chalk.Bold.TextStyle(args[0]))
+						} else {
+							return nil
+						}
 					} else {
 						err := fmt.Errorf(chalk.Red.Color("Context not found"))
 						return err

pkg/qliksense/context_configs_test.go

@@ -855,9 +855,10 @@ func TestDeleteContexts(t *testing.T) {
 			q := New(tt.args.qlikSenseHome)
 			var arg []string
 			arg = append(arg, tt.args.contextName)
-			if err := q.DeleteContextConfig(arg); (err != nil) != tt.wantErr {
+			if err := q.DeleteContextConfig(arg, true); (err != nil) != tt.wantErr {
 				t.Errorf("DeleteContext() error = %v, wantErr %v", err, tt.wantErr)
 			}
+
 		})
 	}
 

pkg/qliksense/docker.go

@@ -46,8 +46,8 @@ func (q *Qliksense) PullImages(version, profile string) error {
 	}
 	if profile != "" {
 		qcr.Spec.Profile = profile
-		if e := qConfig.WriteCR(qcr); e != nil {
-			return e
+		if err := qConfig.WriteCR(qcr); err != nil {
+			return err
 		}
 	}
 	return q.PullImagesForCurrentCR()
@@ -155,7 +155,6 @@ func pullImage(image, imagesDir string) error {
 	return nil
 }
 
-// TagAndPushImages ...
 func (q *Qliksense) PushImagesForCurrentCR() error {
 	qConfig := qapi.NewQConfig(q.QliksenseHome)
 	qcr, err := qConfig.GetCurrentCR()

pkg/qliksense/install.go

@@ -3,6 +3,8 @@ package qliksense
 import (
 	"errors"
 	"fmt"
+	"io/ioutil"
+	"os"
 	"path"
 	"path/filepath"
 
@@ -146,10 +148,15 @@ func installOrRemoveImagePullSecret(qConfig *qapi.QliksenseConfig) error {
 }
 
 func kustomizeForImageRegistry(resources, dockerConfigJsonSecretName, name, newName string) (string, error) {
-	fSys := filesys.MakeFsInMemory()
-	if err := fSys.WriteFile("/resources.yaml", []byte(resources)); err != nil {
+	dir, err := ioutil.TempDir("", "")
+	if err != nil {
 		return "", err
-	} else if err := fSys.WriteFile("/addImagePullSecrets.yaml", []byte(fmt.Sprintf(`
+	}
+	defer os.RemoveAll(dir)
+
+	if err := ioutil.WriteFile(filepath.Join(dir, "resources.yaml"), []byte(resources), os.ModePerm); err != nil {
+		return "", err
+	} else if err := ioutil.WriteFile(filepath.Join(dir, "addImagePullSecrets.yaml"), []byte(fmt.Sprintf(`
 apiVersion: builtin
 kind: PatchTransformer
 metadata:
@@ -158,9 +165,9 @@ patch: '[{"op": "add", "path": "/spec/template/spec/imagePullSecrets", "value":
 target:
   name: .*-operator
   kind: Deployment
-`, dockerConfigJsonSecretName))); err != nil {
+`, dockerConfigJsonSecretName)), os.ModePerm); err != nil {
 		return "", err
-	} else if err := fSys.WriteFile("/kustomization.yaml", []byte(fmt.Sprintf(`
+	} else if err := ioutil.WriteFile(filepath.Join(dir, "kustomization.yaml"), []byte(fmt.Sprintf(`
 resources:
 - resources.yaml
 transformers:
@@ -168,9 +175,9 @@ transformers:
 images:
 - name: %s
   newName: %s
-`, name, newName))); err != nil {
+`, name, newName)), os.ModePerm); err != nil {
 		return "", err
-	} else if out, err := executeKustomizeBuildForFileSystem("/", fSys); err != nil {
+	} else if out, err := executeKustomizeBuildForFileSystem(dir, filesys.MakeFsOnDisk()); err != nil {
 		return "", err
 	} else {
 		return string(out), nil

pkg/qliksense/install_test.go

@@ -130,7 +130,6 @@ spec:
 	}
 
 	originalOperatorString := q.GetOperatorControllerString()
-
 	processedOperatorString, err := q.getProcessedOperatorControllerString(qcr)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)

pkg/qliksense/kuz_test.go

@@ -68,7 +68,7 @@ func Test_executeKustomizeBuild_onQlikConfig_regenerateKeys(t *testing.T) {
 	configPath := path.Join(tmpDir, "config")
 	if repo, err := kapis_git.CloneRepository(configPath, defaultConfigRepoGitUrl, nil); err != nil {
 		t.Fatalf("unexpected error: %v\n", err)
-	} else if err := kapis_git.Checkout(repo, "v1.21.23-edge", "", nil); err != nil {
+	} else if err := kapis_git.Checkout(repo, "e38df644e759abf0b5941c1511d1a2cd5e3c42fa", "", nil); err != nil {
 		t.Fatalf("unexpected error: %v\n", err)
 	}
 

pkg/qliksense/uninstall.go

@@ -6,16 +6,24 @@ import (
 	qapi "github.com/qlik-oss/sense-installer/pkg/api"
 )
 
-func (q *Qliksense) UninstallQK8s(contextName string) error {
-	qConfig := qapi.NewQConfig(q.QliksenseHome)
-	if contextName == "" {
-		contextName = qConfig.Spec.CurrentContext
-	} else if !qConfig.IsContextExist(contextName) {
-		return errors.New("context name [ " + contextName + " ] not found")
+func (q *Qliksense) UninstallQK8s(contextName string, skipConfirmation bool) error {
+	ans := skipConfirmation
+
+	if ans == false {
+		ans = AskForConfirmation("Are You Sure? ")
 	}
-	str, err := q.getCRString(contextName)
-	if err != nil {
-		return err
+	if ans == true {
+		qConfig := qapi.NewQConfig(q.QliksenseHome)
+		if contextName == "" {
+			contextName = qConfig.Spec.CurrentContext
+		} else if !qConfig.IsContextExist(contextName) {
+			return errors.New("context name [ " + contextName + " ] not found")
+		}
+		str, err := q.getCRString(contextName)
+		if err != nil {
+			return err
+		}
+		return qapi.KubectlDelete(str, "")
 	}
-	return qapi.KubectlDelete(str, "")
+	return nil
 }