[WIP: dont merge]

builder/config_reader.go

@@ -9,6 +9,7 @@ import (
 	"github.com/BurntSushi/toml"
 	"github.com/pkg/errors"
 
+	"github.com/buildpacks/pack/buildpackage"
 	"github.com/buildpacks/pack/internal/config"
 	"github.com/buildpacks/pack/internal/style"
 	"github.com/buildpacks/pack/pkg/dist"
@@ -25,6 +26,13 @@ type Config struct {
 	Lifecycle       LifecycleConfig  `toml:"lifecycle"`
 	Run             RunConfig        `toml:"run"`
 	Build           BuildConfig      `toml:"build"`
+	WithTargets     []dist.Target    `toml:"targets,omitempty"`
+}
+
+type MultiArchConfig struct {
+	Config
+	flagTargets     []dist.Target
+	relativeBaseDir string
 }
 
 // ModuleCollection is a list of ModuleConfigs
@@ -115,6 +123,151 @@ func ReadConfig(path string) (config Config, warnings []string, err error) {
 	return config, warnings, nil
 }
 
+func (c *MultiArchConfig) Targets() []dist.Target {
+	if len(c.flagTargets) != 0 {
+		return c.flagTargets
+	}
+
+	return c.WithTargets
+}
+
+func ReadMultiArchConfig(path string, flagTargets []dist.Target) (config MultiArchConfig, warnings []string, err error) {
+	file, err := os.Open(filepath.Clean(path))
+	if err != nil {
+		return MultiArchConfig{}, nil, errors.Wrap(err, "opening config file")
+	}
+	defer file.Close()
+
+	config, err = parseMultiArchConfig(file)
+	if err != nil {
+		return MultiArchConfig{}, nil, errors.Wrapf(err, "parse contents of '%s'", path)
+	}
+
+	if len(config.Order) == 0 {
+		warnings = append(warnings, fmt.Sprintf("empty %s definition", style.Symbol("order")))
+	}
+
+	config.mergeStackWithImages()
+	if len(flagTargets) != 0 {
+		config.flagTargets = flagTargets
+	}
+	return config, warnings, nil
+}
+
+func (c *MultiArchConfig) BuilderConfigs(getIndexManifest buildpackage.GetIndexManifestFn) (configs []Config, err error) {
+	for _, target := range c.Targets() {
+		if err := target.Range(func(target dist.Target, distroName, distroVersion string) error {
+			cfg, err := c.processTarget(target, "", "", getIndexManifest)
+			configs = append(configs, cfg)
+			return err
+		}); err != nil {
+			return configs, err
+		}
+	}
+	return configs, nil
+}
+
+func copyConfig(config Config) Config {
+	return Config{
+		Description:     config.Description,
+		Buildpacks:      make(ModuleCollection, len(config.Buildpacks)),
+		Extensions:      make(ModuleCollection, len(config.Extensions)),
+		Order:           make(dist.Order, len(config.Order)),
+		OrderExtensions: make(dist.Order, len(config.OrderExtensions)),
+		Stack: StackConfig{
+			RunImageMirrors: make([]string, len(config.Stack.RunImageMirrors)),
+		},
+		Run: RunConfig{
+			Images: make([]RunImageConfig, len(config.Run.Images)),
+		},
+	}
+}
+
+func (c *MultiArchConfig) processTarget(target dist.Target, distroName, distroVersion string, getIndexManifest buildpackage.GetIndexManifestFn) (config Config, err error) {
+	config = copyConfig(c.Config)
+	target = buildpackage.ProcessTarget(target, distroName, distroVersion)
+	for i, bp := range c.Config.Buildpacks {
+		if bp.URI != "" {
+			if config.Buildpacks[i].URI, err = buildpackage.GetRelativeURI(bp.URI, c.relativeBaseDir, &target, getIndexManifest); err != nil {
+				return config, err
+			}
+		}
+	}
+
+	for i, ext := range c.Config.Extensions {
+		if ext.URI != "" {
+			if config.Extensions[i].URI, err = buildpackage.GetRelativeURI(ext.URI, c.relativeBaseDir, &target, getIndexManifest); err != nil {
+				return config, err
+			}
+		}
+	}
+
+	if img := c.Config.Build.Image; img != "" {
+		if config.Build.Image, err = buildpackage.ParseURItoString(img, target, getIndexManifest); err != nil {
+			return config, err
+		}
+	}
+
+	for i, runImg := range c.Config.Run.Images {
+		config.Run.Images[i].Image, err = buildpackage.ParseURItoString(runImg.Image, target, getIndexManifest)
+		if len(config.Run.Images[i].Mirrors) == 0 {
+			config.Run.Images[i].Mirrors = make([]string, len(runImg.Mirrors))
+		}
+
+		if err != nil {
+			for j, mirror := range runImg.Mirrors {
+				if config.Run.Images[i].Mirrors[j], err = buildpackage.ParseURItoString(mirror, target, getIndexManifest); err == nil {
+					break
+				}
+			}
+
+			if err != nil {
+				return config, err
+			}
+		}
+	}
+
+	if img := c.Config.Stack.BuildImage; img != "" {
+		if config.Stack.BuildImage, err = buildpackage.ParseURItoString(img, target, getIndexManifest); err != nil {
+			return config, err
+		}
+	}
+
+	if img := c.Config.Stack.RunImage; img != "" {
+		config.Stack.RunImage, err = buildpackage.ParseURItoString(img, target, getIndexManifest)
+	}
+
+	if err != nil {
+		for i, mirror := range c.Config.Stack.RunImageMirrors {
+			if config.Stack.RunImageMirrors[i], err = buildpackage.ParseURItoString(mirror, target, getIndexManifest); err == nil {
+				break
+			}
+		}
+	}
+
+	config.Order = c.Order
+	config.OrderExtensions = c.OrderExtensions
+	config.WithTargets = []dist.Target{target}
+	return config, err
+}
+
+func (c *MultiArchConfig) MultiArch() bool {
+	targets := c.Targets()
+	if len(targets) > 1 {
+		return true
+	}
+
+	targetsLen := 0
+	for _, target := range targets {
+		target.Range(func(_ dist.Target, _, _ string) error {
+			targetsLen++
+			return nil
+		})
+	}
+
+	return targetsLen > 1
+}
+
 // ValidateConfig validates the config
 func ValidateConfig(c Config) error {
 	if c.Build.Image == "" && c.Stack.BuildImage == "" {
@@ -182,27 +335,48 @@ func parseConfig(file *os.File) (Config, error) {
 	return builderConfig, nil
 }
 
+// parseMultiArchConfig reads a builder configuration from file
+func parseMultiArchConfig(file *os.File) (MultiArchConfig, error) {
+	multiArchBuilderConfig := MultiArchConfig{}
+	tomlMetadata, err := toml.NewDecoder(file).Decode(&multiArchBuilderConfig)
+	if err != nil {
+		return MultiArchConfig{}, errors.Wrap(err, "decoding MultiArchBuilder Toml")
+	}
+
+	undecodedKeys := tomlMetadata.Undecoded()
+	if len(undecodedKeys) > 0 {
+		unknownElementsMsg := config.FormatUndecodedKeys(undecodedKeys)
+
+		return MultiArchConfig{}, errors.Errorf("%s in %s",
+			unknownElementsMsg,
+			style.Symbol(file.Name()),
+		)
+	}
+
+	return multiArchBuilderConfig, nil
+}
+
 func ParseBuildConfigEnv(env []BuildConfigEnv, path string) (envMap map[string]string, warnings []string, err error) {
 	envMap = map[string]string{}
 	var appendOrPrependWithoutDelim = 0
 	for _, v := range env {
-		if name := v.Name; name == "" || len(name) == 0 {
+		if name := v.Name; name == "" {
 			return nil, nil, errors.Wrapf(errors.Errorf("env name should not be empty"), "parse contents of '%s'", path)
 		}
-		if val := v.Value; val == "" || len(val) == 0 {
+		if val := v.Value; val == "" {
 			warnings = append(warnings, fmt.Sprintf("empty value for key/name %s", style.Symbol(v.Name)))
 		}
 		suffixName, delimName, err := getBuildConfigEnvFileName(v)
 		if err != nil {
 			return envMap, warnings, err
 		}
-		if val, e := envMap[suffixName]; e {
+		if val, ok := envMap[suffixName]; ok {
 			warnings = append(warnings, fmt.Sprintf(errors.Errorf("overriding env with name: %s and suffix: %s from %s to %s", style.Symbol(v.Name), style.Symbol(string(v.Suffix)), style.Symbol(val), style.Symbol(v.Value)).Error(), "parse contents of '%s'", path))
 		}
-		if val, e := envMap[delimName]; e {
+		if val, ok := envMap[delimName]; ok {
 			warnings = append(warnings, fmt.Sprintf(errors.Errorf("overriding env with name: %s and delim: %s from %s to %s", style.Symbol(v.Name), style.Symbol(v.Delim), style.Symbol(val), style.Symbol(v.Value)).Error(), "parse contents of '%s'", path))
 		}
-		if delim := v.Delim; (delim != "" || len(delim) != 0) && (delimName != "" || len(delimName) != 0) {
+		if delim := v.Delim; delim != "" && delimName != "" {
 			envMap[delimName] = delim
 		}
 		envMap[suffixName] = v.Value
@@ -234,7 +408,7 @@ func getBuildConfigEnvFileName(env BuildConfigEnv) (suffixName, delimName string
 	} else {
 		suffixName = env.Name + suffix
 	}
-	if delim := env.Delim; delim != "" || len(delim) != 0 {
+	if delim := env.Delim; delim != "" {
 		delimName = env.Name + ".delim"
 	}
 	return suffixName, delimName, err