minor change

cmd/qliksense/apply.go

@@ -1,45 +1,74 @@
 package main
 
 import (
+	"bytes"
+	"errors"
+	"fmt"
+
+	qapi "github.com/qlik-oss/sense-installer/pkg/api"
+
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 	"github.com/spf13/cobra"
 )
 
 func applyCmd(q *qliksense.Qliksense) *cobra.Command {
-	opts := &qliksense.InstallCommandOptions{
-		CleanPatchFiles: true,
-	}
+	opts := &qliksense.InstallCommandOptions{}
 	filePath := ""
+	cleanPatchFiles, pull, push := true, 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 apply(q, cmd, opts)
+			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, cleanPatchFiles, true, pull, push)
+				}
+			})
 		},
 	}
 
 	f := c.Flags()
 	f.StringVarP(&filePath, "file", "f", "", "Install from a CR file")
+	c.MarkFlagRequired("file")
 	f.StringVarP(&opts.StorageClass, "storageClass", "s", "", "Storage class for qliksense")
 	f.StringVarP(&opts.MongodbUri, "mongodbUri", "m", "", "mongodbUri for qliksense (i.e. mongodb://qlik-default-mongodb:27017/qliksense?ssl=false)")
 	f.StringVarP(&opts.RotateKeys, "rotateKeys", "r", "", "Rotate JWT keys for qliksense (yes:rotate keys/ no:use exising keys from cluster/ None: use default EJSON_KEY from env")
-	f.BoolVar(&opts.CleanPatchFiles, cleanPatchFilesFlagName, opts.CleanPatchFiles, cleanPatchFilesFlagUsage)
-	f.BoolVarP(&opts.Pull, pullFlagName, pullFlagShorthand, opts.Pull, pullFlagUsage)
-	f.BoolVarP(&opts.Push, pushFlagName, pushFlagShorthand, opts.Push, pushFlagUsage)
-	f.StringVarP(&opts.AcceptEULA, "acceptEULA", "a", opts.AcceptEULA, "Accept EULA for qliksense")
+	f.BoolVar(&cleanPatchFiles, cleanPatchFilesFlagName, cleanPatchFiles, cleanPatchFilesFlagUsage)
+	f.BoolVarP(&pull, pullFlagName, pullFlagShorthand, pull, pullFlagUsage)
+	f.BoolVarP(&push, pushFlagName, pushFlagShorthand, push, pushFlagUsage)
+
+	eulaPreRunHooks.addValidator(fmt.Sprintf("%v %v", rootCommandName, c.Name()), loadOrApplyCommandEulaPreRunHook)
 
-	if err := c.MarkFlagRequired("file"); err != nil {
-		panic(err)
-	}
 	return c
 }
 
-func apply(q *qliksense.Qliksense, cmd *cobra.Command, opts *qliksense.InstallCommandOptions) error {
-	if crBytes, err := getCrBytesFromFileFlag(cmd); err != nil {
-		return err
+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 {
-		return q.ApplyCRFromBytes(crBytes, opts, true)
+		cr.SetEULA("yes")
+		if crBytesWithEula, err := qapi.K8sToYaml(cr); err != nil {
+			return nil, nil, err
+		} else {
+			return cr, crBytesWithEula, nil
+		}
 	}
 }

cmd/qliksense/eula.go

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

cmd/qliksense/install.go

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

cmd/qliksense/load.go

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

cmd/qliksense/pull_push.go

@@ -1,6 +1,9 @@
 package main
 
 import (
+	"errors"
+
+	qapi "github.com/qlik-oss/sense-installer/pkg/api"
 	"github.com/qlik-oss/sense-installer/pkg/qliksense"
 	"github.com/spf13/cobra"
 )
@@ -31,8 +34,22 @@ 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 {
-			return q.PushImagesForCurrentCR()
+			if err := ensureImageRegistrySetInCR(q); err != nil {
+				return err
+			} else {
+				return q.PushImagesForCurrentCR()
+			}
 		},
 	}
 	return cmd
 }
+
+func ensureImageRegistrySetInCR(q *qliksense.Qliksense) error {
+	qConfig := qapi.NewQConfig(q.QliksenseHome)
+	if qcr, err := qConfig.GetCurrentCR(); err != nil {
+		return err
+	} else if registry := qcr.Spec.GetImageRegistry(); registry == "" {
+		return errors.New("no image registry set in the CR; to set it use: qliksense config set-image-registry")
+	}
+	return nil
+}

cmd/qliksense/root.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"io"
 	"log"
 	"os"
 	"path/filepath"
@@ -105,6 +106,7 @@ func getRootCmd(p *qliksense.Qliksense) *cobra.Command {
 		Args:  cobra.ArbitraryArgs,
 		PersistentPreRun: func(cmd *cobra.Command, args []string) {
 			if commandUsesContext(cmd.CommandPath()) {
+				globalEulaPreRun(cmd, p)
 				if err := p.SetUpQliksenseDefaultContext(); err != nil {
 					panic(err)
 				}
@@ -112,10 +114,25 @@ func getRootCmd(p *qliksense.Qliksense) *cobra.Command {
 				if err := pf.Initialize(); err != nil {
 					panic(err)
 				}
+				globalEulaPostRun(cmd, p)
+			}
+		},
+		PersistentPostRun: func(cmd *cobra.Command, args []string) {
+			if commandUsesContext(cmd.CommandPath()) {
+				globalEulaPostRun(cmd, p)
 			}
 		},
 		SilenceUsage: true,
 	}
+	origHelpFunc := cmd.HelpFunc()
+	cmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
+		if !commandUsesContext(cmd.CommandPath()) {
+			cmd.Flags().MarkHidden("acceptEULA")
+		}
+		origHelpFunc(cmd, args)
+	})
+	accept := ""
+	cmd.PersistentFlags().StringVarP(&accept, "acceptEULA", "a", "", "Accept EULA for qliksense")
 	cmd.Flags().SetInterspersed(false)
 	return cmd
 }
@@ -223,6 +240,34 @@ func rootCmd(p *qliksense.Qliksense) *cobra.Command {
 	return cmd
 }
 
+func copy(src, dst string) (int64, error) {
+	var (
+		source, destination *os.File
+		sourceFileStat      os.FileInfo
+		err                 error
+		nBytes              int64
+	)
+	if sourceFileStat, err = os.Stat(src); err != nil {
+		return 0, err
+	}
+
+	if !sourceFileStat.Mode().IsRegular() {
+		return 0, fmt.Errorf("%s is not a regular file", src)
+	}
+
+	if source, err = os.Open(src); err != nil {
+		return 0, err
+	}
+	defer source.Close()
+
+	if destination, err = os.Create(dst); err != nil {
+		return 0, err
+	}
+	defer destination.Close()
+	nBytes, err = io.Copy(destination, source)
+	return nBytes, err
+}
+
 func levenstein(cmd *cobra.Command) {
 	cmd.SuggestionsMinimumDistance = 2
 	if len(os.Args) > 1 {

go.mod

@@ -10,7 +10,7 @@ replace (
 	k8s.io/client-go => k8s.io/client-go v0.17.0
 	k8s.io/kubectl => k8s.io/kubectl v0.0.0-20191219154910-1528d4eea6dd
 
-	sigs.k8s.io/kustomize/api => github.com/qlik-oss/kustomize/api v0.3.3-0.20200612023448-4c1f2f38ea9b
+	sigs.k8s.io/kustomize/api => github.com/qlik-oss/kustomize/api v0.3.3-0.20200604192606-17370c1af57b
 )
 
 require (

go.sum

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

pkg/qliksense/apply.go

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

pkg/qliksense/docker.go

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

pkg/qliksense/install.go

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

pkg/qliksense/install_test.go

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

pkg/qliksense/load_cr.go

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

pkg/qliksense/load_cr_test.go

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