load cr from file

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

.gitignore

@@ -6,3 +6,4 @@ pkg/qliksense/packrd
 pkg/qliksense/qliksense-packr.go
 pkg/qliksense/docker-registry
 /pkg/qliksense/tests
+.DS_Store

Makefile

@@ -92,7 +92,7 @@ clean-packr: packr2
 
 get-crds:
 	$(eval TMP := $(shell mktemp -d))
-	git clone https://github.com/qlik-oss/qliksense-operator.git -b ms-3 $(TMP)/operator
+	git clone https://github.com/qlik-oss/qliksense-operator.git -b master $(TMP)/operator
 	mkdir -p pkg/qliksense/crds/cr
 	mkdir -p pkg/qliksense/crds/crd
 	mkdir -p pkg/qliksense/crds/crd-deploy

cmd/qliksense/config.go

@@ -20,7 +20,7 @@ func configCmd(q *qliksense.Qliksense) *cobra.Command {
 func configApplyCmd(q *qliksense.Qliksense) *cobra.Command {
 	c := &cobra.Command{
 		Use:     "apply",
-		Short:   "generate the patchs and apply manifests to k8s",
+		Short:   "generate the patches and apply manifests to k8s",
 		Long:    `generate patches based on CR and apply manifests to k8s`,
 		Example: `qliksense config apply`,
 		RunE: func(cmd *cobra.Command, args []string) error {

cmd/qliksense/load.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"os"
+
+	"github.com/pkg/errors"
+	"github.com/qlik-oss/sense-installer/pkg/qliksense"
+	"github.com/spf13/cobra"
+)
+
+func loadCrFile(q *qliksense.Qliksense) *cobra.Command {
+	filePath := ""
+	c := &cobra.Command{
+		Use:   "load",
+		Short: "load a CR a file and create necessary structure for future use",
+		Long:  `load a CR a file and create necessary structure for future use`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if filePath == "-" {
+				return q.LoadCr(os.Stdin)
+			}
+			file, e := os.Open(filePath)
+			if e != nil {
+				return errors.Wrapf(e,
+					"unable to read the file %s", filePath)
+			}
+			return q.LoadCr(file)
+		},
+	}
+	f := c.Flags()
+	f.StringVarP(&filePath, "file", "f", "", "File to laod CR from")
+	c.MarkFlagRequired("file")
+	return c
+}
+
+func isInputFromPipe() bool {
+	fileInfo, _ := os.Stdin.Stat()
+	return fileInfo.Mode()&os.ModeCharDevice == 0
+}

cmd/qliksense/preflight.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/qlik-oss/sense-installer/pkg/qliksense"
+	"github.com/spf13/cobra"
+)
+
+func preflightCmd(q *qliksense.Qliksense) *cobra.Command {
+	var configCmd = &cobra.Command{
+		Use:   "preflight",
+		Short: "perform preflight checks on the cluster",
+		Long:  `perform preflight checks on the cluster`,
+		Example: `qliksense preflight <preflight_check_to_run>
+Usage:
+qliksense preflight dns
+`,
+	}
+	return configCmd
+}
+
+func preflightCheckDnsCmd(q *qliksense.Qliksense) *cobra.Command {
+	var preflightDnsCmd = &cobra.Command{
+		Use:     "dns",
+		Short:   "perform preflight dns check",
+		Long:    `perform preflight dns check to check DNS connectivity status in the cluster`,
+		Example: `qliksense preflight dns`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			err := q.DownloadPreflight()
+			if err != nil {
+				err = fmt.Errorf("There has been an error downloading preflight: %+v", err)
+				log.Println(err)
+				return err
+			}
+			return q.CheckDns()
+		},
+	}
+	return preflightDnsCmd
+}

cmd/qliksense/root.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"io"
 	"log"
-	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
@@ -19,7 +18,7 @@ import (
 	"github.com/ttacon/chalk"
 )
 
-// To run this project in ddebug mode, run:
+// To run this project in debug mode, run:
 // export QLIKSENSE_DEBUG=true
 // qliksense <command>
 
@@ -45,7 +44,6 @@ func initAndExecute() error {
 	qliksenseClient := qliksense.New(qlikSenseHome)
 	qliksenseClient.SetUpQliksenseDefaultContext()
 	cmd := rootCmd(qliksenseClient)
-
 	if err := cmd.Execute(); err != nil {
 		//levenstein checks (auto-suggestions)
 		levenstein(cmd)
@@ -166,6 +164,15 @@ func rootCmd(p *qliksense.Qliksense) *cobra.Command {
 	cmd.AddCommand(crdsCmd)
 	crdsCmd.AddCommand(crdsViewCmd(p))
 	crdsCmd.AddCommand(crdsInstallCmd(p))
+
+	// add preflight command
+	preflightCmd := preflightCmd(p)
+	preflightCmd.AddCommand(preflightCheckDnsCmd(p))
+	//preflightCmd.AddCommand(preflightCheckMongoCmd(p))
+	//preflightCmd.AddCommand(preflightCheckAllCmd(p))
+
+	cmd.AddCommand(preflightCmd)
+	cmd.AddCommand(loadCrFile(p))
 	return cmd
 }
 
@@ -174,32 +181,6 @@ func initConfig() {
 	viper.AutomaticEnv()
 }
 
-func downloadFile(url string, filepath string) error {
-	var (
-		out  *os.File
-		err  error
-		resp *http.Response
-	)
-	// Create the file
-	if out, err = os.Create(filepath); err != nil {
-		return err
-	}
-	defer out.Close()
-
-	// Get the data
-	if resp, err = http.Get(url); err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	// Write the body to file
-	if _, err = io.Copy(out, resp.Body); err != nil {
-		return err
-	}
-
-	return nil
-}
-
 func copy(src, dst string) (int64, error) {
 	var (
 		source, destination *os.File
@@ -238,9 +219,11 @@ func levenstein(cmd *cobra.Command) {
 			for _, cm := range os.Args {
 				arg = append(arg, cm)
 			}
-			arg[1] = suggest[0]
-			out := ansi.NewColorableStdout()
-			fmt.Fprintln(out, chalk.Green.Color("Did you mean: "), chalk.Bold.TextStyle(strings.Join(arg, " ")), "?")
+			if !strings.EqualFold(arg[1], suggest[0]) {
+				arg[1] = suggest[0]
+				out := ansi.NewColorableStdout()
+				fmt.Fprintln(out, chalk.Green.Color("Did you mean: "), chalk.Bold.TextStyle(strings.Join(arg, " ")), "?")
+			}
 		}
 	}
 }

docs/concepts.md

@@ -75,3 +75,22 @@ When you perform `qliksense install` or `qliksene config apply`, qliksense opera
 - Install kubernetes resources
 - 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
+
+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
+  gitOps:
+    enabled: "yes"
+    schedule: "*/5 * * * *"
+    watchBranch: pr-branch-24868a33
+    image: qlik-docker-oss.bintray.io/qliksense-repo-watcher
+....
+```

go.mod

@@ -39,6 +39,7 @@ require (
 	github.com/mattn/go-colorable v0.1.4
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/morikuni/aec v1.0.0 // indirect
+	github.com/pkg/errors v0.8.1
 	github.com/qlik-oss/k-apis v0.0.22
 	github.com/robfig/cron/v3 v3.0.1
 	github.com/rogpeppe/go-internal v1.5.2 // indirect
@@ -56,6 +57,7 @@ require (
 	gopkg.in/yaml.v3 v3.0.0-20190924164351-c8b7dadae555
 	k8s.io/api v0.17.0
 	k8s.io/apimachinery v0.17.0
+	k8s.io/client-go v11.0.0+incompatible
 	sigs.k8s.io/kustomize/api v0.3.2
 	sigs.k8s.io/yaml v1.1.0
 )

pkg/api/apis.go

@@ -46,7 +46,7 @@ func (qc *QliksenseConfig) GetCR(contextName string) (*QliksenseCR, error) {
 	if crFilePath == "" {
 		return nil, errors.New("context name " + contextName + " not found")
 	}
-	return getCRObject(crFilePath)
+	return GetCRObject(crFilePath)
 }
 
 func getUnencryptedCR() {
@@ -77,7 +77,8 @@ func (qc *QliksenseConfig) SetCrLocation(contextName, filepath string) (*Qliksen
 	return nil, errors.New("cannot find the context")
 }
 
-func getCRObject(crfile string) (*QliksenseCR, error) {
+// GetCRObject create a qliksense CR object from file
+func GetCRObject(crfile string) (*QliksenseCR, error) {
 	cr := &QliksenseCR{}
 	err := ReadFromFile(cr, crfile)
 	if err != nil {
@@ -88,6 +89,20 @@ func getCRObject(crfile string) (*QliksenseCR, error) {
 	return cr, nil
 }
 
+//CreateCRObjectFromString create a QliksenseCR from string content
+func CreateCRObjectFromString(crContent string) (*QliksenseCR, error) {
+	if crContent == "" {
+		return nil, errors.New("empty string cannot qliksensecr")
+	}
+	cr := &QliksenseCR{}
+	err := ReadFromStream(cr, strings.NewReader(crContent))
+	if err != nil {
+		fmt.Println("cannot unmarshal cr ", err)
+		return nil, err
+	}
+	return cr, nil
+}
+
 func (qc *QliksenseConfig) getCRFilePath(contextName string) string {
 	crFilePath := ""
 	for _, ctx := range qc.Spec.Contexts {
@@ -374,3 +389,36 @@ func (qc *QliksenseConfig) GetDecryptedCr(cr *QliksenseCR) (*QliksenseCR, error)
 	newCr.Spec.Secrets = finalSecrets
 	return newCr, nil
 }
+
+//Validate validate CR
+func (cr *QliksenseCR) Validate() bool {
+	return true
+}
+
+//CreateContextDirs create context dir structure ~/.qliksense/contexts/contextName
+func (qc *QliksenseConfig) CreateContextDirs(contextName string) {
+	contexPath := filepath.Join(qc.QliksenseHomePath, qliksenseContextsDirName, contextName)
+	os.MkdirAll(contexPath, os.ModePerm)
+}
+
+func (qc *QliksenseConfig) BuildCrFilePath(contextName string) string {
+	return filepath.Join(qc.QliksenseHomePath, qliksenseContextsDirName, contextName, contextName+".yaml")
+}
+
+//AddToContexts add the context into qc.Spec.Contexts
+func (qc *QliksenseConfig) AddToContexts(crName, crFile string) {
+	qc.Spec.Contexts = append(qc.Spec.Contexts, []Context{
+		{CrFile: crFile,
+			Name: crName},
+	}...)
+}
+
+//SetCurrentContextName set the qc.Spec.CurrentContext
+func (qc *QliksenseConfig) SetCurrentContextName(name string) {
+	qc.Spec.CurrentContext = name
+}
+
+//Write write QliksenseConfig into config.yaml
+func (qc *QliksenseConfig) Write() error {
+	return WriteToFile(qc, filepath.Join(qc.QliksenseHomePath, "config.yaml"))
+}

pkg/api/context_apis.go

@@ -3,8 +3,10 @@ package api
 import (
 	"bytes"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"log"
+	"os"
 
 	"github.com/qlik-oss/k-apis/pkg/config"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -103,14 +105,22 @@ func ReadFromFile(content interface{}, sourceFile string) error {
 	if content == nil || sourceFile == "" {
 		return nil
 	}
-	contents, err := ioutil.ReadFile(sourceFile)
+	file, e := os.Open(sourceFile)
+	if e != nil {
+		return e
+	}
+	return ReadFromStream(content, file)
+}
+
+// ReadFromStream reads from input stream and creat yaml struct of type content
+func ReadFromStream(content interface{}, reader io.Reader) error {
+	contents, err := ioutil.ReadAll(reader)
 	if err != nil {
-		err = fmt.Errorf("There was an error reading from file: %s, %v", sourceFile, err)
+		err = fmt.Errorf("There was an error reading from reader: %v", err)
 		return err
 	}
 	// reading k8s style object
 	// https://stackoverflow.com/questions/44306554/how-to-deserialize-kubernetes-yaml-file
 	dec := machine_yaml.NewYAMLOrJSONDecoder(bytes.NewReader(contents), 10000)
-	dec.Decode(content)
-	return nil
+	return dec.Decode(content)
 }

pkg/api/kubectl.go

@@ -97,3 +97,20 @@ func kubectlOperation(manifests string, oprName string, namespace string) error
 	os.Remove(tempYaml.Name())
 	return nil
 }
+
+func KubectlDirectOps(opr []string, namespace string) error {
+	arguments := []string{}
+	if namespace != "" {
+		arguments = append(arguments, "-n", namespace)
+	}
+	arguments = append(arguments, opr...)
+
+	cmd := exec.Command("kubectl", arguments...)
+	LogDebugMessage("Kubectl command: %s %v\n", "kubectl", arguments)
+	sterrBuffer := &bytes.Buffer{}
+	cmd.Stderr = sterrBuffer
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("kubectl %v failed with: %v, %v\n", opr, err, sterrBuffer.String())
+	}
+	return nil
+}

pkg/api/kubectl_test.go

@@ -1,6 +1,8 @@
 package api
 
 import (
+	"fmt"
+	"strings"
 	"testing"
 )
 
@@ -15,3 +17,16 @@ func TestGetKubectlNamespace(t *testing.T) {
 	}
 	SetKubectlNamespace(ns)
 }
+
+func TestKubectlDirectOps(t *testing.T) {
+	t.Skip()
+	SetKubectlNamespace("test")
+	ns := GetKubectlNamespace()
+	opr := fmt.Sprintf("version")
+	opr1 := strings.Fields(opr)
+	err := KubectlDirectOps(opr1, ns)
+	if err != nil {
+		t.Log(err)
+		t.Fail()
+	}
+}

pkg/api/utils.go

@@ -1,13 +1,21 @@
 package api
 
 import (
+	"archive/tar"
+	"archive/zip"
+	"compress/gzip"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"log"
+	"net/http"
 	"os"
+	"path/filepath"
 	"regexp"
 	"strings"
 	"time"
+
+	"github.com/pkg/errors"
 )
 
 func checkExists(filename string) os.FileInfo {
@@ -109,3 +117,152 @@ func ExecuteTaskWithBlinkingStdoutFeedback(task func() (interface{}, error), fee
 		}
 	}
 }
+
+func DownloadFile(url, baseFolder, installerName string) error {
+	var (
+		out  *os.File
+		err  error
+		resp *http.Response
+	)
+	// Create the file
+	fileName := filepath.Join(baseFolder, installerName)
+	LogDebugMessage("Installer Filename: %s\n", fileName)
+	if out, err = os.Create(fileName); err != nil {
+		return err
+	}
+	defer out.Close()
+
+	// Get the data
+	if resp, err = http.Get(url); err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		err = fmt.Errorf("unable to download the file from URL: %s, status: %s", url, resp.Status)
+		log.Println(err)
+		return err
+	}
+
+	// Write the body to file
+	if _, err = io.Copy(out, resp.Body); err != nil {
+		return err
+	}
+	err = os.Chmod(fileName, os.ModePerm)
+	if err != nil {
+		log.Println(err)
+	}
+	return nil
+}
+
+func ExplodePackage(destination, fileToUntar string) error {
+	LogDebugMessage("Destination: %s\n", destination)
+	LogDebugMessage("fileToUntar: %s\n", fileToUntar)
+
+	if strings.HasSuffix(fileToUntar, "zip") {
+		LogDebugMessage("This is a windows file : %s", fileToUntar)
+		err := UnZipFile(destination, fileToUntar)
+		if err != nil {
+			return nil
+		}
+	} else if strings.HasSuffix(fileToUntar, "tar.gz") {
+		LogDebugMessage("This is a mac/linux file: %s", fileToUntar)
+		err := UntarGzFile(destination, fileToUntar)
+		if err != nil {
+			return nil
+		}
+	}
+	return nil
+}
+
+func UntarGzFile(destination, fileToUntar string) error {
+	lFile, err := os.Open(fileToUntar)
+	if err != nil {
+		err = errors.Wrapf(err, "unable to read the local file %s", fileToUntar)
+		log.Fatal(err)
+		return err
+	}
+
+	gzReader, err := gzip.NewReader(lFile)
+	if err != nil {
+		err = errors.Wrap(err, "unable to load the file into a gz reader")
+		log.Fatal(err)
+		return err
+	}
+	defer gzReader.Close()
+
+	tarReader := tar.NewReader(gzReader)
+	for {
+		header, err := tarReader.Next()
+		switch {
+		case err == io.EOF:
+			return nil
+		case err != nil:
+			err = errors.Wrap(err, "error during untar")
+			log.Fatal(err)
+			return err
+		case header == nil:
+			continue
+		}
+
+		fileInLoop := filepath.Join(destination, header.Name)
+		switch header.Typeflag {
+		case tar.TypeDir:
+			if _, err := os.Stat(fileInLoop); err != nil {
+				if err := os.MkdirAll(fileInLoop, 0755); err != nil {
+					err = errors.Wrapf(err, "error creating directory %s", fileInLoop)
+					log.Fatal(err)
+					return err
+				}
+			}
+		case tar.TypeReg:
+			fileAtLoc, err := os.OpenFile(fileInLoop, os.O_CREATE|os.O_RDWR, os.FileMode(header.Mode))
+			if err != nil {
+				err = errors.Wrapf(err, "error opening file %s", fileInLoop)
+				log.Fatal(err)
+				return err
+			}
+
+			if _, err := io.Copy(fileAtLoc, tarReader); err != nil {
+				err = errors.Wrapf(err, "error writing file %s", fileInLoop)
+				log.Fatal(err)
+				return err
+			}
+			fileAtLoc.Close()
+			fileAtLoc.Chmod(os.ModePerm)
+		}
+	}
+	return nil
+}
+
+func UnZipFile(destination, fileToUnzip string) error {
+	zipReader, _ := zip.OpenReader(fileToUnzip)
+	for _, file := range zipReader.Reader.File {
+
+		zippedFile, err := file.Open()
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer zippedFile.Close()
+		extractedFilePath := filepath.Join(
+			destination,
+			file.Name,
+		)
+		outputFile, err := os.OpenFile(
+			extractedFilePath,
+			os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
+			file.Mode(),
+		)
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer outputFile.Close()
+
+		_, err = io.Copy(outputFile, zippedFile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		LogDebugMessage("File extracted: %s, Extracted file path: %s\n", file.Name, extractedFilePath)
+	}
+	return nil
+}

pkg/qliksense/context_configs_test.go

@@ -152,6 +152,7 @@ func removePrivateKey() {
 
 func setup() func() {
 	// create tests dir
+	os.RemoveAll(testDir)
 	if err := os.Mkdir(testDir, 0777); err != nil {
 		log.Printf("\nError occurred: %v", err)
 	}

pkg/qliksense/kuz.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/qlik-oss/sense-installer/pkg/api"
 
+	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp" // don't delete this line ref: https://github.com/kubernetes/client-go/issues/242
 	"sigs.k8s.io/kustomize/api/filesys"
 	"sigs.k8s.io/kustomize/api/konfig"
 	"sigs.k8s.io/kustomize/api/krusty"

pkg/qliksense/load_cr.go

@@ -0,0 +1,60 @@
+package qliksense
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+
+	qapi "github.com/qlik-oss/sense-installer/pkg/api"
+)
+
+//
+func (q *Qliksense) LoadCr(reader io.Reader) error {
+	for _, doc := range readMultipleYamlFromReader(reader) {
+		if crName, err := q.loadCrStringIntoFileSystem(doc); err != nil {
+			return err
+		} else {
+			fmt.Println("cr name: [ " + crName + " ] has been loaded")
+		}
+	}
+	return nil
+}
+
+func (q *Qliksense) loadCrStringIntoFileSystem(crstr string) (string, error) {
+	cr, err := qapi.CreateCRObjectFromString(crstr)
+	if err != nil {
+		return "", err
+	}
+	qConfig := qapi.NewQConfig(q.QliksenseHome)
+	if qConfig.IsContextExist(cr.GetName()) {
+		return "", errors.New("Context Name: " + cr.GetName() + " already exist. please delete the existing context first using delete-context command")
+	}
+	qConfig.CreateContextDirs(cr.GetName())
+
+	if err = qapi.WriteToFile(cr, qConfig.BuildCrFilePath(cr.GetName())); err != nil {
+		return "", err
+	}
+	qConfig.AddToContexts(cr.GetName(), qConfig.BuildCrFilePath(cr.GetName()))
+	qConfig.SetCurrentContextName(cr.GetName())
+	qConfig.Write()
+	return cr.GetName(), nil
+}
+
+func readMultipleYamlFromReader(reader io.Reader) []string {
+	docs := make([]string, 0)
+	scanner := bufio.NewScanner(bufio.NewReader(reader))
+	adoc := ""
+	for scanner.Scan() {
+		s := scanner.Text()
+		if s == "---" {
+			docs = append(docs, adoc)
+			adoc = ""
+		}
+		adoc = adoc + "\n" + s
+	}
+	if adoc != "" {
+		docs = append(docs, adoc)
+	}
+	return docs
+}

pkg/qliksense/load_cr_test.go

@@ -0,0 +1,91 @@
+package qliksense
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	qapi "github.com/qlik-oss/sense-installer/pkg/api"
+)
+
+func TestLoadCrFile(t *testing.T) {
+	td := setup()
+	sampleCr := `
+apiVersion: qlik.com/v1
+kind: Qliksense
+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"`
+
+	duplicateCr := `
+apiVersion: qlik.com/v1
+kind: Qliksense
+metadata:
+  name: qlik-default
+  labels:
+    version: v0.0.2
+spec:
+  git:
+    repository: https://github.com/ffoysal/qliksense-k8s
+    accessToken: abababababababaab
+    userName: "blblbl"`
+	crFile := filepath.Join(testDir, "testcr.yaml")
+	ioutil.WriteFile(crFile, []byte(sampleCr), 0644)
+
+	dupCrFile := filepath.Join(testDir, "dupcr.yaml")
+	ioutil.WriteFile(dupCrFile, []byte(duplicateCr), 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-test")
+	if err != nil {
+		t.Log(err)
+		t.FailNow()
+	}
+	if cr.GetName() != "qlik-test" {
+		t.FailNow()
+	}
+	if qConfig.Spec.CurrentContext != "qlik-test" {
+		t.FailNow()
+	}
+	file, e = os.Open(dupCrFile)
+	if e != nil {
+		t.Log(e)
+		t.FailNow()
+	}
+	if err := q.LoadCr(file); err == nil {
+		t.FailNow()
+	}
+	td()
+}

pkg/qliksense/preflight_checks.go

@@ -0,0 +1,302 @@
+package qliksense
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"text/template"
+
+	"github.com/qlik-oss/sense-installer/pkg/api"
+)
+
+const (
+	// preflight releases have the same version
+	preflightRelease       = "v0.9.26"
+	preflightLinuxFile     = "preflight_linux_amd64.tar.gz"
+	preflightMacFile       = "preflight_darwin_amd64.tar.gz"
+	preflightWindowsFile   = "preflight_windows_amd64.zip"
+	PreflightChecksDirName = "preflight_checks"
+)
+
+var preflightBaseURL = fmt.Sprintf("https://github.com/replicatedhq/troubleshoot/releases/download/%s/", preflightRelease)
+
+const dnsCheckYAML = `
+apiVersion: troubleshoot.replicated.com/v1beta1
+kind: Preflight
+metadata:
+  name: cluster-preflight-checks
+  namespace: {{ . }}
+spec:
+  collectors:
+    - run: 
+        collectorName: spin-up-pod
+        args: ["-z", "-v", "-w 1", "qnginx001", "80"]
+        command: ["nc"]
+        image: subfuzion/netcat:latest
+        imagePullPolicy: IfNotPresent
+        name: spin-up-pod-check-dns
+        namespace: {{ . }}
+        timeout: 30s
+
+  analyzers:
+    - textAnalyze:
+        checkName: DNS check
+        collectorName: spin-up-pod-check-dns
+        fileName: spin-up-pod.txt
+        regex: succeeded
+        outcomes:
+          - fail:
+              message: DNS check failed
+          - pass:
+              message: DNS check passed
+`
+
+func (q *Qliksense) DownloadPreflight() error {
+	const preflightExecutable = "preflight"
+
+	preflightInstallDir := filepath.Join(q.QliksenseHome, PreflightChecksDirName)
+	platform := runtime.GOOS
+
+	exists, err := checkInstalled(preflightInstallDir, preflightExecutable)
+	if err != nil {
+		err = fmt.Errorf("There has been an error when trying to determine if preflight installer exists")
+		log.Println(err)
+		return err
+	}
+	if exists {
+		// preflight exist, no need to download again.
+		api.LogDebugMessage("Preflight already exist, proceeding to perform checks")
+		return nil
+	}
+
+	// Create the Preflight-check directory, download and install preflight
+	if !api.DirExists(preflightInstallDir) {
+		api.LogDebugMessage("%s does not exist, creating now\n", preflightInstallDir)
+		if err := os.Mkdir(preflightInstallDir, os.ModePerm); err != nil {
+			err = fmt.Errorf("Not able to create %s dir: %v", preflightInstallDir, err)
+			log.Println(err)
+			return nil
+		}
+	}
+	api.LogDebugMessage("Preflight-checks install Dir: %s exists", preflightInstallDir)
+
+	preflightUrl, preflightFile, err := determinePlatformSpecificUrls(platform)
+	if err != nil {
+		err = fmt.Errorf("There was an error when trying to determine platform specific paths")
+		return err
+	}
+
+	// Download Preflight
+	err = downloadAndExplode(preflightUrl, preflightInstallDir, preflightFile)
+	if err != nil {
+		return err
+	}
+	fmt.Println("Downloaded Preflight")
+
+	return nil
+}
+
+func checkInstalled(preflightInstallDir, preflightExecutable string) (bool, error) {
+	installerExists := true
+	preflightInstaller := filepath.Join(preflightInstallDir, preflightExecutable)
+	if api.DirExists(preflightInstallDir) {
+		if !api.FileExists(preflightInstaller) {
+			installerExists = false
+			api.LogDebugMessage("Preflight install directory exists, but preflight installer does not exist")
+		}
+	} else {
+		installerExists = false
+	}
+	return installerExists, nil
+}
+
+func downloadAndExplode(url, installDir, file string) error {
+	err := api.DownloadFile(url, installDir, file)
+	if err != nil {
+		return err
+	}
+	api.LogDebugMessage("Downloaded File: %s", file)
+
+	fileToUntar := filepath.Join(installDir, file)
+	api.LogDebugMessage("File to explode: %s", file)
+
+	err = api.ExplodePackage(installDir, fileToUntar)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func determinePlatformSpecificUrls(platform string) (string, string, error) {
+
+	var preflightUrl, preflightFile string
+
+	if runtime.GOARCH != `amd64` {
+		err := fmt.Errorf("%s architecture is not supported", runtime.GOARCH)
+		return "", "", err
+	}
+
+	switch platform {
+	case "windows":
+		preflightFile = preflightWindowsFile
+	case "darwin":
+		preflightFile = preflightMacFile
+	case "linux":
+		preflightFile = preflightLinuxFile
+	default:
+		err := fmt.Errorf("Unable to download the preflight executable for the underlying platform\n")
+		return "", "", err
+	}
+	preflightUrl = fmt.Sprintf("%s%s", preflightBaseURL, preflightFile)
+
+	return preflightUrl, preflightFile, nil
+}
+
+func (q *Qliksense) CheckDns() error {
+	// retrieve namespace
+	namespace := api.GetKubectlNamespace()
+	api.LogDebugMessage("Namespace here: %s", namespace)
+
+	tmpl, err := template.New("test").Parse(dnsCheckYAML)
+	if err != nil {
+		fmt.Printf("cannot parse template: %v", err)
+		return err
+	}
+	tempYaml, err := ioutil.TempFile("", "")
+	if err != nil {
+		fmt.Printf("cannot create file: %v", err)
+		return err
+	}
+	api.LogDebugMessage("Temp Yaml file: %s\n", tempYaml.Name())
+
+	b := bytes.Buffer{}
+	err = tmpl.Execute(&b, namespace)
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+
+	tempYaml.WriteString(b.String())
+
+	// creating Kubectl resources
+	appName := "qnginx001"
+	const PreflightChecksDirName = "preflight_checks"
+	const preflightFileName = "preflight"
+
+	// kubectl create deployment
+	opr := fmt.Sprintf("create deployment %s --image=nginx", appName)
+	err = initiateK8sOps(opr, namespace)
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+	api.LogDebugMessage("create deployment executed")
+
+	defer func() {
+		// Deleting deployment..
+		opr = fmt.Sprintf("delete deployment %s", appName)
+		// we want to delete the k8s resource here, we dont care a lot about an error here
+		_ = initiateK8sOps(opr, namespace)
+		api.LogDebugMessage("delete deployment executed")
+	}()
+
+	// create service
+	opr = fmt.Sprintf("create service clusterip %s --tcp=80:80", appName)
+	err = initiateK8sOps(opr, namespace)
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+	api.LogDebugMessage("create service executed")
+
+	defer func() {
+		// delete service
+		opr = fmt.Sprintf("delete service %s", appName)
+		// we want to delete the k8s resource here, we dont care a lot about an error here
+		_ = initiateK8sOps(opr, namespace)
+		api.LogDebugMessage("delete service executed")
+	}()
+
+	//kubectl -n $namespace wait --for=condition=ready pod -l app=$appName --timeout=120s
+	opr = fmt.Sprintf("wait --for=condition=ready pod -l app=%s --timeout=120s", appName)
+	err = initiateK8sOps(opr, namespace)
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+	api.LogDebugMessage("kubectl wait executed")
+
+	// call preflight
+	preflightCommand := filepath.Join(q.QliksenseHome, PreflightChecksDirName, preflightFileName)
+	trackSuccess, 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
+}
+
+func initiateK8sOps(opr, namespace string) error {
+	opr1 := strings.Fields(opr)
+	err := api.KubectlDirectOps(opr1, namespace)
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+	return nil
+}
+
+func invokePreflight(preflightCommand string, yamlFile *os.File) (bool, error) {
+	arguments := []string{}
+	arguments = append(arguments, yamlFile.Name(), "--interactive=false")
+	cmd := exec.Command(preflightCommand, arguments...)
+
+	sterrBuffer := &bytes.Buffer{}
+	cmd.Stdout = sterrBuffer
+	cmd.Stderr = sterrBuffer
+	if err := cmd.Run(); err != nil {
+		return false, fmt.Errorf("Error when running preflight command: %v\n", err)
+	}
+	ind := strings.Index(sterrBuffer.String(), "---")
+	output := sterrBuffer.String()
+	if ind > -1 {
+		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"
+	// 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
+}

pkg/qliksense/preflight_checks_test.go

@@ -0,0 +1,90 @@
+package qliksense
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_initiateK8sOps(t *testing.T) {
+	t.Skip()
+	type args struct {
+		opr       string
+		namespace string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "valid case",
+			args: args{
+				opr:       fmt.Sprintf("version"),
+				namespace: "ash-ns",
+			},
+			wantErr: false,
+		},
+		{
+			name: "invalid case",
+			args: args{
+				opr:       fmt.Sprintf("versions"),
+				namespace: "ash-ns",
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := initiateK8sOps(tt.args.opr, tt.args.namespace); (err != nil) != tt.wantErr {
+				t.Errorf("initiateK8sOps() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_determinePlatformSpecificUrls(t *testing.T) {
+	type args struct {
+		platform string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		want1   string
+		wantErr bool
+	}{
+		{
+			name: "valid platform",
+			args: args{
+				platform: "windows",
+			},
+			want:    fmt.Sprintf("%s%s", preflightBaseURL, preflightWindowsFile),
+			want1:   preflightWindowsFile,
+			wantErr: false,
+		},
+		{
+			name: "invalid platform",
+			args: args{
+				platform: "unix",
+			},
+			want:    "",
+			want1:   "",
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, got1, err := determinePlatformSpecificUrls(tt.args.platform)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("determinePlatformSpecificUrls() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("determinePlatformSpecificUrls() got = %v, want %v", got, tt.want)
+			}
+			if got1 != tt.want1 {
+				t.Errorf("determinePlatformSpecificUrls() got1 = %v, want %v", got1, tt.want1)
+			}
+		})
+	}
+}