pack builder create should accept builder env config

builder/config_reader.go

@@ -70,7 +70,27 @@ type RunImageConfig struct {
 
 // BuildConfig build image configuration
 type BuildConfig struct {
-	Image string `toml:"image"`
+	Image string           `toml:"image"`
+	Env   []BuildConfigEnv `toml:"env"`
+}
+
+type Suffix string
+
+var SuffixSlice []Suffix = []Suffix{NONE, DEFAULT, OVERRIDE, APPEND, PREPEND}
+
+const (
+	NONE     Suffix = ""
+	DEFAULT  Suffix = "default"
+	OVERRIDE Suffix = "override"
+	APPEND   Suffix = "append"
+	PREPEND  Suffix = "prepend"
+)
+
+type BuildConfigEnv struct {
+	Name   string `toml:"name"`
+	Value  string `toml:"value"`
+	Suffix Suffix `toml:"suffix,omitempty"`
+	Delim  string `toml:"delim,omitempty"`
 }
 
 // ReadConfig reads a builder configuration from the file path provided and returns the

internal/builder/builder.go

@@ -32,6 +32,8 @@
 	lifecycleplatform "github.com/buildpacks/lifecycle/platform"
 )
 
+var buildConfigDir = cnbBuildConfigDir()
+
 const (
 	packName = "Pack CLI"
 
@@ -67,6 +69,7 @@
 // Builder represents a pack builder, used to build images
 type Builder struct {
 	baseImageName            string
+	buildConfigEnv           map[string]string
 	image                    imgutil.Image
 	layerWriterFactory       archive.TarWriterFactory
 	lifecycle                Lifecycle
@@ -146,6 +149,7 @@
 		metadata:                 metadata,
 		lifecycleDescriptor:      constructLifecycleDescriptor(metadata),
 		env:                      map[string]string{},
+		buildConfigEnv:           map[string]string{},
 		validateMixins:           true,
 		additionalBuildpacks:     *buildpack.NewModuleManager(opts.flatten, opts.depth),
 		additionalExtensions:     *buildpack.NewModuleManager(opts.flatten, opts.depth),
@@ -349,6 +353,11 @@
 	b.env = env
 }
 
+// SetBuildConfigEnv sets an environment variable to a value that will take action on platform environment variables basedon filename suffix
+func (b *Builder) SetBuildConfigEnv(env map[string]string) {
+	b.buildConfigEnv = env
+}
+
 // SetOrder sets the order of the builder
 func (b *Builder) SetOrder(order dist.Order) {
 	b.order = order
@@ -525,6 +534,18 @@
 		return errors.Wrap(err, "adding run.tar layer")
 	}
 
+	if len(b.buildConfigEnv) > 0 {
+		logger.Debugf("Provided Build Config Environment Variables\n  %s", style.Map(b.env, "  ", "\n"))
+		buildConfigEnvTar, err := b.buildConfigEnvLayer(tmpDir, b.buildConfigEnv)
+		if err != nil {
+			return errors.Wrap(err, "retrieving build-config-env layer")
+		}
+
+		if err := b.image.AddLayer(buildConfigEnvTar); err != nil {
+			return errors.Wrap(err, "adding build-config-env layer")
+		}
+	}
+
 	if len(b.env) > 0 {
 		logger.Debugf("Provided Environment Variables\n  %s", style.Map(b.env, "  ", "\n"))
 	}
@@ -903,7 +924,7 @@
 	}
 
 	// can't use filepath.Join(), to ensure Windows doesn't transform it to Windows join
-	for _, path := range []string{cnbDir, dist.BuildpacksDir, dist.ExtensionsDir, platformDir, platformDir + "/env"} {
+	for _, path := range []string{cnbDir, dist.BuildpacksDir, dist.ExtensionsDir, platformDir, platformDir + "/env", buildConfigDir, buildConfigDir + "/env"} {
 		if err := lw.WriteHeader(b.rootOwnedDir(path, ts)); err != nil {
 			return "", errors.Wrapf(err, "creating %s dir in layer", style.Symbol(path))
 		}
@@ -1102,6 +1123,33 @@
 	return fh.Name(), nil
 }
 
+func (b *Builder) buildConfigEnvLayer(dest string, env map[string]string) (string, error) {
+	fh, err := os.Create(filepath.Join(dest, "build-config-env.tar"))
+	if err != nil {
+		return "", err
+	}
+	defer fh.Close()
+
+	lw := b.layerWriterFactory.NewWriter(fh)
+	defer lw.Close()
+
+	for k, v := range env {
+		if err := lw.WriteHeader(&tar.Header{
+			Name:    path.Join(buildConfigDir, "env", k),
+			Size:    int64(len(v)),
+			Mode:    0644,
+			ModTime: archive.NormalizedDateTime,
+		}); err != nil {
+			return "", err
+		}
+		if _, err := lw.Write([]byte(v)); err != nil {
+			return "", err
+		}
+	}
+
+	return fh.Name(), nil
+}
+
 func (b *Builder) whiteoutLayer(tmpDir string, i int, bpInfo dist.ModuleInfo) (string, error) {
 	bpWhiteoutsTmpDir := filepath.Join(tmpDir, strconv.Itoa(i)+"_whiteouts")
 	if err := os.MkdirAll(bpWhiteoutsTmpDir, os.ModePerm); err != nil {
@@ -1257,3 +1305,11 @@
 func (e errModuleTar) Path() string {
 	return ""
 }
+
+func cnbBuildConfigDir() string {
+	if env, ok := os.LookupEnv("CNB_BUILD_CONFIG_DIR"); !ok {
+		return "/cnb/build-config"
+	} else {
+		return env
+	}
+}

internal/builder/builder_test.go

@@ -384,6 +384,20 @@ func testBuilder(t *testing.T, when spec.G, it spec.S) {
 				)
 			})
 
+			it("creates the build-config dir", func() {
+				h.AssertNil(t, subject.Save(logger, builder.CreatorMetadata{}))
+				h.AssertEq(t, baseImage.IsSaved(), true)
+
+				layerTar, err := baseImage.FindLayerWithPath("/cnb/build-config")
+				h.AssertNil(t, err)
+				h.AssertOnTarEntry(t, layerTar, "/cnb/build-config",
+					h.IsDirectory(),
+					h.HasOwnerAndGroup(0, 0),
+					h.HasFileMode(0755),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+			})
+
 			it("creates the buildpacks dir", func() {
 				h.AssertNil(t, subject.Save(logger, builder.CreatorMetadata{}))
 				h.AssertEq(t, baseImage.IsSaved(), true)
@@ -1607,6 +1621,35 @@ func testBuilder(t *testing.T, when spec.G, it spec.S) {
 			})
 		})
 
+		when("#SetBuildConfigEnv", func() {
+			it.Before(func() {
+				subject.SetBuildConfigEnv(map[string]string{
+					"SOME_KEY":         "some-val",
+					"OTHER_KEY.append": "other-val",
+					"OTHER_KEY.delim":  ":",
+				})
+				h.AssertNil(t, subject.Save(logger, builder.CreatorMetadata{}))
+				h.AssertEq(t, baseImage.IsSaved(), true)
+			})
+
+			it("adds the env vars as files to the image", func() {
+				layerTar, err := baseImage.FindLayerWithPath("/cnb/build-config/env/SOME_KEY")
+				h.AssertNil(t, err)
+				h.AssertOnTarEntry(t, layerTar, "/cnb/build-config/env/SOME_KEY",
+					h.ContentEquals(`some-val`),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+				h.AssertOnTarEntry(t, layerTar, "/cnb/build-config/env/OTHER_KEY.append",
+					h.ContentEquals(`other-val`),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+				h.AssertOnTarEntry(t, layerTar, "/cnb/build-config/env/OTHER_KEY.delim",
+					h.ContentEquals(`:`),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+			})
+		})
+
 		when("#SetEnv", func() {
 			it.Before(func() {
 				subject.SetEnv(map[string]string{

internal/commands/builder_create.go

@@ -75,9 +75,18 @@
 				return errors.Wrap(err, "getting absolute path for config")
 			}
 
+			envMap, warnings, err := ParseBuildConfigEnv(builderConfig.Build.Env, flags.BuilderTomlPath)
+			for _, v := range warnings {
+				logger.Warn(v)
+			}
+			if err != nil {
+				return err
+			}
+
 			imageName := args[0]
 			if err := pack.CreateBuilder(cmd.Context(), client.CreateBuilderOptions{
 				RelativeBaseDir: relativeBaseDir,
+				BuildConfigEnv:  envMap,
 				BuilderName:     imageName,
 				Config:          builderConfig,
 				Publish:         flags.Publish,
@@ -137,3 +146,92 @@
 
 	return nil
 }
+
+func getActionType(suffix builder.Suffix) (suffixString string, err error) {
+	const delim = "."
+	switch suffix {
+	case builder.NONE:
+		return "", nil
+	case builder.DEFAULT:
+		return delim + string(builder.DEFAULT), nil
+	case builder.OVERRIDE:
+		return delim + string(builder.OVERRIDE), nil
+	case builder.APPEND:
+		return delim + string(builder.APPEND), nil
+	case builder.PREPEND:
+		return delim + string(builder.PREPEND), nil
+	default:
+		return suffixString, errors.Errorf("unknown action type %s", style.Symbol(string(suffix)))
+	}
+}
+
+func getFilePrefixSuffix(filename string) (prefix, suffix string, err error) {
+	val := strings.Split(filename, ".")
+	if len(val) <= 1 {
+		return val[0], suffix, errors.Errorf("Suffix might be null")
+	}
+	if len(val) == 2 {
+		suffix = val[1]
+	} else {
+		strings.Join(val[1:], ".")
+	}
+	return val[0], suffix, err
+}
+
+func getBuildConfigEnvFileName(env builder.BuildConfigEnv) (suffixName, delimName string, err error) {
+	suffix, err := getActionType(env.Suffix)
+	if err != nil {
+		return suffixName, delimName, err
+	}
+	if suffix == "" || len(suffix) == 0 {
+		suffixName = env.Name
+	} else {
+		suffixName = env.Name + suffix
+	}
+	if delim := env.Delim; delim != "" || len(delim) != 0 {
+		delimName = env.Name + ".delim"
+	}
+	return suffixName, delimName, err
+}
+
+func ParseBuildConfigEnv(env []builder.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 {
+			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 {
+			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 {
+			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 {
+			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) {
+			envMap[delimName] = delim
+		}
+		envMap[suffixName] = v.Value
+	}
+
+	for k := range envMap {
+		name, suffix, err := getFilePrefixSuffix(k)
+		if err != nil {
+			continue
+		}
+		if _, ok := envMap[name+".delim"]; (suffix == "append" || suffix == "prepend") && !ok {
+			warnings = append(warnings, fmt.Sprintf(errors.Errorf("env with name/key %s with suffix %s must to have a %s value", style.Symbol(name), style.Symbol(suffix), style.Symbol("delim")).Error(), "parse contents of '%s'", path))
+			appendOrPrependWithoutDelim++
+		}
+	}
+	if appendOrPrependWithoutDelim > 0 {
+		return envMap, warnings, errors.Errorf("error parsing [[build.env]] in file '%s'", path)
+	}
+	return envMap, warnings, err
+}