package bake

import (

"context"

"encoding"

"encoding/json"

"fmt"

"io"

"maps"

"net/url"

"os"

"path"

"path/filepath"

"regexp"

"slices"

"sort"

"strconv"

"strings"

"sync"

"time"

composecli "github.com/compose-spec/compose-go/v2/cli"

"github.com/docker/buildx/bake/hclparser"

"github.com/docker/buildx/build"

"github.com/docker/buildx/util/buildflags"

"github.com/docker/buildx/util/platformutil"

"github.com/docker/buildx/util/progress"

"github.com/docker/buildx/util/urlutil"

dockeropts "github.com/docker/cli/opts"

hcl "github.com/hashicorp/hcl/v2"

"github.com/moby/buildkit/client"

"github.com/moby/buildkit/client/llb"

"github.com/moby/buildkit/frontend/dockerfile/dfgitutil"

"github.com/pkg/errors"

"github.com/zclconf/go-cty/cty"

"github.com/zclconf/go-cty/cty/convert"

)

var (

validTargetNameChars = `[a-zA-Z0-9_-]+`

targetNamePattern = regexp.MustCompile(`^` + validTargetNameChars + `$`)

)

type File struct {

Name string

Data []byte

}

type Override struct {

Value string

ArrValue []string

Append bool

}

func defaultFilenames() []string {

names := []string{}

names = append(names, composecli.DefaultFileNames...)

names = append(names, []string{

"docker-bake.json",

"docker-bake.hcl",

"docker-bake.override.json",

"docker-bake.override.hcl",

}...)

return names

}

func ReadLocalFiles(names []string, stdin io.Reader, l progress.SubLogger) ([]File, error) {

isDefault := false

if len(names) == 0 {

isDefault = true

names = defaultFilenames()

}

out := make([]File, 0, len(names))

setStatus := func(st *client.VertexStatus) {

if l != nil {

l.SetStatus(st)

}

}

for _, n := range names {

var dt []byte

var err error

if n == "-" {

dt, err = readWithProgress(stdin, setStatus)

if err != nil {

return nil, err

}

} else {

dt, err = readFileWithProgress(n, isDefault, setStatus)

if dt == nil && err == nil {

continue

}

if err != nil {

return nil, err

}

}

out = append(out, File{Name: n, Data: dt})

}

return out, nil

}

func readFileWithProgress(fname string, isDefault bool, setStatus func(st *client.VertexStatus)) (dt []byte, err error) {

st := &client.VertexStatus{

ID: "reading " + fname,

}

defer func() {

now := time.Now()

st.Completed = &now

if dt != nil || err != nil {

setStatus(st)

}

}()

now := time.Now()

st.Started = &now

f, err := os.Open(fname)

if err != nil {

if isDefault && errors.Is(err, os.ErrNotExist) {

return nil, nil

}

return nil, err

}

defer f.Close()

setStatus(st)

info, err := f.Stat()

if err != nil {

return nil, err

}

st.Total = info.Size()

setStatus(st)

buf := make([]byte, 1024)

for {

n, err := f.Read(buf)

if err == io.EOF {

break

}

if err != nil {

return nil, err

}

dt = append(dt, buf[:n]...)

st.Current += int64(n)

setStatus(st)

}

return dt, nil

}

func readWithProgress(r io.Reader, setStatus func(st *client.VertexStatus)) (dt []byte, err error) {

st := &client.VertexStatus{

ID: "reading from stdin",

}

defer func() {

now := time.Now()

st.Completed = &now

setStatus(st)

}()

now := time.Now()

st.Started = &now

setStatus(st)

buf := make([]byte, 1024)

for {

n, err := r.Read(buf)

if err == io.EOF {

break

}

if err != nil {

return nil, err

}

dt = append(dt, buf[:n]...)

st.Current += int64(n)

setStatus(st)

}

return dt, nil

}

func ListTargets(files []File) ([]string, error) {

c, _, err := ParseFiles(files, nil, nil)

if err != nil {

return nil, err

}

var targets []string

for _, g := range c.Groups {

targets = append(targets, g.Name)

}

for _, t := range c.Targets {

targets = append(targets, t.Name)

}

return dedupSlice(targets), nil

}

func ReadTargets(ctx context.Context, files []File, targets, overrides []string, defaults, vars map[string]string, ent *EntitlementConf) (map[string]*Target, map[string]*Group, error) {

c, _, err := ParseFiles(files, defaults, vars)

if err != nil {

return nil, nil, err

}

for i, t := range targets {

targets[i] = sanitizeTargetName(t)

}

var tms []string

for _, t := range targets {

names, err := c.matchNames(t)

if err != nil {

return nil, nil, err

}

tms = append(tms, names...)

}

targets = dedupSlice(tms)

o, err := c.newOverrides(overrides)

if err != nil {

return nil, nil, err

}

targetsMap := map[string]*Target{}

groupsMap := map[string]*Group{}

for _, target := range targets {

ts, gs := c.ResolveGroup(target)

for _, tname := range ts {

t, err := c.ResolveTarget(tname, o, ent)

if err != nil {

return nil, nil, err

}

if t != nil {

targetsMap[tname] = t

}

}

for _, gname := range gs {

for _, group := range c.Groups {

if group.Name == gname {

groupsMap[gname] = group

break

}

}

}

}

for _, target := range targets {

if _, ok := groupsMap["default"]; ok && target == "default" {

continue

}

if _, ok := groupsMap["default"]; !ok {

groupsMap["default"] = &Group{Name: "default"}

}

groupsMap["default"].Targets = append(groupsMap["default"].Targets, target)

}

if g, ok := groupsMap["default"]; ok {

g.Targets = dedupSlice(g.Targets)

sort.Strings(g.Targets)

}

for name, t := range targetsMap {

if err := c.loadLinks(name, t, targetsMap, o, nil, ent); err != nil {

return nil, nil, err

}

}

return targetsMap, groupsMap, nil

}

func dedupSlice(s []string) []string {

if len(s) == 0 {

return s

}

var res []string

seen := make(map[string]struct{})

for _, val := range s {

if _, ok := seen[val]; !ok {

res = append(res, val)

seen[val] = struct{}{}

}

}

return res

}

func dedupMap(ms ...map[string]string) map[string]string {

if len(ms) == 0 {

return nil

}

res := map[string]string{}

for _, m := range ms {

if len(m) == 0 {

continue

}

for k, v := range m {

if _, ok := res[k]; !ok {

res[k] = v

}

}

}

return res

}

func sliceToMap(env []string) (res map[string]string) {

res = make(map[string]string)

for _, s := range env {

kv := strings.SplitN(s, "=", 2)

key := kv[0]

switch {

case len(kv) == 1:

res[key] = ""

default:

res[key] = kv[1]

}

}

return

}

func (c Config) matchNames(pattern string) ([]string, error) {

if !strings.ContainsAny(pattern, "*?[]") {

return []string{pattern}, nil

}

var names []string

for _, group := range c.Groups {

if ok, err := path.Match(pattern, group.Name); ok && err == nil {

names = append(names, group.Name)

}

}

for _, target := range c.Targets {

if ok, err := path.Match(pattern, target.Name); ok && err == nil {

names = append(names, target.Name)

}

}

if len(names) == 0 {

return nil, errors.Errorf("could not find any target matching %q", pattern)

}

return names, nil

}

func ParseFiles(files []File, defaults, vars map[string]string) (_ *Config, _ *hclparser.ParseMeta, err error) {

defer func() {

err = formatHCLError(err, files)

}()

var c Config

var composeFiles []File

var hclFiles []*hcl.File

for _, f := range files {

isCompose, composeErr := validateComposeFile(f.Data, f.Name, vars)

if isCompose {

if composeErr != nil {

return nil, nil, composeErr

}

composeFiles = append(composeFiles, f)

}

if !isCompose {

hf, isHCL, err := ParseHCLFile(f.Data, f.Name)

if isHCL {

if err != nil {

return nil, nil, err

}

hclFiles = append(hclFiles, hf)

} else if composeErr != nil {

return nil, nil, errors.Wrapf(err, "failed to parse %s: parsing yaml: %v, parsing hcl", f.Name, composeErr)

} else {

return nil, nil, err

}

}

}

if len(composeFiles) > 0 {

cfg, cmperr := ParseComposeFiles(composeFiles, vars)

if cmperr != nil {

return nil, nil, errors.Wrap(cmperr, "failed to parse compose file")

}

c = mergeConfig(c, *cfg)

c = dedupeConfig(c)

}

var pm hclparser.ParseMeta

if len(hclFiles) > 0 {

lookup := func(key string) (string, bool) {

if v, ok := vars[key]; ok {

return v, true

}

if envLookupAllowed() {

return os.LookupEnv(key)

}

return "", false

}

res, err := hclparser.Parse(hclparser.MergeFiles(hclFiles), hclparser.Opt{

LookupVar: lookup,

Vars: defaults,

ValidateLabel: validateTargetName,

}, &c)

if err.HasErrors() {

return nil, nil, err

}

for _, renamed := range res.Renamed {

for oldName, newNames := range renamed {

newNames = dedupSlice(newNames)

if len(newNames) == 1 && oldName == newNames[0] {

continue

}

c.Groups = append(c.Groups, &Group{

Name: oldName,

Targets: newNames,

})

}

}

c = dedupeConfig(c)

pm = *res

}

return &c, &pm, nil

}

func dedupeConfig(c Config) Config {

c2 := c

c2.Groups = make([]*Group, 0, len(c2.Groups))

for _, g := range c.Groups {

g1 := *g

g1.Targets = dedupSlice(g1.Targets)

c2.Groups = append(c2.Groups, &g1)

}

c2.Targets = make([]*Target, 0, len(c2.Targets))

mt := map[string]*Target{}

for _, t := range c.Targets {

if t2, ok := mt[t.Name]; ok {

t2.Merge(t)

} else {

mt[t.Name] = t

c2.Targets = append(c2.Targets, t)

}

}

return c2

}

func ParseFile(dt []byte, fn string) (*Config, error) {

c, _, err := ParseFiles([]File{{Data: dt, Name: fn}}, nil, nil)

return c, err

}

type Config struct {

Groups []*Group `json:"group" hcl:"group,block" cty:"group"`

Targets []*Target `json:"target" hcl:"target,block" cty:"target"`

}

func mergeConfig(c1, c2 Config) Config {

if c1.Groups == nil {

c1.Groups = []*Group{}

}

for _, g2 := range c2.Groups {

var g1 *Group

for _, g := range c1.Groups {

if g2.Name == g.Name {

g1 = g

break

}

}

if g1 == nil {

c1.Groups = append(c1.Groups, g2)

continue

}

nextTarget:

for _, t2 := range g2.Targets {

for _, t1 := range g1.Targets {

if t1 == t2 {

continue nextTarget

}

}

g1.Targets = append(g1.Targets, t2)

}

c1.Groups = append(c1.Groups, g1)

}

if c1.Targets == nil {

c1.Targets = []*Target{}

}

for _, t2 := range c2.Targets {

var t1 *Target

for _, t := range c1.Targets {

if t2.Name == t.Name {

t1 = t

break

}

}

if t1 != nil {

t1.Merge(t2)

t2 = t1

}

c1.Targets = append(c1.Targets, t2)

}

return c1

}

func (c Config) expandTargets(pattern string) ([]string, error) {

for _, target := range c.Targets {

if target.Name == pattern {

return []string{pattern}, nil

}

}

var names []string

for _, target := range c.Targets {

ok, err := path.Match(pattern, target.Name)

if err != nil {

return nil, errors.Wrapf(err, "could not match targets with '%s'", pattern)

}

if ok {

names = append(names, target.Name)

}

}

if len(names) == 0 {

return nil, errors.Errorf("could not find any target matching '%s'", pattern)

}

return names, nil

}

func (c Config) loadLinks(name string, t *Target, m map[string]*Target, o map[string]map[string]Override, visited []string, ent *EntitlementConf) error {

visited = append(visited, name)

for _, v := range t.Contexts {

if target, ok := strings.CutPrefix(v, "target:"); ok {

if target == name {

return errors.Errorf("target %s cannot link to itself", target)

}

if slices.Contains(visited, target) {

return errors.Errorf("infinite loop from %s to %s", name, target)

}

t2, ok := m[target]

if !ok {

var err error

t2, err = c.ResolveTarget(target, o, ent)

if err != nil {

return err

}

t2.Outputs = []*buildflags.ExportEntry{

{Type: "cacheonly"},

}

t2.linked = true

m[target] = t2

}

if err := c.loadLinks(target, t2, m, o, visited, ent); err != nil {

return err

}

// entitlements are inherited from linked targets

for _, ent := range t2.Entitlements {

if !slices.Contains(t.Entitlements, ent) {

t.Entitlements = append(t.Entitlements, ent)

}

}

if len(t.Platforms) > 1 && len(t2.Platforms) > 1 {

if !isSubset(t.Platforms, t2.Platforms) {

return errors.Errorf("target %s can't be used by %s because its platforms %v are not a subset of %v", target, name, t.Platforms, t2.Platforms)

}

}

}

}

return nil

}

func (c Config) newOverrides(v []string) (map[string]map[string]Override, error) {

m := map[string]map[string]Override{}

for _, v := range v {

parts := strings.SplitN(v, "=", 2)

skey := strings.TrimSuffix(parts[0], "+")

appendTo := strings.HasSuffix(parts[0], "+")

keys := strings.SplitN(skey, ".", 3)

if len(keys) < 2 {

return nil, errors.Errorf("invalid override key %s, expected target.name", skey)

}

pattern := keys[0]

if len(parts) != 2 && keys[1] != "args" {

return nil, errors.Errorf("invalid override %s, expected target.name=value", v)

}

names, err := c.expandTargets(pattern)

if err != nil {

return nil, err

}

okey := strings.Join(keys[1:], ".")

for _, name := range names {

t, ok := m[name]

if !ok {

t = map[string]Override{}

m[name] = t

}

override := t[okey]

// IMPORTANT: if you add more fields here, do not forget to update

// docs/reference/buildx_bake.md (--set) and https://docs.docker.com/build/bake/overrides/

switch keys[1] {

case "output", "cache-to", "cache-from", "tags", "platform", "secrets", "ssh", "attest", "entitlements", "network", "annotations", "policy":

if len(parts) == 2 {

override.Append = appendTo

override.ArrValue = append(override.ArrValue, parts[1])

}

case "args":

if len(keys) != 3 {

return nil, errors.Errorf("invalid key %s, args requires name", parts[0])

}

if len(parts) < 2 && envLookupAllowed() {

v, ok := os.LookupEnv(keys[2])

if !ok {

continue

}

override.Value = v

}

fallthrough

case "contexts":

if len(keys) != 3 {

return nil, errors.Errorf("invalid key %s, contexts requires name", parts[0])

}

fallthrough

default:

if len(parts) == 2 {

override.Value = parts[1]

}

}

t[okey] = override

}

}

return m, nil

}

func (c Config) ResolveGroup(name string) ([]string, []string) {

targets, groups := c.group(name, map[string]visit{})

return dedupSlice(targets), dedupSlice(groups)

}

type visit struct {

target []string

group []string

}

func (c Config) group(name string, visited map[string]visit) ([]string, []string) {

if v, ok := visited[name]; ok {

return v.target, v.group

}

var g *Group

for _, group := range c.Groups {

if group.Name == name {

g = group

break

}

}

if g == nil {

return []string{name}, nil

}

visited[name] = visit{}

targets := make([]string, 0, len(g.Targets))

groups := []string{name}

for _, t := range g.Targets {

ttarget, tgroup := c.group(t, visited)

if len(ttarget) > 0 {

targets = append(targets, ttarget...)

} else {

targets = append(targets, t)

}

if len(tgroup) > 0 {

groups = append(groups, tgroup...)

}

}

visited[name] = visit{target: targets, group: groups}

return targets, groups

}

func (c Config) ResolveTarget(name string, overrides map[string]map[string]Override, ent *EntitlementConf) (*Target, error) {

t, err := c.target(name, map[string]*Target{}, overrides, ent)

if err != nil {

return nil, err

}

t.Inherits = nil

if t.Context == nil {

s := "."

t.Context = &s

}

if t.Dockerfile == nil || (t.Dockerfile != nil && *t.Dockerfile == "") {

s := "Dockerfile"

t.Dockerfile = &s

}

return t, nil

}

func (c Config) target(name string, visited map[string]*Target, overrides map[string]map[string]Override, ent *EntitlementConf) (*Target, error) {

if t, ok := visited[name]; ok {

return t, nil

}

visited[name] = nil

var t *Target

for _, target := range c.Targets {

if target.Name == name {

t = target

break

}

}

if t == nil {

return nil, errors.Errorf("failed to find target %s", name)

}

tt := &Target{}

for _, name := range t.Inherits {

t, err := c.target(name, visited, overrides, ent)

if err != nil {

return nil, err

}

if t != nil {

tt.Merge(t)

}

}

m := defaultTarget()

m.Merge(tt)

m.Merge(t)

tt = m

if err := tt.AddOverrides(overrides[name], ent); err != nil {

return nil, err

}

tt.normalize()

visited[name] = tt

return tt, nil

}

type Group struct {

Name string `json:"-" hcl:"name,label" cty:"name"`

Description string `json:"description,omitempty" hcl:"description,optional" cty:"description"`

Targets []string `json:"targets" hcl:"targets" cty:"targets"`

// Target // TODO?

}

type Target struct {

Name string `json:"-" hcl:"name,label" cty:"name"`

Description string `json:"description,omitempty" hcl:"description,optional" cty:"description"`

// Inherits is the only field that cannot be overridden with --set

Inherits []string `json:"inherits,omitempty" hcl:"inherits,optional" cty:"inherits"`

Annotations []string `json:"annotations,omitempty" hcl:"annotations,optional" cty:"annotations"`

Attest buildflags.Attests `json:"attest,omitempty" hcl:"attest,optional" cty:"attest"`

Context *string `json:"context,omitempty" hcl:"context,optional" cty:"context"`

Contexts map[string]string `json:"contexts,omitempty" hcl:"contexts,optional" cty:"contexts"`

Dockerfile *string `json:"dockerfile,omitempty" hcl:"dockerfile,optional" cty:"dockerfile"`

DockerfileInline *string `json:"dockerfile-inline,omitempty" hcl:"dockerfile-inline,optional" cty:"dockerfile-inline"`

Args map[string]*string `json:"args,omitempty" hcl:"args,optional" cty:"args"`

Labels map[string]*string `json:"labels,omitempty" hcl:"labels,optional" cty:"labels"`

Tags []string `json:"tags,omitempty" hcl:"tags,optional" cty:"tags"`

CacheFrom buildflags.CacheOptions `json:"cache-from,omitempty" hcl:"cache-from,optional" cty:"cache-from"`

CacheTo buildflags.CacheOptions `json:"cache-to,omitempty" hcl:"cache-to,optional" cty:"cache-to"`

Target *string `json:"target,omitempty" hcl:"target,optional" cty:"target"`

Secrets buildflags.Secrets `json:"secret,omitempty" hcl:"secret,optional" cty:"secret"`

SSH buildflags.SSHKeys `json:"ssh,omitempty" hcl:"ssh,optional" cty:"ssh"`

Platforms []string `json:"platforms,omitempty" hcl:"platforms,optional" cty:"platforms"`

Outputs buildflags.Exports `json:"output,omitempty" hcl:"output,optional" cty:"output"`

Pull *bool `json:"pull,omitempty" hcl:"pull,optional" cty:"pull"`

NoCache *bool `json:"no-cache,omitempty" hcl:"no-cache,optional" cty:"no-cache"`

NetworkMode *string `json:"network,omitempty" hcl:"network,optional" cty:"network"`

NoCacheFilter []string `json:"no-cache-filter,omitempty" hcl:"no-cache-filter,optional" cty:"no-cache-filter"`

ShmSize *string `json:"shm-size,omitempty" hcl:"shm-size,optional" cty:"shm-size"`

Ulimits []string `json:"ulimits,omitempty" hcl:"ulimits,optional" cty:"ulimits"`

Call *string `json:"call,omitempty" hcl:"call,optional" cty:"call"`

Entitlements []string `json:"entitlements,omitempty" hcl:"entitlements,optional" cty:"entitlements"`

ExtraHosts map[string]*string `json:"extra-hosts,omitempty" hcl:"extra-hosts,optional" cty:"extra-hosts"`

Policy buildflags.PolicyConfigs `json:"policy,omitempty" hcl:"policy,optional" cty:"policy"`

// IMPORTANT: if you add more fields here, do not forget to update newOverrides/AddOverrides and docs/bake-reference.md.

// linked is a private field to mark a target used as a linked one

linked bool

}

func (t *Target) MarshalJSON() ([]byte, error) {

tgt := *t

esc := func(s string) string {

return strings.ReplaceAll(strings.ReplaceAll(s, "${", "$${"), "%{", "%%{")

}

tgt.Annotations = slices.Clone(t.Annotations)

for i, v := range tgt.Annotations {

tgt.Annotations[i] = esc(v)

}

if tgt.DockerfileInline != nil {

escaped := esc(*tgt.DockerfileInline)

tgt.DockerfileInline = &escaped

}

tgt.Labels = maps.Clone(t.Labels)

for k, v := range t.Labels {

if v != nil {

escaped := esc(*v)

tgt.Labels[k] = &escaped

}

}

tgt.Args = maps.Clone(t.Args)

for k, v := range t.Args {

if v != nil {

escaped := esc(*v)

tgt.Args[k] = &escaped

}

}

tgt.ExtraHosts = maps.Clone(t.ExtraHosts)

for k, v := range t.ExtraHosts {

if v != nil {

escaped := esc(*v)

tgt.ExtraHosts[k] = &escaped

}

}

return json.Marshal(tgt)

}

var (

_ hclparser.WithEvalContexts = &Target{}

_ hclparser.WithGetName = &Target{}

_ hclparser.WithEvalContexts = &Group{}

_ hclparser.WithGetName = &Group{}

)

func (t *Target) normalize() {

t.Annotations = removeDupesStr(t.Annotations)

t.Attest = t.Attest.Normalize()

t.Tags = removeDupesStr(t.Tags)

t.Secrets = t.Secrets.Normalize()

t.SSH = t.SSH.Normalize()

t.Platforms = removeDupesStr(t.Platforms)

t.CacheFrom = t.CacheFrom.Normalize()

t.CacheTo = t.CacheTo.Normalize()

t.Outputs = t.Outputs.Normalize()

t.NoCacheFilter = removeDupesStr(t.NoCacheFilter)

t.Ulimits = removeDupesStr(t.Ulimits)

if t.NetworkMode != nil && *t.NetworkMode == "host" {

t.Entitlements = append(t.Entitlements, "network.host")

}

t.Entitlements = removeDupesStr(t.Entitlements)

for k, v := range t.Contexts {

if v == "" {

delete(t.Contexts, k)

}

}

if len(t.Contexts) == 0 {

t.Contexts = nil

}

}

func (t *Target) Merge(t2 *Target) {

if t2.Context != nil {

t.Context = t2.Context

}

if t2.Dockerfile != nil {

t.Dockerfile = t2.Dockerfile

}

if t2.DockerfileInline != nil {

t.DockerfileInline = t2.DockerfileInline

}

for k, v := range t2.Args {

if v == nil {

continue

}

if t.Args == nil {

t.Args = map[string]*string{}

}

t.Args[k] = v

}

for k, v := range t2.Contexts {

if t.Contexts == nil {

t.Contexts = map[string]string{}

}

t.Contexts[k] = v

}

for k, v := range t2.Labels {

if v == nil {

continue

}

if t.Labels == nil {

t.Labels = map[string]*string{}

}

t.Labels[k] = v

}

if t2.Tags != nil { // no merge

t.Tags = t2.Tags

}

if t2.Target != nil {

t.Target = t2.Target

}

if t2.Call != nil {

t.Call = t2.Call

}

if t2.Annotations != nil { // merge

t.Annotations = append(t.Annotations, t2.Annotations...)

}

if t2.Attest != nil { // merge

t.Attest = t.Attest.Merge(t2.Attest)

}

if t2.Policy != nil { // merge

t.Policy = append(t.Policy, t2.Policy...)

}

if t2.Secrets != nil { // merge

t.Secrets = t.Secrets.Merge(t2.Secrets)

}

if t2.SSH != nil { // merge

t.SSH = t.SSH.Merge(t2.SSH)

}

if t2.Platforms != nil { // no merge

t.Platforms = t2.Platforms

}

if t2.CacheFrom != nil { // merge

t.CacheFrom = t.CacheFrom.Merge(t2.CacheFrom)

}

if t2.CacheTo != nil { // no merge

t.CacheTo = t2.CacheTo

}

if t2.Outputs != nil { // no merge

t.Outputs = t2.Outputs

}

if t2.Pull != nil {

t.Pull = t2.Pull

}

if t2.NoCache != nil {

t.NoCache = t2.NoCache

}

if t2.NetworkMode != nil {

t.NetworkMode = t2.NetworkMode

}

if t2.NoCacheFilter != nil { // merge

t.NoCacheFilter = append(t.NoCacheFilter, t2.NoCacheFilter...)

}

if t2.ShmSize != nil { // no merge

t.ShmSize = t2.ShmSize

}

if t2.Ulimits != nil { // merge

t.Ulimits = append(t.Ulimits, t2.Ulimits...)

}

if t2.Description != "" {

t.Description = t2.Description

}

if t2.Entitlements != nil { // merge

t.Entitlements = append(t.Entitlements, t2.Entitlements...)

}

for k, v := range t2.ExtraHosts {

if v == nil {

continue

}

if t.ExtraHosts == nil {

t.ExtraHosts = map[string]*string{}

}

t.ExtraHosts[k] = v

}

t.Inherits = append(t.Inherits, t2.Inherits...)

}

func (t *Target) AddOverrides(overrides map[string]Override, ent *EntitlementConf) error {

// IMPORTANT: if you add more fields here, do not forget to update

// docs/bake-reference.md and https://docs.docker.com/build/bake/overrides/

for key, o := range overrides {

value := o.Value

keys := strings.SplitN(key, ".", 2)

switch keys[0] {

case "context":

t.Context = &value

case "dockerfile":

t.Dockerfile = &value

case "args":

if len(keys) != 2 {

return errors.Errorf("invalid format for args, expecting args.<name>=<value>")

}

if t.Args == nil {

t.Args = map[string]*string{}

}

t.Args[keys[1]] = &value

case "contexts":

if len(keys) != 2 {

return errors.Errorf("invalid format for contexts, expecting contexts.<name>=<value>")

}

if t.Contexts == nil {

t.Contexts = map[string]string{}

}

t.Contexts[keys[1]] = value

case "labels":

if len(keys) != 2 {

return errors.Errorf("invalid format for labels, expecting labels.<name>=<value>")

}

if t.Labels == nil {

t.Labels = map[string]*string{}

}

t.Labels[keys[1]] = &value

case "tags":