Merge branch 'make-relative-path' into manifest-root-relative-path

Signed-off-by: Foysal Iqbal <mqb@qlik.com>

.github/workflows/mkdocs.yml

@@ -4,8 +4,8 @@ on:
     branches:
       - master
     paths:
-      - docs/
-      - mkdocs.yml
+      - 'docs/**'
+      - 'mkdocs.yml'
 
 jobs:
   build:

Makefile

@@ -46,11 +46,11 @@ build: clean generate
 .PHONY: test
 test: clean generate
 ifeq ($(shell ${WHICH} docker-registry 2>${DEVNUL}),)
-	$(eval TMP := $(shell mktemp -d))
-	git clone https://github.com/docker/distribution.git $(TMP)/docker-distribution
-	cd $(TMP)/docker-distribution; git checkout -b v2.7.1; make
-	cp $(TMP)/docker-distribution/bin/registry pkg/qliksense/docker-registry
-	-rm -rf $(TMP)/docker-distribution
+	$(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)
 endif
 	go test -short -count=1 -tags "$(BUILDTAGS)" -v ./...
 	$(MAKE) clean
@@ -70,7 +70,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 $(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
@@ -91,12 +91,16 @@ clean-packr: packr2
 	cd pkg/qliksense && packr2 clean
 
 get-crds:
-	$(eval TMP := $(shell mktemp -d))
-	git clone https://github.com/qlik-oss/qliksense-operator.git -b master $(TMP)/operator
+ifeq ($(QLIKSENSE_OPERATOR_DIR),)
+	$(eval TMP-operator := $(shell mktemp -d))
+	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)
+else
 	mkdir -p pkg/qliksense/crds/cr
 	mkdir -p pkg/qliksense/crds/crd
 	mkdir -p pkg/qliksense/crds/crd-deploy
-	cp $(TMP)/operator/deploy/*.yaml pkg/qliksense/crds/crd-deploy
-	cp $(TMP)/operator/deploy/crds/*_crd.yaml pkg/qliksense/crds/crd
-	cp $(TMP)/operator/deploy/crds/*_cr.yaml pkg/qliksense/crds/cr
-	-rm -rf $(TMP)/operator
+	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
+endif

cmd/qliksense/apply.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"os"
+
+	"github.com/pkg/errors"
+	"github.com/qlik-oss/sense-installer/pkg/qliksense"
+	"github.com/spf13/cobra"
+)
+
+func applyCmd(q *qliksense.Qliksense) *cobra.Command {
+
+	filePath := ""
+	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 {
+			if filePath == "-" {
+				if !isInputFromPipe() {
+					return errors.New("No input pipe present")
+				}
+				return q.ApplyCRFromReader(os.Stdin)
+			}
+			file, e := os.Open(filePath)
+			if e != nil {
+				return errors.Wrapf(e,
+					"unable to read the file %s", filePath)
+			}
+			return q.ApplyCRFromReader(file)
+		},
+	}
+
+	f := c.Flags()
+	f.StringVarP(&filePath, "file", "f", "", "Install from a CR file")
+	c.MarkFlagRequired("file")
+	return c
+}

cmd/qliksense/eula.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+
+	qapi "github.com/qlik-oss/sense-installer/pkg/api"
+	"github.com/qlik-oss/sense-installer/pkg/qliksense"
+)
+
+var eulaEnforced = false
+var eulaText = "EULA text goes here..."
+var eulaPrompt = "Do you accept our EULA? (y/n): "
+var eulaErrorInstruction = "You must enter y/yes to continue"
+
+func isEulaEnforced() bool {
+	return eulaEnforced
+}
+
+func enforceEula(q *qliksense.Qliksense) {
+	if isEulaEnforced() {
+		if qConfig, err := qapi.NewQConfigE(q.QliksenseHome); err != nil {
+			doEnforceEula()
+		} else if qcr, err := qConfig.GetCurrentCR(); err != nil || !qcr.IsEULA() {
+			doEnforceEula()
+		}
+	}
+}
+
+func doEnforceEula() {
+	fmt.Println(eulaText)
+	fmt.Print(eulaPrompt)
+	scanner := bufio.NewScanner(os.Stdin)
+	scanSuccess := scanner.Scan()
+	if !scanSuccess {
+		fmt.Println(eulaErrorInstruction)
+		os.Exit(1)
+	}
+	line := scanner.Text()
+	answer := strings.ToLower(strings.TrimSpace(line))
+	if answer != "y" && answer != "yes" {
+		fmt.Println(eulaErrorInstruction)
+		os.Exit(1)
+	}
+}

cmd/qliksense/load.go

@@ -16,6 +16,9 @@ func loadCrFile(q *qliksense.Qliksense) *cobra.Command {
 		Long:  `load a CR a file and create necessary structure for future use`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if filePath == "-" {
+				if !isInputFromPipe() {
+					return errors.New("No input pipe present")
+				}
 				return q.LoadCr(os.Stdin)
 			}
 			file, e := os.Open(filePath)

cmd/qliksense/root.go

@@ -42,7 +42,6 @@ func initAndExecute() error {
 	api.LogDebugMessage("QliksenseHomeDir: %s", qlikSenseHome)
 
 	qliksenseClient := qliksense.New(qlikSenseHome)
-	qliksenseClient.SetUpQliksenseDefaultContext()
 	cmd := rootCmd(qliksenseClient)
 	if err := cmd.Execute(); err != nil {
 		//levenstein checks (auto-suggestions)
@@ -85,16 +84,37 @@ var versionCmd = &cobra.Command{
 	},
 }
 
-func rootCmd(p *qliksense.Qliksense) *cobra.Command {
-	var (
-		cmd *cobra.Command
-	)
+func commandUsesContext(command string) bool {
+	return command != "" && command != "help" && command != "version"
+}
 
-	cmd = &cobra.Command{
+func globalPreRun(cmd *cobra.Command, p *qliksense.Qliksense) {
+	if command := cmd.CalledAs(); commandUsesContext(command) {
+		if isEulaEnforced() {
+			enforceEula(p)
+		}
+
+		if err := p.SetUpQliksenseDefaultContext(); err != nil {
+			panic(err)
+		}
+
+		if isEulaEnforced() {
+			if err := p.SetEulaAccepted(); err != nil {
+				panic(err)
+			}
+		}
+	}
+}
+
+func rootCmd(p *qliksense.Qliksense) *cobra.Command {
+	cmd := &cobra.Command{
 		Use:   "qliksense",
 		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) {
+			globalPreRun(cmd, p)
+		},
 	}
 
 	cmd.Flags().SetInterspersed(false)
@@ -173,6 +193,7 @@ func rootCmd(p *qliksense.Qliksense) *cobra.Command {
 
 	cmd.AddCommand(preflightCmd)
 	cmd.AddCommand(loadCrFile(p))
+	cmd.AddCommand((applyCmd(p)))
 	return cmd
 }
 

cmd/qliksense/uninstall.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	qapi "github.com/qlik-oss/sense-installer/pkg/api"
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 	"github.com/spf13/cobra"
 )
@@ -9,7 +8,7 @@ import (
 func uninstallCmd(q *qliksense.Qliksense) *cobra.Command {
 	c := &cobra.Command{
 		Use:     "uninstall",
-		Short:   "Uninstall the deployed qliksense with release name [ " + qapi.NewQConfig(q.QliksenseHome).Spec.CurrentContext + " ]",
+		Short:   "Uninstall the deployed qliksense.",
 		Long:    `Uninstall the deployed qliksense. By default uninstall the current context`,
 		Example: `qliksense uninstall <context-name>`,
 		RunE: func(cmd *cobra.Command, args []string) error {

docs/command_reference.md

@@ -0,0 +1,41 @@
+# qliksense command reference
+
+## qliksense apply
+
+`qliksense apply` command takes input a cr file or input 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
+
+```yaml
+apiVersion: qlik.com/v1
+kind: Qliksense
+metadata:
+  name: qlik-test
+  labels:
+    version: v0.0.2
+spec:
+  configs:
+    qliksense:
+    - name: acceptEULA
+      value: "yes"
+  secrets:
+    qliksense:
+    - name: mongoDbUri
+      value: mongodb://qlik-test-mongodb:27017/qliksense?ssl=false
+  profile: docker-desktop
+  rotateKeys: "yes"
+  ```
+
+after doing one of the above commands, cli will set the current context to the cr name and install the qliksense into the cluster. so make sure you dont have a context (cr name = context name) with the same name already. It will though error if it same context name already exist. It will encrypt the secrets from CR while writing CR into the disk.
+
+## qliksense load
+
+`qliksense load` command takes input a cr file or input from pipe.
+
+- `qliksense load -f cr-file.yaml`
+- `cat cr-file.yaml | qliksense load -f -`
+
+It will load the cr into `~/.qliksense` folder and create context strcture with for the CR and set the current context with the cr name. In case of multiple documents in a single stream/file it will set the current context to the last one. It will encrypt the secrets from CR while writing the CR into the disk.

docs/concepts.md

@@ -76,21 +76,55 @@ When you perform `qliksense install` or `qliksene config apply`, qliksense opera
 - Push generated patches into a new branch in the provided git repo. _Gives you ability to merge patches into your master branch_
 - Create a CronJob to monitor master branch. Any changes pushed to master branch will be applied into the cluster. _This is a light weight `git-ops` model_
 
-## Enable GitOps
+## GitOps
 
-to enable gitops the following section should be in the CR
+To enable gitops, the following section should be in the CR
 
 ```yaml
 ....
 spec:
   git:
-    repository: https://github.com/ffoysal/qliksense-k8s
-    accessToken: git-token
-    userName: git-username
+    repository: https://github.com/<OWNER>/<REPO>
+    accessToken: "<git-token>"
+    userName: "<git-username>"
   gitOps:
     enabled: "yes"
     schedule: "*/5 * * * *"
-    watchBranch: pr-branch-24868a33
+    watchBranch: <myBranch>
     image: qlik-docker-oss.bintray.io/qliksense-repo-watcher
 ....
 ```
+
+##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.
+
+### DNS check
+Run the following command to view help about the commands supported by preflight at any moment:
+```console
+qliksense preflight
+perform preflight checks on the cluster
+
+Usage:
+  qliksense preflight [command]
+
+Examples:
+qliksense preflight <preflight_check_to_run>
+
+Usage:
+qliksense preflight dns
+
+Available Commands:
+  dns         perform preflight dns check
+```
+
+Run the following command to perform preflight DNS check. The expected output is also shown below.
+```console
+qliksense preflight dns
+  Running Preflight checks ⠧
+--- PASS DNS check
+      --- DNS check passed
+--- PASS   cluster-preflight-checks
+PASS
+```

mkdocs.yml

@@ -17,6 +17,7 @@ markdown_extensions:
 nav:
   - Overview: index.md
   - getting_started.md
+  - command_reference.md
   - concepts.md
   - air_gap.md
   - Releases ⧉: https://github.com/qlik-oss/sense-installer/releases

pkg/api/apis.go

@@ -27,46 +27,55 @@ const (
 
 // NewQConfig create QliksenseConfig object from file ~/.qliksense/config.yaml
 func NewQConfig(qsHome string) *QliksenseConfig {
+	qc, err := NewQConfigE(qsHome)
+	if err != nil {
+		fmt.Println("yaml unmarshalling error ", err)
+		os.Exit(1)
+	}
+	return qc
+}
+
+func NewQConfigE(qsHome string) (*QliksenseConfig, error) {
 	configFile := filepath.Join(qsHome, "config.yaml")
 	qc := &QliksenseConfig{}
 
 	err := ReadFromFile(qc, configFile)
 	if err != nil {
-		fmt.Println("yaml unmarshalling error ", err)
-		os.Exit(1)
+		return nil, err
 	}
 	qc.QliksenseHomePath = qsHome
-	return qc
+	return qc, nil
+}
+func NewQConfigEmpty(qsHome string) *QliksenseConfig {
+	return &QliksenseConfig{
+		QliksenseHomePath: qsHome,
+	}
 }
 
 // GetCR create a QliksenseCR object for a particular context
 // from file ~/.qliksense/contexts/<contx-name>/<contx-name>.yaml
 func (qc *QliksenseConfig) GetCR(contextName string) (*QliksenseCR, error) {
-	crFilePath := qc.getCRFilePath(contextName)
+	crFilePath := qc.GetCRFilePath(contextName)
 	if crFilePath == "" {
 		return nil, errors.New("context name " + contextName + " not found")
 	}
 	return GetCRObject(crFilePath)
 }
 
-func getUnencryptedCR() {
-
-}
-
 // GetCurrentCR create a QliksenseCR object for current context
 func (qc *QliksenseConfig) GetCurrentCR() (*QliksenseCR, error) {
 	return qc.GetCR(qc.Spec.CurrentContext)
 }
 
 // SetCrLocation sets the CR location for a context. Helpful during test
-func (qc *QliksenseConfig) SetCrLocation(contextName, filepath string) (*QliksenseConfig, error) {
+func (qc *QliksenseConfig) SetCrLocation(contextName, filePath string) (*QliksenseConfig, error) {
 	tempQc := &QliksenseConfig{}
 	copier.Copy(tempQc, qc)
 	found := false
 	tempQc.Spec.Contexts = []Context{}
 	for _, c := range qc.Spec.Contexts {
 		if c.Name == contextName {
-			c.CrFile = filepath
+			c.CrFile = filePath
 			found = true
 		}
 		tempQc.Spec.Contexts = append(tempQc.Spec.Contexts, []Context{c}...)
@@ -103,11 +112,11 @@ func CreateCRObjectFromString(crContent string) (*QliksenseCR, error) {
 	return cr, nil
 }
 
-func (qc *QliksenseConfig) getCRFilePath(contextName string) string {
+func (qc *QliksenseConfig) GetCRFilePath(contextName string) string {
 	crFilePath := ""
 	for _, ctx := range qc.Spec.Contexts {
 		if ctx.Name == contextName {
-			crFilePath = ctx.CrFile
+			crFilePath = filepath.Join(qc.QliksenseHomePath, ctx.CrFile)
 			break
 		}
 	}
@@ -131,22 +140,65 @@ func (qc *QliksenseConfig) BuildRepoPath(version string) string {
 	return qc.BuildRepoPathForContext(qc.Spec.CurrentContext, version)
 }
 
+func (qc *QliksenseConfig) BuildRelativeRepoPath(version string) string {
+	return qc.BuildRelativeRepoPathForContext(qc.Spec.CurrentContext, version)
+}
 func (qc *QliksenseConfig) BuildRepoPathForContext(contextName, version string) string {
 	return filepath.Join(qc.QliksenseHomePath, qliksenseContextsDirName, contextName, "qlik-k8s", version)
 }
 
+//BuildRelativeRepoPathForContext to build relative from qliksense home, so that can be written into cr file
+// and later easy to export to different computer
+func (qc *QliksenseConfig) BuildRelativeRepoPathForContext(contextName, version string) string {
+	return filepath.Join(qliksenseContextsDirName, contextName, "qlik-k8s", version)
+}
 func (qc *QliksenseConfig) BuildCurrentManifestsRoot(version string) string {
 	return qc.BuildRepoPath(version)
 }
 
+func (qc *QliksenseConfig) BuildCurrentRelativeManifestsRoot(version string) string {
+	return qc.BuildRelativeRepoPath(version)
+}
 func (qc *QliksenseConfig) WriteCR(cr *QliksenseCR, contextName string) error {
-	crf := qc.getCRFilePath(contextName)
+	crf := qc.GetCRFilePath(contextName)
 	if crf == "" {
 		return errors.New("context name " + contextName + " not found")
 	}
 	return WriteToFile(cr, crf)
 }
 
+//CreateOrWriteCrAndContext create necessary folder structure, update config.yaml and context yaml files
+func (qc *QliksenseConfig) CreateOrWriteCrAndContext(cr *QliksenseCR) error {
+	if qc.QliksenseHomePath == "" {
+		return errors.New("qliksense home is not set")
+	}
+	crf := qc.GetCRFilePath(cr.GetName())
+	if crf == "" {
+		// create direcotry structure for context
+		cDir := filepath.Join(qc.QliksenseHomePath, "contexts", cr.GetName())
+		if err := os.MkdirAll(cDir, os.ModePerm); err != nil {
+			return err
+		}
+		crf = filepath.Join(cDir, cr.GetName()+".yaml")
+		ctx := Context{
+			Name:   cr.GetName(),
+			CrFile: filepath.Join("contexts", cr.GetName(), cr.GetName()+".yaml"),
+		}
+		qc.AddToContexts(ctx)
+
+		if err := WriteToFile(qc, filepath.Join(qc.QliksenseHomePath, "config.yaml")); err != nil {
+			return err
+		}
+	}
+	return WriteToFile(cr, crf)
+}
+
+func (qc *QliksenseConfig) AddToContexts(ctx Context) error {
+	//TODO: additional duplicate check may be added latter
+	qc.Spec.Contexts = append(qc.Spec.Contexts, ctx)
+
+	return nil
+}
 func (qc *QliksenseConfig) WriteCurrentContextCR(cr *QliksenseCR) error {
 	return qc.WriteCR(cr, qc.Spec.CurrentContext)
 }
@@ -237,6 +289,15 @@ func (qc *QliksenseConfig) getDockerConfigJsonSecret(name string) (*DockerConfig
 }
 
 func (qc *QliksenseConfig) getCurrentContextEncryptionKeyPairLocation() (string, error) {
+
+	if qcr, err := qc.GetCurrentCR(); err != nil {
+		return "", err
+	} else {
+		return qc.getContextEncryptionKeyPairLocation(qcr.GetName())
+	}
+}
+
+func (qc *QliksenseConfig) getContextEncryptionKeyPairLocation(contextName string) (string, error) {
 	// Check env var: QLIKSENSE_KEY_LOCATION to determine location to store keypair
 	var secretKeyPairLocation string
 	if os.Getenv("QLIKSENSE_KEY_LOCATION") != "" {
@@ -245,13 +306,9 @@ func (qc *QliksenseConfig) getCurrentContextEncryptionKeyPairLocation() (string,
 	} else {
 		// QLIKSENSE_KEY_LOCATION has not been set, hence storing key pair in default location:
 		// /.qliksense/secrets/contexts/<current-context>/secrets/
-		if qcr, err := qc.GetCurrentCR(); err != nil {
-			return "", err
-		} else {
-			secretKeyPairLocation = filepath.Join(qc.QliksenseHomePath, qliksenseSecretsDirName, qliksenseContextsDirName, qcr.GetObjectMeta().GetName(), qliksenseSecretsDirName)
-		}
+		secretKeyPairLocation = filepath.Join(qc.QliksenseHomePath, qliksenseSecretsDirName, qliksenseContextsDirName, contextName, qliksenseSecretsDirName)
+
 	}
-	LogDebugMessage("SecretKeyLocation to store key pair: %s", secretKeyPairLocation)
 	return secretKeyPairLocation, nil
 }
 
@@ -268,7 +325,15 @@ func (qc *QliksenseConfig) GetCurrentContextEjsonKeyDir() (string, error) {
 }
 
 func (qc *QliksenseConfig) GetCurrentContextEncryptionKeyPair() (*rsa.PublicKey, *rsa.PrivateKey, error) {
-	secretKeyPairLocation, err := qc.getCurrentContextEncryptionKeyPairLocation()
+	if qcr, err := qc.GetCurrentCR(); err != nil {
+		return nil, nil, err
+	} else {
+		return qc.GetContextEncryptionKeyPair(qcr.GetName())
+	}
+}
+
+func (qc *QliksenseConfig) GetContextEncryptionKeyPair(contextName string) (*rsa.PublicKey, *rsa.PrivateKey, error) {
+	secretKeyPairLocation, err := qc.getContextEncryptionKeyPairLocation(contextName)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -357,6 +422,10 @@ func (cr *QliksenseCR) IsEULA() bool {
 	return false
 }
 
+func (cr *QliksenseCR) SetEULA(value string) {
+	cr.Spec.AddToConfigs("qliksense", "acceptEULA", value)
+}
+
 // GetDecryptedCr it decrypts all the encrypted value and return a new CR
 func (qc *QliksenseConfig) GetDecryptedCr(cr *QliksenseCR) (*QliksenseCR, error) {
 	newCr := &QliksenseCR{}
@@ -401,12 +470,18 @@ func (qc *QliksenseConfig) CreateContextDirs(contextName string) {
 	os.MkdirAll(contexPath, os.ModePerm)
 }
 
-func (qc *QliksenseConfig) BuildCrFilePath(contextName string) string {
+//BuildCrFileAbsolutePath build absolute path for a cr ie. ~/.qliksense/contexts/qlik-defautl/qlik-default.yaml
+func (qc *QliksenseConfig) BuildCrFileAbsolutePath(contextName string) string {
 	return filepath.Join(qc.QliksenseHomePath, qliksenseContextsDirName, contextName, contextName+".yaml")
 }
 
+//BuildCrFilePath build cr file path i.e. contexts/qlik-default/qlik-default.yaml
+func (qc *QliksenseConfig) BuildCrFilePath(contextName string) string {
+	return filepath.Join(qliksenseContextsDirName, contextName, contextName+".yaml")
+}
+
 //AddToContexts add the context into qc.Spec.Contexts
-func (qc *QliksenseConfig) AddToContexts(crName, crFile string) {
+func (qc *QliksenseConfig) AddToContextsRaw(crName, crFile string) {
 	qc.Spec.Contexts = append(qc.Spec.Contexts, []Context{
 		{CrFile: crFile,
 			Name: crName},
@@ -422,3 +497,10 @@ func (qc *QliksenseConfig) SetCurrentContextName(name string) {
 func (qc *QliksenseConfig) Write() error {
 	return WriteToFile(qc, filepath.Join(qc.QliksenseHomePath, "config.yaml"))
 }
+
+func (qc *QliksenseConfig) GetCrManifestRoot(cr *QliksenseCR) string {
+	if filepath.IsAbs(cr.Spec.GetManifestsRoot()) {
+		return cr.Spec.GetManifestsRoot()
+	}
+	return filepath.Join(qc.QliksenseHomePath, cr.Spec.GetManifestsRoot())
+}

pkg/api/apis_test.go

@@ -46,7 +46,7 @@ metadata:
     version: v1.0.0
 spec:
   profile: docker-desktop
-  manifestsRoot: /Users/mqb/.qliksense/contexts/contx1/qlik-k8s/v0.0.1/manifests
+  manifestsRoot: contexts/contx1/qlik-k8s/v0.0.1/manifests
   storageClassName: efs
   configs:
     qliksense:
@@ -74,7 +74,7 @@ func TestGetCR(t *testing.T) {
 	// create CR
 	createCRFile(dir)
 
-	crFile := filepath.Join(dir, "contexts", "contx1", "contx1.yaml")
+	crFile := filepath.Join("contexts", "contx1", "contx1.yaml")
 	qct, e := qc.SetCrLocation("contx1", crFile)
 	if e != nil {
 		t.Fail()
@@ -100,7 +100,7 @@ func TestGetDecryptedCr(t *testing.T) {
 	// create CR
 	createCRFile(dir)
 
-	crFile := filepath.Join(dir, "contexts", "contx1", "contx1.yaml")
+	crFile := filepath.Join("contexts", "contx1", "contx1.yaml")
 	qct, e := qc.SetCrLocation("contx1", crFile)
 	if e != nil {
 		t.Fail()

pkg/api/context_apis.go

@@ -63,7 +63,7 @@ func (qliksenseConfig *QliksenseConfig) SwitchCurrentCRToVersionAndProfile(versi
 	if qcr, err := qliksenseConfig.GetCurrentCR(); err != nil {
 		return err
 	} else {
-		versionManifestRoot := qliksenseConfig.BuildCurrentManifestsRoot(version)
+		versionManifestRoot := qliksenseConfig.BuildCurrentRelativeManifestsRoot(version)
 		if (qcr.Spec.ManifestsRoot != versionManifestRoot) || (profile != "" && qcr.Spec.Profile != profile) || (qcr.GetLabelFromCr("version") != version) {
 			qcr.Spec.ManifestsRoot = versionManifestRoot
 			if profile != "" {

pkg/api/kubectl.go

@@ -109,6 +109,7 @@ func KubectlDirectOps(opr []string, namespace string) error {
 	LogDebugMessage("Kubectl command: %s %v\n", "kubectl", arguments)
 	sterrBuffer := &bytes.Buffer{}
 	cmd.Stderr = sterrBuffer
+	cmd.Stdout = os.Stdout
 	if err := cmd.Run(); err != nil {
 		return fmt.Errorf("kubectl %v failed with: %v, %v\n", opr, err, sterrBuffer.String())
 	}

pkg/api/utils.go

@@ -232,7 +232,6 @@ func UntarGzFile(destination, fileToUntar string) error {
 			fileAtLoc.Chmod(os.ModePerm)
 		}
 	}
-	return nil
 }
 
 func UnZipFile(destination, fileToUnzip string) error {

pkg/qliksense/about.go

@@ -167,7 +167,7 @@ func (q *Qliksense) configExistsInCurrentContext() (exists bool, directory strin
 	} else if currentCr.Spec.ManifestsRoot == "" {
 		return false, "", "", nil
 	} else {
-		return true, currentCr.Spec.GetManifestsRoot(), currentCr.Spec.Profile, nil
+		return true, q.GetCrManifestRoot(currentCr), currentCr.Spec.Profile, nil
 	}
 }
 

pkg/qliksense/apply.go

@@ -0,0 +1,23 @@
+package qliksense
+
+import (
+	"io"
+
+	qapi "github.com/qlik-oss/sense-installer/pkg/api"
+)
+
+func (q *Qliksense) ApplyCRFromReader(r io.Reader) error {
+	if err := q.LoadCr(r); err != nil {
+		return err
+	}
+	qConfig := qapi.NewQConfig(q.QliksenseHome)
+	cr, err := qConfig.GetCurrentCR()
+	if err != nil {
+		return err
+	}
+	opts := &InstallCommandOptions{}
+	if err := q.InstallQK8s(cr.GetLabelFromCr("version"), opts, true); err != nil {
+		return err
+	}
+	return nil
+}

pkg/qliksense/config.go

@@ -82,12 +82,12 @@ func (q *Qliksense) applyConfigToK8s(qcr *qapi.QliksenseCR) error {
 		fmt.Printf(`error fetching user's home directory: %v\n`, err)
 		return err
 	}
-	fmt.Println("Manifests root: " + qcr.Spec.GetManifestsRoot())
+	fmt.Println("Manifests root: " + q.GetCrManifestRoot(qcr))
 	qcr.SetNamespace(qapi.GetKubectlNamespace())
 	// generate patches
 	cr.GeneratePatches(&qcr.KApiCr, path.Join(userHomeDir, ".kube", "config"))
 	// apply generated manifests
-	profilePath := filepath.Join(qcr.Spec.GetManifestsRoot(), qcr.Spec.GetProfileDir())
+	profilePath := filepath.Join(q.GetCrManifestRoot(qcr), qcr.Spec.GetProfileDir())
 	mByte, err := executeKustomizeBuild(profilePath)
 	if err != nil {
 		fmt.Println("cannot generate manifests for "+profilePath, err)

pkg/qliksense/context_configs.go

@@ -3,7 +3,6 @@ package qliksense
 import (
 	"crypto/rsa"
 	"fmt"
-	"github.com/robfig/cron/v3"
 	"io/ioutil"
 	"log"
 	"os"
@@ -11,6 +10,8 @@ import (
 	"strings"
 	"text/tabwriter"
 
+	"github.com/robfig/cron/v3"
+
 	"github.com/qlik-oss/k-apis/pkg/config"
 
 	b64 "encoding/base64"
@@ -300,7 +301,7 @@ func (q *Qliksense) ListContextConfigs() error {
 	w.Flush()
 	if len(qliksenseConfig.Spec.Contexts) > 0 {
 		for _, cont := range qliksenseConfig.Spec.Contexts {
-			fmt.Fprintln(w, cont.Name, "\t", cont.CrFile, "\t")
+			fmt.Fprintln(w, cont.Name, "\t", qliksenseConfig.GetCRFilePath(cont.Name), "\t")
 		}
 		w.Flush()
 		fmt.Fprintln(out, "")
@@ -378,6 +379,7 @@ func (q *Qliksense) SetUpQliksenseDefaultContext() error {
 
 // SetUpQliksenseContext - to setup qliksense context
 func (q *Qliksense) SetUpQliksenseContext(contextName string, isDefaultContext bool) error {
+	fmt.Println(contextName)
 	if contextName == "" {
 		err := fmt.Errorf("Please enter a non-empty context-name")
 		log.Println(err)
@@ -391,83 +393,28 @@ func (q *Qliksense) SetUpQliksenseContext(contextName string, isDefaultContext b
 	}
 
 	qliksenseConfigFile := filepath.Join(q.QliksenseHome, QliksenseConfigFile)
-	var qliksenseConfig api.QliksenseConfig
-	configFileTrack := false
+	qliksenseConfig := api.NewQConfigEmpty(q.QliksenseHome)
 
 	if !api.FileExists(qliksenseConfigFile) {
 		qliksenseConfig.AddBaseQliksenseConfigs(contextName)
 	} else {
-		if err := api.ReadFromFile(&qliksenseConfig, qliksenseConfigFile); err != nil {
-			log.Println(err)
-			return err
-		}
-		if isDefaultContext { // if config file exits but a default context is requested, we want to prevent writing to config file
-			configFileTrack = true
-		}
-	}
-	// creating a file in the name of the context if it does not exist/ opening it to append/modify content if it already exists
-
-	qliksenseContextsDir1 := filepath.Join(q.QliksenseHome, QliksenseContextsDir)
-	if !api.DirExists(qliksenseContextsDir1) {
-		if err := os.Mkdir(qliksenseContextsDir1, os.ModePerm); err != nil {
-			err = fmt.Errorf("Not able to create %s dir: %v", qliksenseContextsDir1, err)
+		if err := api.ReadFromFile(qliksenseConfig, qliksenseConfigFile); err != nil {
 			log.Println(err)
 			return err
 		}
 	}
-	api.LogDebugMessage("%s exists", qliksenseContextsDir1)
 
-	// creating contexts/qlik-default/qlik-default.yaml file
-	qliksenseContextFile := filepath.Join(qliksenseContextsDir1, contextName, contextName+".yaml")
-	//var qliksenseCR api.QliksenseCR
-
-	defaultContextsDir := filepath.Join(qliksenseContextsDir1, contextName)
-	if !api.DirExists(defaultContextsDir) {
-		if err := os.Mkdir(defaultContextsDir, os.ModePerm); err != nil {
-			err = fmt.Errorf("Not able to create %s: %v", defaultContextsDir, err)
-			log.Println(err)
-			return err
-		}
+	if qliksenseConfig.IsContextExist(contextName) {
+		fmt.Println("context [ " + contextName + " ] already exist")
+		return nil
 	}
-	api.LogDebugMessage("%s exists", defaultContextsDir)
-	if !api.FileExists(qliksenseContextFile) {
-		qliksenseCR := &api.QliksenseCR{}
-		qliksenseCR.AddCommonConfig(contextName)
-		api.WriteToFile(&qliksenseCR, qliksenseContextFile)
-		api.LogDebugMessage("Added Context: %s", contextName)
-	}
-	// else {
-	// 	if err := api.ReadFromFile(&qliksenseCR, qliksenseContextFile); err != nil {
-	// 		log.Println(err)
-	// 		return err
-	// 	}
-	// }
-
-	//api.WriteToFile(&qliksenseCR, qliksenseContextFile)
-	ctxTrack := false
-	if len(qliksenseConfig.Spec.Contexts) > 0 {
-		for _, ctx := range qliksenseConfig.Spec.Contexts {
-			if ctx.Name == contextName {
-				ctx.CrFile = qliksenseContextFile
-				ctxTrack = true
-				break
-			}
-		}
-	}
-	if !ctxTrack {
-		qliksenseConfig.Spec.Contexts = append(qliksenseConfig.Spec.Contexts, api.Context{
-			Name:   contextName,
-			CrFile: qliksenseContextFile,
-		})
-	}
-	qliksenseConfig.Spec.CurrentContext = contextName
-	if !configFileTrack {
-		api.WriteToFile(&qliksenseConfig, qliksenseConfigFile)
+	qliksenseCR := &api.QliksenseCR{}
+	qliksenseCR.AddCommonConfig(contextName)
+	if err := qliksenseConfig.CreateOrWriteCrAndContext(qliksenseCR); err != nil {
+		return err
 	}
 	// set the encrypted default mongo
-	q.SetSecrets([]string{`qliksense.mongoDbUri="mongodb://qlik-default-mongodb:27017/qliksense?ssl=false"`}, false)
-
-	return nil
+	return q.SetSecrets([]string{`qliksense.mongoDbUri="mongodb://qlik-default-mongodb:27017/qliksense?ssl=false"`}, false)
 }
 
 func validateInput(input string) (string, error) {
@@ -578,3 +525,13 @@ func (q *Qliksense) SetImageRegistry(registry, pushUsername, pushPassword, pullU
 	qliksenseCR.Spec.AddToConfigs("qliksense", imageRegistryConfigKey, registry)
 	return api.WriteToFile(&qliksenseCR, qliksenseContextsFile)
 }
+
+func (q *Qliksense) SetEulaAccepted() error {
+	qConfig := api.NewQConfig(q.QliksenseHome)
+	qcr, err := qConfig.GetCurrentCR()
+	if err != nil {
+		return err
+	}
+	qcr.SetEULA("yes")
+	return qConfig.WriteCurrentContextCR(qcr)
+}

pkg/qliksense/context_configs_test.go

@@ -165,7 +165,7 @@ metadata:
 spec:
   contexts:
   - name: qlik-default
-    crFile: /root/.qliksense/contexts/qlik-default.yaml
+    crFile: contexts/qlik-default/qlik-default.yaml
   currentContext: qlik-default
 `
 	configFile := filepath.Join(testDir, "config.yaml")
@@ -397,7 +397,7 @@ func TestSetConfigs(t *testing.T) {
 
 func TestSetImageRegistry(t *testing.T) {
 	getQlikSense := func(tmpQlikSenseHome string) (*Qliksense, error) {
-		if err := ioutil.WriteFile(path.Join(tmpQlikSenseHome, "config.yaml"), []byte(fmt.Sprintf(`
+		if err := ioutil.WriteFile(path.Join(tmpQlikSenseHome, "config.yaml"), []byte(`
 apiVersion: config.qlik.com/v1
 kind: QliksenseConfig
 metadata:
@@ -405,9 +405,9 @@ metadata:
 spec:
   contexts:
   - name: qlik-default
-    crFile: %s/contexts/qlik-default/qlik-default.yaml
+    crFile: contexts/qlik-default/qlik-default.yaml
   currentContext: qlik-default
-`, tmpQlikSenseHome)), os.ModePerm); err != nil {
+`), os.ModePerm); err != nil {
 			return nil, err
 		}
 
@@ -799,11 +799,11 @@ metadata:
 spec:
   contexts:
   - name: qlik-default
-    crFile: /root/.qliksense/contexts/qlik-default.yaml
+    crFile: contexts/qlik-default.yaml
   - name: qlik1
-    crFile: /root/.qliksense/contexts/qlik1.yaml
+    crFile: contexts/qlik1.yaml
   - name: qlik2
-    crFile: /root/.qliksense/contexts/qlik2.yaml
+    crFile: contexts/qlik2.yaml
   currentContext: qlik1
 `
 	configFile := filepath.Join(testDir, "config.yaml")

pkg/qliksense/crds.go

@@ -19,7 +19,7 @@ func (q *Qliksense) ViewCrds(opts *CrdCommandOptions) error {
 		fmt.Println("cannot get the current-context cr", err)
 		return err
 	}
-	if engineCRD, err := getQliksenseInitCrd(qcr); err != nil {
+	if engineCRD, err := q.getQliksenseInitCrd(qcr); err != nil {
 		return err
 	} else if opts.All {
 		fmt.Printf("%s\n%s", q.GetOperatorCRDString(), engineCRD)
@@ -38,7 +38,7 @@ func (q *Qliksense) InstallCrds(opts *CrdCommandOptions) error {
 		return err
 	}
 
-	if engineCRD, err := getQliksenseInitCrd(qcr); err != nil {
+	if engineCRD, err := q.getQliksenseInitCrd(qcr); err != nil {
 		return err
 	} else if err = qapi.KubectlApply(engineCRD, ""); err != nil {
 		return err
@@ -52,12 +52,12 @@ func (q *Qliksense) InstallCrds(opts *CrdCommandOptions) error {
 	return nil
 }
 
-func getQliksenseInitCrd(qcr *qapi.QliksenseCR) (string, error) {
+func (q *Qliksense) getQliksenseInitCrd(qcr *qapi.QliksenseCR) (string, error) {
 	var repoPath string
 	var err error
 
-	if qcr.Spec.GetManifestsRoot() != "" {
-		repoPath = qcr.Spec.GetManifestsRoot()
+	if q.GetCrManifestRoot(qcr) != "" {
+		repoPath = q.GetCrManifestRoot(qcr)
 	} else {
 		if repoPath, err = downloadFromGitRepoToTmpDir(defaultConfigRepoGitUrl, "master"); err != nil {
 			return "", err

pkg/qliksense/crds_test.go

@@ -8,12 +8,13 @@ import (
 )
 
 func TestGetQliksenseInitCrd(t *testing.T) {
+	q := &Qliksense{}
 	someTmpRepoPath, err := downloadFromGitRepoToTmpDir(defaultConfigRepoGitUrl, "master")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	crdFromContextConfig, err := getQliksenseInitCrd(&qapi.QliksenseCR{
+	crdFromContextConfig, err := q.getQliksenseInitCrd(&qapi.QliksenseCR{
 		KApiCr: kapi_config.KApiCr{
 			Spec: &kapi_config.CRSpec{
 				ManifestsRoot: someTmpRepoPath,
@@ -24,7 +25,7 @@ func TestGetQliksenseInitCrd(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	crdFromDownloadedConfig, err := getQliksenseInitCrd(&qapi.QliksenseCR{
+	crdFromDownloadedConfig, err := q.getQliksenseInitCrd(&qapi.QliksenseCR{
 		KApiCr: kapi_config.KApiCr{
 			Spec: &kapi_config.CRSpec{
 				ManifestsRoot: "",

pkg/qliksense/docker.go

@@ -36,7 +36,7 @@ func (q *Qliksense) PullImagesForCurrentCR() error {
 	}
 	version := qcr.GetLabelFromCr("version")
 	profile := qcr.Spec.Profile
-	repoDir := qcr.Spec.ManifestsRoot
+	repoDir := q.GetCrManifestRoot(qcr)
 
 	imagesDir, err := setupImagesDir(q.QliksenseHome)
 	if err != nil {
@@ -125,7 +125,7 @@ func (q *Qliksense) PushImagesForCurrentCR() error {
 	}
 	version := qcr.GetLabelFromCr("version")
 	profile := qcr.Spec.Profile
-	repoDir := qcr.Spec.ManifestsRoot
+	repoDir := q.GetCrManifestRoot(qcr)
 
 	dockerConfigJsonSecret, err := qConfig.GetPushDockerConfigJsonSecret()
 	if err != nil {

pkg/qliksense/docker_test.go

@@ -171,7 +171,7 @@ func Test_Pull_Push_ImagesForCurrentCR(t *testing.T) {
 }
 
 func setupQlikSenseHome(t *testing.T, tmpQlikSenseHome string, registry *testRegistryV2, clientAuth clientAuthType) error {
-	if err := ioutil.WriteFile(path.Join(tmpQlikSenseHome, "config.yaml"), []byte(fmt.Sprintf(`
+	if err := ioutil.WriteFile(path.Join(tmpQlikSenseHome, "config.yaml"), []byte(`
 apiVersion: config.qlik.com/v1
 kind: QliksenseConfig
 metadata:
@@ -179,9 +179,9 @@ metadata:
 spec:
   contexts:
   - name: qlik-default
-    crFile: %s/contexts/qlik-default/qlik-default.yaml
+    crFile: contexts/qlik-default/qlik-default.yaml
   currentContext: qlik-default
-`, tmpQlikSenseHome)), os.ModePerm); err != nil {
+`), os.ModePerm); err != nil {
 		return err
 	}
 

pkg/qliksense/fetch.go

@@ -34,7 +34,7 @@ func fetchAndUpdateCR(qConfig *qapi.QliksenseConfig, version string) error {
 	} else if err = kapis_git.Checkout(repo, version, fmt.Sprintf("%v-by-operator-%v", version, uuid.New().String()), nil); err != nil {
 		return err
 	}
-	qcr.Spec.ManifestsRoot = qConfig.BuildCurrentManifestsRoot(version)
+	qcr.Spec.ManifestsRoot = qConfig.BuildCurrentRelativeManifestsRoot(version)
 	qcr.AddLabelToCr("version", version)
 	return qConfig.WriteCurrentContextCR(qcr)
 }

pkg/qliksense/get_installable_versions.go

@@ -21,8 +21,8 @@ func (q *Qliksense) GetInstallableVersions(opts *LsRemoteCmdOptions) error {
 	}
 
 	var repoPath string
-	if qcr.Spec.GetManifestsRoot() != "" {
-		repoPath = qcr.Spec.GetManifestsRoot()
+	if q.GetCrManifestRoot(qcr) != "" {
+		repoPath = q.GetCrManifestRoot(qcr)
 	} else {
 		repoPath, err = downloadFromGitRepoToTmpDir(defaultConfigRepoGitUrl, "master")
 		if err != nil {

pkg/qliksense/install.go

@@ -42,7 +42,7 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 	}
 
 	if opts.AcceptEULA != "" {
-		qcr.Spec.AddToConfigs("qliksense", "acceptEULA", opts.AcceptEULA)
+		qcr.SetEULA(opts.AcceptEULA)
 	}
 	if opts.MongoDbUri != "" {
 		qcr.Spec.AddToSecrets("qliksense", "mongoDbUri", opts.MongoDbUri, "")
@@ -107,7 +107,7 @@ func (q *Qliksense) InstallQK8s(version string, opts *InstallCommandOptions, kee
 	if err != nil {
 		fmt.Println("cannot get the current-context cr", err)
 		return err
-	} else if qcr.Spec.GetManifestsRoot() == "" {
+	} else if qConfig.GetCrManifestRoot(qcr) == "" {
 		return errors.New("cannot get the manifest root. Use qliksense fetch <version> or qliksense set manifestsRoot")
 	}
 

pkg/qliksense/install_test.go

@@ -0,0 +1,65 @@
+package qliksense
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	qapi "github.com/qlik-oss/sense-installer/pkg/api"
+)
+
+func TestCreateK8sResoruceBeforePatch(t *testing.T) {
+	td := setup()
+	sampleCr := `
+apiVersion: qlik.com/v1
+kind: Qliksense
+metadata:
+  name: qlik-test3
+  labels:
+    version: v0.0.2
+spec:
+  git:
+    repository: https://github.com/ffoysal/qliksense-k8s
+    accessToken: abababababababaab
+    userName: "blblbl"
+  gitOps:
+    enabled: "no"
+    schedule: "*/1 * * * *"
+    watchBranch: pr-branch-db1d26d6
+    image: qlik-docker-oss.bintray.io/qliksense-repo-watcher
+  configs:
+    qliksense:
+    - name: acceptEULA
+      value: "yes"
+  secrets:
+    qliksense:
+    - name: mongoDbUri
+      value: mongodb://qlik-default-mongodb:27017/qliksense?ssl=false
+  profile: docker-desktop
+  rotateKeys: "yes"`
+
+	crFile := filepath.Join(testDir, "install_test.yaml")
+	ioutil.WriteFile(crFile, []byte(sampleCr), 0644)
+	q := New(testDir)
+	file, e := os.Open(crFile)
+	if e != nil {
+		t.Log(e)
+		t.FailNow()
+	}
+	if err := q.LoadCr(file); err != nil {
+		t.Log(err)
+		t.FailNow()
+	}
+	qConfig := qapi.NewQConfig(testDir)
+	cr, err := qConfig.GetCR("qlik-test3")
+	if err != nil {
+		t.Log(err)
+		t.FailNow()
+	}
+	if err = q.createK8sResoruceBeforePatch(cr); err != nil {
+		t.Log(err)
+		t.FailNow()
+	}
+	td()
+}

pkg/qliksense/load_cr.go

@@ -32,12 +32,35 @@ func (q *Qliksense) loadCrStringIntoFileSystem(crstr string) (string, error) {
 	}
 	qConfig.CreateContextDirs(cr.GetName())
 
-	if err = qapi.WriteToFile(cr, qConfig.BuildCrFilePath(cr.GetName())); err != nil {
+	// encrypt the secrets and do base64 then update the CR
+	rsaPublicKey, _, err := qConfig.GetContextEncryptionKeyPair(cr.GetName())
+	if err != nil {
 		return "", err
 	}
-	qConfig.AddToContexts(cr.GetName(), qConfig.BuildCrFilePath(cr.GetName()))
+	for svc, nvs := range cr.Spec.Secrets {
+		for _, nv := range nvs {
+			if nv.ValueFrom == nil {
+				skv := &qapi.ServiceKeyValue{
+					Key:     nv.Name,
+					Value:   nv.Value,
+					SvcName: svc,
+				}
+				if err := q.processSecret(skv, rsaPublicKey, cr, false); err != nil {
+					return cr.GetName(), err
+				}
+			}
+		}
+	}
+
+	// write to disk
+
+	if err = qConfig.CreateOrWriteCrAndContext(cr); err != nil {
+		return "", err
+	}
+	qConfig.AddToContextsRaw(cr.GetName(), qConfig.BuildCrFilePath(cr.GetName()))
 	qConfig.SetCurrentContextName(cr.GetName())
 	qConfig.Write()
+
 	return cr.GetName(), nil
 }
 
@@ -50,6 +73,7 @@ func readMultipleYamlFromReader(reader io.Reader) []string {
 		if s == "---" {
 			docs = append(docs, adoc)
 			adoc = ""
+			s = ""
 		}
 		adoc = adoc + "\n" + s
 	}

pkg/qliksense/load_cr_test.go

@@ -11,6 +11,7 @@ import (
 
 func TestLoadCrFile(t *testing.T) {
 	td := setup()
+	setup()
 	sampleCr := `
 apiVersion: qlik.com/v1
 kind: Qliksense
@@ -18,6 +19,33 @@ metadata:
   name: qlik-test
   labels:
     version: v0.0.2
+spec:
+  git:
+    repository: https://github.com/ffoysal/qliksense-k8s
+    accessToken: abababababababaab
+    userName: "blblbl"
+  gitOps:
+    enabled: "no"
+    schedule: "*/1 * * * *"
+    watchBranch: pr-branch-db1d26d6
+    image: qlik-docker-oss.bintray.io/qliksense-repo-watcher
+  configs:
+    qliksense:
+    - name: acceptEULA
+      value: "yes"
+  secrets:
+    qliksense:
+    - name: mongoDbUri
+      value: mongodb://qlik-default-mongodb:27017/qliksense?ssl=false
+  profile: docker-desktop
+  rotateKeys: "yes"
+---
+apiVersion: qlik.com/v1
+kind: Qliksense
+metadata:
+  name: qlik-test3
+  labels:
+    version: v0.0.2
 spec:
   git:
     repository: https://github.com/ffoysal/qliksense-k8s
@@ -76,7 +104,17 @@ spec:
 	if cr.GetName() != "qlik-test" {
 		t.FailNow()
 	}
-	if qConfig.Spec.CurrentContext != "qlik-test" {
+
+	cr, err = qConfig.GetCR("qlik-test3")
+	if err != nil {
+		t.Log(err)
+		t.FailNow()
+	}
+	if cr.GetName() != "qlik-test3" {
+		t.FailNow()
+	}
+
+	if qConfig.Spec.CurrentContext != "qlik-test3" {
 		t.FailNow()
 	}
 	file, e = os.Open(dupCrFile)

pkg/qliksense/preflight_checks.go

@@ -163,7 +163,8 @@ func determinePlatformSpecificUrls(platform string) (string, string, error) {
 func (q *Qliksense) CheckDns() error {
 	// retrieve namespace
 	namespace := api.GetKubectlNamespace()
-	api.LogDebugMessage("Namespace here: %s", namespace)
+
+	api.LogDebugMessage("Namespace: %s\n", namespace)
 
 	tmpl, err := template.New("test").Parse(dnsCheckYAML)
 	if err != nil {
@@ -191,6 +192,8 @@ func (q *Qliksense) CheckDns() error {
 	const PreflightChecksDirName = "preflight_checks"
 	const preflightFileName = "preflight"
 
+	fmt.Println("Creating resources to run preflight checks")
+
 	// kubectl create deployment
 	opr := fmt.Sprintf("create deployment %s --image=nginx", appName)
 	err = initiateK8sOps(opr, namespace)
@@ -198,7 +201,6 @@ func (q *Qliksense) CheckDns() error {
 		fmt.Println(err)
 		return err
 	}
-	api.LogDebugMessage("create deployment executed")
 
 	defer func() {
 		// Deleting deployment..
@@ -215,7 +217,6 @@ func (q *Qliksense) CheckDns() error {
 		fmt.Println(err)
 		return err
 	}
-	api.LogDebugMessage("create service executed")
 
 	defer func() {
 		// delete service
@@ -236,18 +237,13 @@ func (q *Qliksense) CheckDns() error {
 
 	// call preflight
 	preflightCommand := filepath.Join(q.QliksenseHome, PreflightChecksDirName, preflightFileName)
-	trackSuccess, err := invokePreflight(preflightCommand, tempYaml)
+
+	err = invokePreflight(preflightCommand, tempYaml)
 	if err != nil {
 		fmt.Println(err)
 		return err
 	}
 
-	if trackSuccess {
-		fmt.Println("PREFLIGHT DNS CHECK PASSED")
-	} else {
-		fmt.Println("PREFLIGHT DNS CHECK FAILED")
-	}
-
 	return nil
 }
 
@@ -261,7 +257,7 @@ func initiateK8sOps(opr, namespace string) error {
 	return nil
 }
 
-func invokePreflight(preflightCommand string, yamlFile *os.File) (bool, error) {
+func invokePreflight(preflightCommand string, yamlFile *os.File) error {
 	arguments := []string{}
 	arguments = append(arguments, yamlFile.Name(), "--interactive=false")
 	cmd := exec.Command(preflightCommand, arguments...)
@@ -270,7 +266,7 @@ func invokePreflight(preflightCommand string, yamlFile *os.File) (bool, error) {
 	cmd.Stdout = sterrBuffer
 	cmd.Stderr = sterrBuffer
 	if err := cmd.Run(); err != nil {
-		return false, fmt.Errorf("Error when running preflight command: %v\n", err)
+		return fmt.Errorf("Error when running preflight command: %v\n", err)
 	}
 	ind := strings.Index(sterrBuffer.String(), "---")
 	output := sterrBuffer.String()
@@ -278,25 +274,28 @@ func invokePreflight(preflightCommand string, yamlFile *os.File) (bool, error) {
 		output = fmt.Sprintf("%s\n%s", output[:ind], output[ind:])
 	}
 	fmt.Printf("%v\n", output)
-	outputArr := strings.Fields(strings.TrimSpace(output))
-	trackSuccess := false
-	trackPrg := false
 
-	// We are only checking the overall "PASS" or "FAIL"
+	// Maybe good to retain this part in case we need to process the output in future.
 	// We are going to look for the first occurance of PASS or FAIL from the end
-	// there are also some space-like deceiving characters
-	for i := len(outputArr) - 1; i >= 0; i-- {
-		if strings.TrimSpace(outputArr[i]) != "" {
-			if outputArr[i] == "PASS" {
-				trackSuccess = true
-				trackPrg = true
-			} else if outputArr[i] == "FAIL" {
-				trackPrg = true
-			}
-		}
-		if trackPrg {
-			break
-		}
-	}
-	return trackSuccess, nil
+	// there are also some space-like deceiving characters which are being hard to get by
+
+	//outputArr := strings.Fields(strings.TrimSpace(output))
+	//trackSuccess := false
+	//trackPrg := false
+
+	//for i := len(outputArr) - 1; i >= 0; i-- {
+	//	if strings.TrimSpace(outputArr[i]) != "" {
+	//		if outputArr[i] == "PASS" {
+	//			trackSuccess = true
+	//			trackPrg = true
+	//		} else if outputArr[i] == "FAIL" {
+	//			trackPrg = true
+	//		}
+	//	}
+	//	if trackPrg {
+	//		break
+	//	}
+	//}
+	fmt.Println("Preflight checks completed, cleaning up resources now")
+	return nil
 }

pkg/qliksense/repo.go

@@ -2,6 +2,7 @@ package qliksense
 
 import (
 	"errors"
+	"path/filepath"
 
 	kapis_git "github.com/qlik-oss/k-apis/pkg/git"
 	qapi "github.com/qlik-oss/sense-installer/pkg/api"
@@ -12,8 +13,8 @@ func (q *Qliksense) DiscardAllUnstagedChangesFromGitRepo(qConfig *qapi.Qliksense
 		return err
 	} else if version := qcr.GetLabelFromCr("version"); version == "" {
 		return errors.New("version label is not set in CR")
-	} else if qcr.Spec.ManifestsRoot == qConfig.BuildRepoPath(version) {
-		if repo, err := kapis_git.OpenRepository(qcr.Spec.ManifestsRoot); err != nil {
+	} else if qConfig.GetCrManifestRoot(qcr) == qConfig.BuildRepoPath(version) {
+		if repo, err := kapis_git.OpenRepository(qConfig.GetCrManifestRoot(qcr)); err != nil {
 			return err
 		} else if err = kapis_git.DiscardAllUnstagedChanges(repo); err != nil {
 			return err
@@ -21,3 +22,10 @@ func (q *Qliksense) DiscardAllUnstagedChangesFromGitRepo(qConfig *qapi.Qliksense
 	}
 	return nil
 }
+
+func (q *Qliksense) GetCrManifestRoot(cr *qapi.QliksenseCR) string {
+	if filepath.IsAbs(cr.Spec.GetManifestsRoot()) {
+		return cr.Spec.GetManifestsRoot()
+	}
+	return filepath.Join(q.QliksenseHome, cr.Spec.GetManifestsRoot())
+}