Merge pull request #968 from kinvolk/invidian/improvements

cli/cmd: make some variable names consistent

Author: invidian

cli/cmd/cluster-apply.go

@@ -53,57 +53,57 @@ func init() {
 
 //nolint:funlen
 func runClusterApply(cmd *cobra.Command, args []string) {
-	ctxLogger := log.WithFields(log.Fields{
+	contextLogger := log.WithFields(log.Fields{
 		"command": "lokoctl cluster apply",
 		"args":    args,
 	})
 
-	ex, p, lokoConfig, assetDir := initialize(ctxLogger)
+	ex, p, lokoConfig, assetDir := initialize(contextLogger)
 
-	exists := clusterExists(ctxLogger, ex)
+	exists := clusterExists(contextLogger, ex)
 	if exists && !confirm {
 		// TODO: We could plan to a file and use it when installing.
 		if err := ex.Plan(); err != nil {
-			ctxLogger.Fatalf("Failed to reconcile cluster state: %v", err)
+			contextLogger.Fatalf("Failed to reconcile cluster state: %v", err)
 		}
 
 		if !askForConfirmation("Do you want to proceed with cluster apply?") {
-			ctxLogger.Println("Cluster apply cancelled")
+			contextLogger.Println("Cluster apply cancelled")
 
 			return
 		}
 	}
 
 	if err := p.Apply(ex); err != nil {
-		ctxLogger.Fatalf("error applying cluster: %v", err)
+		contextLogger.Fatalf("error applying cluster: %v", err)
 	}
 
 	fmt.Printf("\nYour configurations are stored in %s\n", assetDir)
 
-	kubeconfig, err := getKubeconfig(ctxLogger, lokoConfig, true)
+	kubeconfig, err := getKubeconfig(contextLogger, lokoConfig, true)
 	if err != nil {
-		ctxLogger.Fatalf("Failed to get kubeconfig: %v", err)
+		contextLogger.Fatalf("Failed to get kubeconfig: %v", err)
 	}
 
 	if err := verifyCluster(kubeconfig, p.Meta().ExpectedNodes); err != nil {
-		ctxLogger.Fatalf("Verify cluster: %v", err)
+		contextLogger.Fatalf("Verify cluster: %v", err)
 	}
 
 	// Update all the pre installed namespaces with lokomotive specific label.
 	// `lokomotive.kinvolk.io/name: <namespace_name>`.
 	if err := updateInstalledNamespaces(kubeconfig); err != nil {
-		ctxLogger.Fatalf("Updating installed namespace: %v", err)
+		contextLogger.Fatalf("Updating installed namespace: %v", err)
 	}
 
 	// Do controlplane upgrades only if cluster already exists and it is not a managed platform.
 	if exists && !p.Meta().Managed {
 		fmt.Printf("\nEnsuring that cluster controlplane is up to date.\n")
 
 		cu := controlplaneUpdater{
-			kubeconfig: kubeconfig,
-			assetDir:   assetDir,
-			ctxLogger:  *ctxLogger,
-			ex:         *ex,
+			kubeconfig:    kubeconfig,
+			assetDir:      assetDir,
+			contextLogger: *contextLogger,
+			ex:            *ex,
 		}
 
 		charts := platform.CommonControlPlaneCharts()
@@ -122,7 +122,7 @@ func runClusterApply(cmd *cobra.Command, args []string) {
 
 	if ph, ok := p.(platform.PlatformWithPostApplyHook); ok {
 		if err := ph.PostApplyHook(kubeconfig); err != nil {
-			ctxLogger.Fatalf("Running platform post install hook failed: %v", err)
+			contextLogger.Fatalf("Running platform post install hook failed: %v", err)
 		}
 	}
 
@@ -135,11 +135,11 @@ func runClusterApply(cmd *cobra.Command, args []string) {
 		componentsToApply = append(componentsToApply, component.Name)
 	}
 
-	ctxLogger.Println("Applying component configuration")
+	contextLogger.Println("Applying component configuration")
 
 	if len(componentsToApply) > 0 {
 		if err := applyComponents(lokoConfig, kubeconfig, componentsToApply...); err != nil {
-			ctxLogger.Fatalf("Applying component configuration failed: %v", err)
+			contextLogger.Fatalf("Applying component configuration failed: %v", err)
 		}
 	}
 }

cli/cmd/cluster-destroy.go

@@ -35,31 +35,31 @@ func init() {
 }
 
 func runClusterDestroy(cmd *cobra.Command, args []string) {
-	ctxLogger := log.WithFields(log.Fields{
+	contextLogger := log.WithFields(log.Fields{
 		"command": "lokoctl cluster destroy",
 		"args":    args,
 	})
 
-	ex, p, _, _ := initialize(ctxLogger)
+	ex, p, _, _ := initialize(contextLogger)
 
-	if !clusterExists(ctxLogger, ex) {
-		ctxLogger.Println("Cluster already destroyed, nothing to do")
+	if !clusterExists(contextLogger, ex) {
+		contextLogger.Println("Cluster already destroyed, nothing to do")
 
 		return
 	}
 
 	if !confirm {
 		confirmation := askForConfirmation("WARNING: This action cannot be undone. Do you really want to destroy the cluster?")
 		if !confirmation {
-			ctxLogger.Println("Cluster destroy canceled")
+			contextLogger.Println("Cluster destroy canceled")
 			return
 		}
 	}
 
 	if err := p.Destroy(ex); err != nil {
-		ctxLogger.Fatalf("error destroying cluster: %v", err)
+		contextLogger.Fatalf("error destroying cluster: %v", err)
 	}
 
-	ctxLogger.Println("Cluster destroyed successfully")
-	ctxLogger.Println("You can safely remove the assets directory now")
+	contextLogger.Println("Cluster destroyed successfully")
+	contextLogger.Println("You can safely remove the assets directory now")
 }

cli/cmd/cluster.go

@@ -43,29 +43,29 @@ func init() {
 
 // initialize does common initialization actions between cluster operations
 // and returns created objects to the caller for further use.
-func initialize(ctxLogger *logrus.Entry) (*terraform.Executor, platform.Platform, *config.Config, string) {
+func initialize(contextLogger *logrus.Entry) (*terraform.Executor, platform.Platform, *config.Config, string) {
 	lokoConfig, diags := getLokoConfig()
 	if len(diags) > 0 {
-		ctxLogger.Fatal(diags)
+		contextLogger.Fatal(diags)
 	}
 
 	p, diags := getConfiguredPlatform(lokoConfig, true)
 	if diags.HasErrors() {
 		for _, diagnostic := range diags {
-			ctxLogger.Error(diagnostic.Error())
+			contextLogger.Error(diagnostic.Error())
 		}
 
-		ctxLogger.Fatal("Errors found while loading cluster configuration")
+		contextLogger.Fatal("Errors found while loading cluster configuration")
 	}
 
 	// Get the configured backend for the cluster. Backend types currently supported: local, s3.
 	b, diags := getConfiguredBackend(lokoConfig)
 	if diags.HasErrors() {
 		for _, diagnostic := range diags {
-			ctxLogger.Error(diagnostic.Error())
+			contextLogger.Error(diagnostic.Error())
 		}
 
-		ctxLogger.Fatal("Errors found while loading cluster configuration")
+		contextLogger.Fatal("Errors found while loading cluster configuration")
 	}
 
 	// Use a local backend if no backend is configured.
@@ -75,36 +75,36 @@ func initialize(ctxLogger *logrus.Entry) (*terraform.Executor, platform.Platform
 
 	assetDir, err := homedir.Expand(p.Meta().AssetDir)
 	if err != nil {
-		ctxLogger.Fatalf("Error expanding path: %v", err)
+		contextLogger.Fatalf("Error expanding path: %v", err)
 	}
 
 	// Validate backend configuration.
 	if err = b.Validate(); err != nil {
-		ctxLogger.Fatalf("Failed to validate backend configuration: %v", err)
+		contextLogger.Fatalf("Failed to validate backend configuration: %v", err)
 	}
 
-	ex := initializeTerraform(ctxLogger, p, b)
+	ex := initializeTerraform(contextLogger, p, b)
 
 	return ex, p, lokoConfig, assetDir
 }
 
 // initializeTerraform initialized Terraform directory using given backend and platform
 // and returns configured executor.
-func initializeTerraform(ctxLogger *logrus.Entry, p platform.Platform, b backend.Backend) *terraform.Executor {
+func initializeTerraform(contextLogger *logrus.Entry, p platform.Platform, b backend.Backend) *terraform.Executor {
 	assetDir, err := homedir.Expand(p.Meta().AssetDir)
 	if err != nil {
-		ctxLogger.Fatalf("Error expanding path: %v", err)
+		contextLogger.Fatalf("Error expanding path: %v", err)
 	}
 
 	// Render backend configuration.
 	renderedBackend, err := b.Render()
 	if err != nil {
-		ctxLogger.Fatalf("Failed to render backend configuration file: %v", err)
+		contextLogger.Fatalf("Failed to render backend configuration file: %v", err)
 	}
 
 	// Configure Terraform directory, module and backend.
 	if err := terraform.Configure(assetDir, renderedBackend); err != nil {
-		ctxLogger.Fatalf("Failed to configure Terraform : %v", err)
+		contextLogger.Fatalf("Failed to configure Terraform : %v", err)
 	}
 
 	conf := terraform.Config{
@@ -114,15 +114,15 @@ func initializeTerraform(ctxLogger *logrus.Entry, p platform.Platform, b backend
 
 	ex, err := terraform.NewExecutor(conf)
 	if err != nil {
-		ctxLogger.Fatalf("Failed to create Terraform executor: %v", err)
+		contextLogger.Fatalf("Failed to create Terraform executor: %v", err)
 	}
 
 	if err := p.Initialize(ex); err != nil {
-		ctxLogger.Fatalf("Failed to initialize Platform: %v", err)
+		contextLogger.Fatalf("Failed to initialize Platform: %v", err)
 	}
 
 	if err := ex.Init(); err != nil {
-		ctxLogger.Fatalf("Failed to initialize Terraform: %v", err)
+		contextLogger.Fatalf("Failed to initialize Terraform: %v", err)
 	}
 
 	return ex
@@ -131,21 +131,21 @@ func initializeTerraform(ctxLogger *logrus.Entry, p platform.Platform, b backend
 // clusterExists determines if cluster has already been created by getting all
 // outputs from the Terraform. If there is any output defined, it means 'terraform apply'
 // run at least once.
-func clusterExists(ctxLogger *logrus.Entry, ex *terraform.Executor) bool {
+func clusterExists(contextLogger *logrus.Entry, ex *terraform.Executor) bool {
 	o := map[string]interface{}{}
 
 	if err := ex.Output("", &o); err != nil {
-		ctxLogger.Fatalf("Failed to check if cluster exists: %v", err)
+		contextLogger.Fatalf("Failed to check if cluster exists: %v", err)
 	}
 
 	return len(o) != 0
 }
 
 type controlplaneUpdater struct {
-	kubeconfig []byte
-	assetDir   string
-	ctxLogger  logrus.Entry
-	ex         terraform.Executor
+	kubeconfig    []byte
+	assetDir      string
+	contextLogger logrus.Entry
+	ex            terraform.Executor
 }
 
 func (c controlplaneUpdater) getControlplaneChart(name string) (*chart.Chart, error) {
@@ -176,29 +176,29 @@ func (c controlplaneUpdater) getControlplaneValues(name string) (map[string]inte
 }
 
 func (c controlplaneUpdater) upgradeComponent(component, namespace string) {
-	ctxLogger := c.ctxLogger.WithFields(logrus.Fields{
+	contextLogger := c.contextLogger.WithFields(logrus.Fields{
 		"action":    "controlplane-upgrade",
 		"component": component,
 	})
 
 	actionConfig, err := util.HelmActionConfig(namespace, c.kubeconfig)
 	if err != nil {
-		ctxLogger.Fatalf("Failed initializing helm: %v", err)
+		contextLogger.Fatalf("Failed initializing helm: %v", err)
 	}
 
 	helmChart, err := c.getControlplaneChart(component)
 	if err != nil {
-		ctxLogger.Fatalf("Loading chart from assets failed: %v", err)
+		contextLogger.Fatalf("Loading chart from assets failed: %v", err)
 	}
 
 	values, err := c.getControlplaneValues(component)
 	if err != nil {
-		ctxLogger.Fatalf("Failed to get kubernetes values.yaml from Terraform: %v", err)
+		contextLogger.Fatalf("Failed to get kubernetes values.yaml from Terraform: %v", err)
 	}
 
 	exists, err := util.ReleaseExists(*actionConfig, component)
 	if err != nil {
-		ctxLogger.Fatalf("Failed checking if controlplane component is installed: %v", err)
+		contextLogger.Fatalf("Failed checking if controlplane component is installed: %v", err)
 	}
 
 	if !exists {
@@ -213,7 +213,7 @@ func (c controlplaneUpdater) upgradeComponent(component, namespace string) {
 		if _, err := install.Run(helmChart, values); err != nil {
 			fmt.Println("Failed!")
 
-			ctxLogger.Fatalf("Installing controlplane component failed: %v", err)
+			contextLogger.Fatalf("Installing controlplane component failed: %v", err)
 		}
 
 		fmt.Println("Done.")
@@ -228,7 +228,7 @@ func (c controlplaneUpdater) upgradeComponent(component, namespace string) {
 	if _, err := update.Run(component, helmChart, values); err != nil {
 		fmt.Println("Failed!")
 
-		ctxLogger.Fatalf("Updating chart failed: %v", err)
+		contextLogger.Fatalf("Updating chart failed: %v", err)
 	}
 
 	fmt.Println("Done.")

cli/cmd/component-delete.go

@@ -62,7 +62,7 @@ func runDelete(cmd *cobra.Command, args []string) {
 		log.SetLevel(log.DebugLevel)
 	}
 
-	lokoCfg, diags := getLokoConfig()
+	lokoConfig, diags := getLokoConfig()
 	if len(diags) > 0 {
 		contextLogger.Fatal(diags)
 	}
@@ -71,9 +71,9 @@ func runDelete(cmd *cobra.Command, args []string) {
 	copy(componentsToDelete, args)
 
 	if len(args) == 0 {
-		componentsToDelete = make([]string, len(lokoCfg.RootConfig.Components))
+		componentsToDelete = make([]string, len(lokoConfig.RootConfig.Components))
 
-		for i, component := range lokoCfg.RootConfig.Components {
+		for i, component := range lokoConfig.RootConfig.Components {
 			componentsToDelete[i] = component.Name
 		}
 	}
@@ -99,7 +99,7 @@ func runDelete(cmd *cobra.Command, args []string) {
 		return
 	}
 
-	kubeconfig, err := getKubeconfig(contextLogger, lokoCfg, false)
+	kubeconfig, err := getKubeconfig(contextLogger, lokoConfig, false)
 	if err != nil {
 		contextLogger.Debugf("Error in finding kubeconfig file: %s", err)
 		contextLogger.Fatal("Suitable kubeconfig file not found. Did you run 'lokoctl cluster apply' ?")

cli/cmd/document/main.go

@@ -32,15 +32,15 @@ func init() {
 }
 
 func runDocument(docCmd *cobra.Command, args []string) {
-	ctxLogger := log.WithFields(log.Fields{
+	contextLogger := log.WithFields(log.Fields{
 		"command": "go run cli/cmd/document/main.go",
 		"args":    args,
 	})
 
 	err := doc.GenMarkdownTree(cmd.RootCmd, args[0])
 	if err != nil {
-		ctxLogger.Fatalf("Failed to generate markdown documentation: %v", err)
+		contextLogger.Fatalf("Failed to generate markdown documentation: %v", err)
 	}
 
-	ctxLogger.Printf("Markdown documentation written to %s\n", args[0])
+	contextLogger.Printf("Markdown documentation written to %s\n", args[0])
 }