cp: call tf init during cp up only, with creds

Author: Mate Ory

internal/cli/command/controlplane/init.go

@@ -16,7 +16,6 @@ package controlplane
 
 import (
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -29,7 +28,6 @@ import (
 	"github.com/banzaicloud/banzai-cli/internal/cli/input"
 	"github.com/banzaicloud/banzai-cli/internal/cli/utils"
 	"github.com/google/uuid"
-	json "github.com/json-iterator/go"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"gopkg.in/yaml.v2"
@@ -407,12 +405,6 @@ func runInit(options initOptions, banzaiCli cli.Cli) error {
 
 	out["installer"] = installer
 
-	err = initStateBackend(options.cpContext, out)
-
-	if err != nil {
-		return err
-	}
-
 	return options.writeValues(out)
 }
 
@@ -446,45 +438,6 @@ func initImageValues(options initOptions, out map[string]interface{}) (image str
 	return image, tag
 }
 
-func initStateBackend(options *cpContext, values map[string]interface{}) error {
-	var stateData []byte
-
-	if stateValues, ok := values["state"]; ok {
-		var err error
-		stateData, err = json.MarshalIndent(stateValues, "", "  ")
-		if err != nil {
-			return errors.WrapIf(err, "failed to marshal state backend configuration")
-		}
-	} else {
-		stateData = []byte(fmt.Sprintf(localStateBackend, tfstateFilename))
-	}
-
-	err := ioutil.WriteFile(options.workspace+"/state.tf.json", stateData, 0600)
-	if err != nil {
-		return errors.WrapIf(err, "failed to create state backend configuration")
-	}
-
-	err = os.MkdirAll(options.workspace+"/.terraform", 0700)
-	if err != nil {
-		return errors.WrapIf(err, "failed to create state backend directory")
-	}
-
-	stateFile, err := os.Create(options.workspace + "/.terraform/terraform.tfstate")
-	if err != nil {
-		return errors.WrapIf(err, "failed to create state config file")
-	}
-	_ = stateFile.Close()
-
-	if err := runTerraform("init", options, nil); err != nil {
-		return errors.WrapIf(err, "failed to init state backend")
-	}
-
-	// remove old state.tf if any
-	_ = os.Remove(options.workspace + "/state.tf")
-
-	return nil
-}
-
 func getAmazonCredentialsRegion(defaultAwsRegion string) (string, string, error) {
 	id, region, _, err := input.GetAmazonCredentialsRegion("")
 	if err != nil {

internal/cli/command/controlplane/up.go

@@ -16,9 +16,11 @@ package controlplane
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net"
+	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
@@ -130,10 +132,6 @@ func runUp(options *createOptions, banzaiCli cli.Cli) error {
 		return errors.New("workspace is already initialized but a different --provider is specified")
 	}
 
-	if err := initStateBackend(options.cpContext, values); err != nil {
-		return err
-	}
-
 	source := "/export"
 	var defaultValues map[string]interface{}
 	exportHandlers := []ExportedFilesHandler{
@@ -146,7 +144,34 @@ func runUp(options *createOptions, banzaiCli cli.Cli) error {
 		return err
 	}
 
-	var env map[string]string
+	env := make(map[string]string)
+
+	switch values["provider"] {
+	case providerCustom:
+		if pc, ok := values["providerConfig"]; ok {
+			pc := cast.ToStringMap(pc)
+			if _, ok := pc["accessKey"]; ok { // if using aws key
+				_, creds, err := input.GetAmazonCredentials()
+				if err != nil {
+					return errors.WrapIf(err, "failed to get AWS credentials")
+				}
+				env = creds
+			}
+		}
+	case providerEc2:
+		_, creds, err := input.GetAmazonCredentials()
+		if err != nil {
+			return errors.WrapIf(err, "failed to get AWS credentials")
+		}
+		env = creds
+	}
+
+	if options.terraformInit {
+		if err := initStateBackend(options.cpContext, values, env); err != nil {
+			return errors.WrapIf(err, "failed to initialize state backend")
+		}
+	}
+
 	switch values["provider"] {
 	case providerPke:
 		err := ensurePKECluster(banzaiCli, options.cpContext)
@@ -161,37 +186,19 @@ func runUp(options *createOptions, banzaiCli cli.Cli) error {
 		}
 
 	case providerEc2:
-		_, creds, err := input.GetAmazonCredentials()
-		if err != nil {
-			return errors.WrapIf(err, "failed to get AWS credentials")
-		}
-
 		useGeneratedKey := true
 		if pc, ok := values["providerConfig"]; ok {
 			if pc, ok := pc.(map[string]interface{}); ok {
 				useGeneratedKey = pc["key_name"] != nil && pc["key_name"] != ""
 			}
 		}
 
-		if err := ensureEC2Cluster(options.cpContext, creds, useGeneratedKey); err != nil {
+		if err := ensureEC2Cluster(options.cpContext, env, useGeneratedKey); err != nil {
 			return errors.WrapIf(err, "failed to create EC2 cluster")
 		}
-		env = creds
 
 	case providerCustom:
-		creds := map[string]string{}
-		if pc, ok := values["providerConfig"]; ok {
-			pc := cast.ToStringMap(pc)
-			if _, ok := pc["accessKey"]; ok {
-				_, awsCreds, err := input.GetAmazonCredentials()
-				if err != nil {
-					return errors.WrapIf(err, "failed to get AWS credentials")
-				}
-				creds = awsCreds
-			}
-		}
-
-		if err := ensureCustomCluster(options.cpContext, creds); err != nil {
+		if err := ensureCustomCluster(options.cpContext, env); err != nil {
 			return errors.WrapIf(err, "failed to create Custom infrastructure")
 		}
 
@@ -202,16 +209,6 @@ func runUp(options *createOptions, banzaiCli cli.Cli) error {
 	}
 
 	log.Info("Deploying Banzai Cloud Pipeline to Kubernetes cluster...")
-	if values["provider"] == providerCustom {
-		_, creds, err := input.GetAmazonCredentials()
-		if err != nil {
-			return errors.WrapIf(err, "failed to get AWS credentials")
-		}
-		env = map[string]string{}
-		for k, v := range creds {
-			env[k] = v
-		}
-	}
 
 	if err := runTerraform("apply", options.cpContext, env); err != nil {
 		return errors.WrapIf(err, "failed to deploy pipeline components")
@@ -332,6 +329,65 @@ func imageFileExists(options *cpContext, source string) (bool, error) {
 	}
 }
 
+func stringifyMap(m interface{}) interface{} {
+	switch v := m.(type) {
+	case map[string]interface{}:
+		out := make(map[string]interface{})
+		for k, v := range v {
+			out[k] = stringifyMap(v)
+		}
+		return out
+	case map[interface{}]interface{}:
+		out := make(map[string]interface{})
+		for k, v := range v {
+			out[fmt.Sprint(k)] = stringifyMap(v)
+		}
+		return out
+	default:
+		return v
+	}
+}
+
+func initStateBackend(options *cpContext, values map[string]interface{}, env map[string]string) error {
+	var stateData []byte
+
+	if stateValues, ok := values["state"]; ok {
+		values := stringifyMap(stateValues)
+		var err error
+		stateData, err = json.MarshalIndent(values, "", "  ")
+		if err != nil {
+			return errors.WrapIf(err, "failed to marshal state backend configuration")
+		}
+	} else {
+		stateData = []byte(fmt.Sprintf(localStateBackend, tfstateFilename))
+	}
+
+	err := ioutil.WriteFile(options.workspace+"/state.tf.json", stateData, 0600)
+	if err != nil {
+		return errors.WrapIf(err, "failed to create state backend configuration")
+	}
+
+	err = os.MkdirAll(options.workspace+"/.terraform", 0700)
+	if err != nil {
+		return errors.WrapIf(err, "failed to create state backend directory")
+	}
+
+	stateFile, err := os.Create(options.workspace + "/.terraform/terraform.tfstate")
+	if err != nil {
+		return errors.WrapIf(err, "failed to create state config file")
+	}
+	_ = stateFile.Close()
+
+	if err := runTerraform("init", options, env); err != nil {
+		return errors.WrapIf(err, "failed to init state backend")
+	}
+
+	// remove old state.tf if any
+	_ = os.Remove(options.workspace + "/state.tf")
+
+	return nil
+}
+
 func defaultValuesExporter(source string, defaultValues *map[string]interface{}) ExportedFilesHandler {
 	return ExportedFilesHandler(func(files map[string][]byte) error {
 		if valuesFileContent, ok := files[source]; ok {