pack builder create should accept builder env config

builder/config_reader.go

@@ -4,6 +4,7 @@ import (
  "fmt"
  "os"
  "path/filepath"
+ "strings"
 
  "github.com/BurntSushi/toml"
  "github.com/pkg/errors"
@@ -70,7 +71,25 @@ 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
+
+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
@@ -162,3 +181,92 @@ func parseConfig(file *os.File) (Config, error) {
 
  return builderConfig, 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 {
+ 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
+}
+
+func getBuildConfigEnvFileName(env BuildConfigEnv) (suffixName, delimName string, err error) {
+ suffix, err := getActionType(env.Suffix)
+ if err != nil {
+ return suffixName, delimName, err
+ }
+ if suffix == "" {
+ 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 getActionType(suffix Suffix) (suffixString string, err error) {
+ const delim = "."
+ switch suffix {
+ case NONE:
+ return "", nil
+ case DEFAULT:
+ return delim + string(DEFAULT), nil
+ case OVERRIDE:
+ return delim + string(OVERRIDE), nil
+ case APPEND:
+ return delim + string(APPEND), nil
+ case PREPEND:
+ return delim + string(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 {
+ suffix = strings.Join(val[1:], ".")
+ }
+ return val[0], suffix, err
+}

builder/config_reader_test.go

@@ -229,4 +229,111 @@ uri = "noop-buildpack.tgz"
  h.AssertError(t, builder.ValidateConfig(config), "build.image is required")
  })
  })
+ when("#ParseBuildConfigEnv()", func() {
+ it("should return an error when name is not defined", func() {
+ _, _, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+ {
+ Name: "",
+ Value: "vaiue",
+ },
+ }, "")
+ h.AssertNotNil(t, err)
+ })
+ it("should warn when the value is nil or empty string", func() {
+ env, warn, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+ {
+ Name: "key",
+ Value: "",
+ Suffix: "override",
+ },
+ }, "")
+
+ h.AssertNotNil(t, warn)
+ h.AssertNil(t, err)
+ h.AssertMapContains[string, string](t, env, h.NewKeyValue[string, string]("key.override", ""))
+ })
+ it("should return an error when unknown suffix is specified", func() {
+ _, _, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+ {
+ Name: "key",
+ Value: "",
+ Suffix: "invalid",
+ },
+ }, "")
+
+ h.AssertNotNil(t, err)
+ })
+ it("should override and show a warning when suffix or delim is defined multiple times", func() {
+ env, warn, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+ {
+ Name: "key1",
+ Value: "value1",
+ Suffix: "append",
+ Delim: "%",
+ },
+ {
+ Name: "key1",
+ Value: "value2",
+ Suffix: "append",
+ Delim: ",",
+ },
+ {
+ Name: "key1",
+ Value: "value3",
+ Suffix: "default",
+ Delim: ";",
+ },
+ {
+ Name: "key1",
+ Value: "value4",
+ Suffix: "prepend",
+ Delim: ":",
+ },
+ }, "")
+
+ h.AssertNotNil(t, warn)
+ h.AssertNil(t, err)
+ h.AssertMapContains[string, string](
+ t,
+ env,
+ h.NewKeyValue[string, string]("key1.append", "value2"),
+ h.NewKeyValue[string, string]("key1.default", "value3"),
+ h.NewKeyValue[string, string]("key1.prepend", "value4"),
+ h.NewKeyValue[string, string]("key1.delim", ":"),
+ )
+ h.AssertMapNotContains[string, string](
+ t,
+ env,
+ h.NewKeyValue[string, string]("key1.append", "value1"),
+ h.NewKeyValue[string, string]("key1.delim", "%"),
+ h.NewKeyValue[string, string]("key1.delim", ","),
+ h.NewKeyValue[string, string]("key1.delim", ";"),
+ )
+ })
+ it("should return an error when `suffix` is defined as `append` or `prepend` without a `delim`", func() {
+ _, warn, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+ {
+ Name: "key",
+ Value: "value",
+ Suffix: "append",
+ },
+ }, "")
+
+ h.AssertNotNil(t, warn)
+ h.AssertNotNil(t, err)
+ })
+ it("when suffix is NONE or omitted should default to `override`", func() {
+ env, warn, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+ {
+ Name: "key",
+ Value: "value",
+ Suffix: "",
+ },
+ }, "")
+
+ h.AssertNotNil(t, warn)
+ h.AssertNil(t, err)
+ h.AssertMapContains[string, string](t, env, h.NewKeyValue[string, string]("key", "value"))
+ })
+ })
 }

internal/builder/builder.go

@@ -32,6 +32,8 @@ import (
  lifecycleplatform "github.com/buildpacks/lifecycle/platform"
 )
 
+var buildConfigDir = cnbBuildConfigDir()
+
 const (
  packName = "Pack CLI"
 
@@ -67,6 +69,7 @@ const (
 // 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 @@ func constructBuilder(img imgutil.Image, newName string, errOnMissingLabel bool,
  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 @@ func (b *Builder) SetEnv(env map[string]string) {
  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 @@ func (b *Builder) Save(logger logging.Logger, creatorMetadata CreatorMetadata) e
  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 @@ func (b *Builder) defaultDirsLayer(dest string) (string, error) {
  }
 
  // 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,31 @@ func (b *Builder) envLayer(dest string, env map[string]string) (string, error) {
  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(cnbBuildConfigDir(), "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 +1303,11 @@ func (e errModuleTar) Info() dist.ModuleInfo {
 func (e errModuleTar) Path() string {
  return ""
 }
+
+func cnbBuildConfigDir() string {
+ if env, ok := os.LookupEnv("CNB_BUILD_CONFIG_DIR"); ok {
+ return env
+ }
+
+ return "/cnb/build-config"
+}