replace v7 push manifest interpolation with manifestparser interpolation

- Since the push needs more information from the manifest than the raw
bytes, the manifestparser.Parser will be used to store and transport
that data to Conceptualize.

[#162558994]

Signed-off-by: Supraja Narasimhan <[email protected]>

Author: XenoPhex

command/translatableerror/convert_to_translatable_error.go

@@ -12,6 +12,7 @@ import (
 	"code.cloudfoundry.org/cli/util/clissh/ssherror"
 	"code.cloudfoundry.org/cli/util/download"
 	"code.cloudfoundry.org/cli/util/manifest"
+	"code.cloudfoundry.org/cli/util/manifestparser"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -196,6 +197,12 @@ func ConvertToTranslatableError(err error) error {
 	case manifest.InterpolationError:
 		return InterpolationError(e)
 
+	// ManifestParser Errors
+	case manifestparser.InterpolationError:
+		return InterpolationError(e)
+	case manifestparser.InvalidYAMLError:
+		return InvalidYAMLError(e)
+
 	// Plugin Execution Errors
 	case pluginerror.RawHTTPStatusError:
 		return DownloadPluginHTTPError{Message: e.Status}

command/translatableerror/convert_to_translatable_error_test.go

@@ -13,6 +13,7 @@ import (
 	"code.cloudfoundry.org/cli/util/clissh/ssherror"
 	"code.cloudfoundry.org/cli/util/download"
 	"code.cloudfoundry.org/cli/util/manifest"
+	"code.cloudfoundry.org/cli/util/manifestparser"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/ginkgo/extensions/table"
 	. "github.com/onsi/gomega"
@@ -394,6 +395,14 @@ var _ = Describe("ConvertToTranslatableError", func() {
 			manifest.InterpolationError{Err: errors.New("an-error")},
 			InterpolationError{Err: errors.New("an-error")}),
 
+		Entry("manifestparser.InterpolationError -> InterpolationError",
+			manifestparser.InterpolationError{Err: errors.New("an-error")},
+			InterpolationError{Err: errors.New("an-error")}),
+
+		Entry("manifestparser.InvalidYAMLError -> InvalidYAMLError",
+			manifestparser.InvalidYAMLError{Err: errors.New("an-error")},
+			InvalidYAMLError{Err: errors.New("an-error")}),
+
 		// Plugin Errors
 		Entry("pluginerror.RawHTTPStatusError -> DownloadPluginHTTPError",
 			pluginerror.RawHTTPStatusError{Status: "some status"},

command/translatableerror/invalid_yaml_error.go

@@ -0,0 +1,15 @@
+package translatableerror
+
+type InvalidYAMLError struct {
+	Err error
+}
+
+func (e InvalidYAMLError) Error() string {
+	return "The option --vars-file expects a valid YAML file. {{.ErrorMessage}}"
+}
+
+func (e InvalidYAMLError) Translate(translate func(string, ...interface{}) string) string {
+	return translate(e.Error(), map[string]interface{}{
+		"ErrorMessage": e.Err.Error(),
+	})
+}

command/v7/push_command.go

@@ -15,7 +15,7 @@ import (
 	"code.cloudfoundry.org/cli/command/translatableerror"
 	v6shared "code.cloudfoundry.org/cli/command/v6/shared"
 	"code.cloudfoundry.org/cli/command/v7/shared"
-	"code.cloudfoundry.org/cli/util/manifest"
+	"code.cloudfoundry.org/cli/util/manifestparser"
 	"code.cloudfoundry.org/cli/util/progressbar"
 
 	"github.com/cloudfoundry/bosh-cli/director/template"
@@ -125,6 +125,13 @@ func (cmd PushCommand) Execute(args []string) error {
 		return err
 	}
 
+	var manifest []byte
+	if !cmd.NoManifest {
+		if manifest, err = cmd.readManifest(); err != nil {
+			return err
+		}
+	}
+
 	overrides, err := cmd.GetFlagOverrides()
 	if err != nil {
 		return err
@@ -144,13 +151,6 @@ func (cmd PushCommand) Execute(args []string) error {
 
 	cmd.UI.DisplayText("Getting app info...")
 
-	var manifest []byte
-	if !cmd.NoManifest {
-		if manifest, err = cmd.readManifest(); err != nil {
-			return err
-		}
-	}
-
 	log.Info("generating the app state")
 	pushState, warnings, err := cmd.Actor.Conceptualize(
 		cmd.RequiredArgs.AppName,
@@ -350,22 +350,26 @@ func (cmd PushCommand) readManifest() ([]byte, error) {
 		pathsToVarsFiles = append(pathsToVarsFiles, string(varfilepath))
 	}
 
+	parser := manifestparser.NewParser()
+
 	if len(cmd.PathToManifest) != 0 {
 		log.WithField("manifestPath", cmd.PathToManifest).Debug("reading '-f' provided manifest")
-		return manifest.ReadAndInterpolateRawManifest(string(cmd.PathToManifest), pathsToVarsFiles, cmd.Vars)
+		err := parser.InterpolateAndParse(string(cmd.PathToManifest), pathsToVarsFiles, cmd.Vars)
+		return parser.FullRawManifest(), err
 	}
 
 	pathToManifest := filepath.Join(cmd.PWD, "manifest.yml")
 	log.WithField("manifestPath", pathToManifest).Debug("path to manifest")
 
-	interpolatedManifest, err := manifest.ReadAndInterpolateRawManifest(pathToManifest, pathsToVarsFiles, cmd.Vars)
+	err := parser.InterpolateAndParse(pathToManifest, pathsToVarsFiles, cmd.Vars)
 	if err != nil && !os.IsNotExist(err) {
 		log.Errorln("reading manifest:", err)
 		return nil, err
 	} else if os.IsNotExist(err) {
 		log.Debug("no manifest exists")
 	}
-	return interpolatedManifest, nil
+
+	return parser.FullRawManifest(), nil
 }
 
 func (cmd PushCommand) GetFlagOverrides() (v7pushaction.FlagOverrides, error) {

command/v7/push_command_test.go

@@ -243,7 +243,7 @@ var _ = Describe("push Command", func() {
 						var yamlContents []byte
 
 						BeforeEach(func() {
-							yamlContents = []byte(`---\n- banana`)
+							yamlContents = []byte("---\napplications:\n- name: banana")
 							pathToYAMLFile := filepath.Join(tempDir, "manifest.yml")
 							err := ioutil.WriteFile(pathToYAMLFile, yamlContents, 0644)
 							Expect(err).ToNot(HaveOccurred())
@@ -284,7 +284,7 @@ var _ = Describe("push Command", func() {
 						var yamlContents []byte
 
 						BeforeEach(func() {
-							yamlContents = []byte(`---\n- banana`)
+							yamlContents = []byte("---\napplications:\n- name: banana")
 							pathToYAMLFile := filepath.Join(tempDir, "manifest.yml")
 							err := ioutil.WriteFile(pathToYAMLFile, yamlContents, 0644)
 							Expect(err).ToNot(HaveOccurred())
@@ -313,11 +313,11 @@ var _ = Describe("push Command", func() {
 				When("--vars-files are specified", func() {
 					var yamlContents []byte
 					var varFileContents []byte
-					var interpolatedManifest []byte
+					var expectedManifest []byte
 
 					BeforeEach(func() {
-						interpolatedManifest = yamlUnmarshalMarshal([]byte("---\n- var: turtle"))
-						yamlContents = []byte("---\n- var: ((put-var-here))")
+						expectedManifest = yamlUnmarshalMarshal([]byte("---\napplications:\n- name: turtle"))
+						yamlContents = []byte("---\napplications:\n- name: ((put-var-here))")
 						pathToYAMLFile := filepath.Join(tempDir, "manifest.yml")
 						err := ioutil.WriteFile(pathToYAMLFile, yamlContents, 0644)
 						Expect(err).ToNot(HaveOccurred())
@@ -336,17 +336,17 @@ var _ = Describe("push Command", func() {
 						Expect(executeErr).ToNot(HaveOccurred())
 						Expect(fakeActor.ConceptualizeCallCount()).To(Equal(1))
 						_, _, _, _, _, manifest := fakeActor.ConceptualizeArgsForCall(0)
-						Expect(manifest).To(Equal(interpolatedManifest))
+						Expect(manifest).To(Equal(expectedManifest))
 					})
 				})
 
 				When("The --var flag is provided", func() {
 					var yamlContents []byte
-					var interpolatedManifest []byte
+					var expectedManifest []byte
 
 					BeforeEach(func() {
-						interpolatedManifest = yamlUnmarshalMarshal([]byte("---\n- var: turtle"))
-						yamlContents = []byte("---\n- var: ((put-var-here))")
+						expectedManifest = yamlUnmarshalMarshal([]byte("---\napplications:\n- name: turtle"))
+						yamlContents = []byte("---\napplications:\n- name: ((put-var-here))")
 						pathToYAMLFile := filepath.Join(tempDir, "manifest.yml")
 						err := ioutil.WriteFile(pathToYAMLFile, yamlContents, 0644)
 						Expect(err).ToNot(HaveOccurred())
@@ -360,7 +360,7 @@ var _ = Describe("push Command", func() {
 						Expect(executeErr).ToNot(HaveOccurred())
 						Expect(fakeActor.ConceptualizeCallCount()).To(Equal(1))
 						_, _, _, _, _, manifest := fakeActor.ConceptualizeArgsForCall(0)
-						Expect(manifest).To(Equal(interpolatedManifest))
+						Expect(manifest).To(Equal(expectedManifest))
 					})
 				})
 			})

util/manifestparser/application.go

@@ -0,0 +1,5 @@
+package manifestparser
+
+type Application struct {
+	Name string `yaml:"name"`
+}

util/manifestparser/interpolation_error.go

@@ -0,0 +1,14 @@
+package manifestparser
+
+import (
+	"fmt"
+	"strings"
+)
+
+type InterpolationError struct {
+	Err error
+}
+
+func (e InterpolationError) Error() string {
+	return fmt.Sprint(strings.Replace(e.Err.Error(), "\n", ", ", -1))
+}

util/manifestparser/invalid_yaml_error.go

@@ -0,0 +1,11 @@
+package manifestparser
+
+import "fmt"
+
+type InvalidYAMLError struct {
+	Err error
+}
+
+func (e InvalidYAMLError) Error() string {
+	return fmt.Sprintf("The option --vars-file expects a valid YAML file. %s", e.Err)
+}

util/manifestparser/parser.go

@@ -4,13 +4,10 @@ import (
 	"errors"
 	"io/ioutil"
 
+	"github.com/cloudfoundry/bosh-cli/director/template"
 	yaml "gopkg.in/yaml.v2"
 )
 
-type Application struct {
-	Name string `yaml:"name"`
-}
-
 type Parser struct {
 	PathToManifest string
 
@@ -28,30 +25,50 @@ func (parser *Parser) Parse(manifestPath string) error {
 	if err != nil {
 		return err
 	}
-	parser.rawManifest = bytes
-
-	var raw struct {
-		Applications []Application `yaml:"applications"`
-	}
+	return parser.parse(bytes)
+}
 
-	err = yaml.Unmarshal(bytes, &raw)
+// InterpolateAndParse reads the manifest at the provided paths, interpolates
+// variables if a vars file is provided, and sets the current manifest to the
+// resulting manifest.
+func (parser *Parser) InterpolateAndParse(pathToManifest string, pathsToVarsFiles []string, vars []template.VarKV) error {
+	rawManifest, err := ioutil.ReadFile(pathToManifest)
 	if err != nil {
 		return err
 	}
 
-	parser.Applications = raw.Applications
+	tpl := template.NewTemplate(rawManifest)
+	fileVars := template.StaticVariables{}
 
-	if len(parser.Applications) == 0 {
-		return errors.New("must have at least one application")
-	}
+	for _, path := range pathsToVarsFiles {
+		rawVarsFile, ioerr := ioutil.ReadFile(path)
+		if ioerr != nil {
+			return ioerr
+		}
 
-	for _, application := range parser.Applications {
-		if application.Name == "" {
-			return errors.New("Found an application with no name specified")
+		var sv template.StaticVariables
+
+		err = yaml.Unmarshal(rawVarsFile, &sv)
+		if err != nil {
+			return InvalidYAMLError{Err: err}
+		}
+
+		for k, v := range sv {
+			fileVars[k] = v
 		}
 	}
 
-	return nil
+	for _, kv := range vars {
+		fileVars[kv.Name] = kv.Value
+	}
+
+	rawManifest, err = tpl.Evaluate(fileVars, nil, template.EvaluateOpts{ExpectAllKeys: true})
+	if err != nil {
+		return InterpolationError{Err: err}
+	}
+
+	parser.PathToManifest = pathToManifest
+	return parser.parse(rawManifest)
 }
 
 func (parser Parser) AppNames() []string {
@@ -62,6 +79,37 @@ func (parser Parser) AppNames() []string {
 	return names
 }
 
+func (parser Parser) FullRawManifest() []byte {
+	return parser.rawManifest
+}
+
 func (parser Parser) RawManifest(_ string) ([]byte, error) {
 	return parser.rawManifest, nil
 }
+
+func (parser *Parser) parse(manifestBytes []byte) error {
+	parser.rawManifest = manifestBytes
+
+	var raw struct {
+		Applications []Application `yaml:"applications"`
+	}
+
+	err := yaml.Unmarshal(manifestBytes, &raw)
+	if err != nil {
+		return err
+	}
+
+	parser.Applications = raw.Applications
+
+	if len(parser.Applications) == 0 {
+		return errors.New("must have at least one application")
+	}
+
+	for _, application := range parser.Applications {
+		if application.Name == "" {
+			return errors.New("Found an application with no name specified")
+		}
+	}
+
+	return nil
+}