docker/buildx
1
0
Fork 0
mirror of https://gitea.com/Lydanne/buildx.git synced 2025-07-09 21:17:09 +08:00
Code Issues Packages Projects Releases 1 Wiki Activity

bump compose-go to version v2.6.0

Browse Source 
Signed-off-by: Guillaume Lours <705411+glours@users.noreply.github.com>
This commit is contained in:
Guillaume Lours
2025-04-10 18:02:16 +02:00
parent f8de3c3bdc
commit 0b4e624aaa
23 changed files with 397 additions and 768 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
vendor/github.com/compose-spec/compose-go/v2/dotenv/env.go generated vendored
View File

@ -35,7 +35,7 @@ func GetEnvFromFile(currentEnv map[string]string, filenames []string) (map[strin
s, err := os.Stat(dotEnvFile)
if os.IsNotExist(err) {
return envMap, fmt.Errorf("Couldn't find env file: %s", dotEnvFile)
return envMap, fmt.Errorf("couldn't find env file: %s", dotEnvFile)
}
if err != nil {
return envMap, err
@ -50,7 +50,7 @@ func GetEnvFromFile(currentEnv map[string]string, filenames []string) (map[strin
b, err := os.ReadFile(dotEnvFile)
if os.IsNotExist(err) {
return nil, fmt.Errorf("Couldn't read env file: %s", dotEnvFile)
return nil, fmt.Errorf("couldn't read env file: %s", dotEnvFile)
}
if err != nil {
return envMap, err

16
vendor/github.com/compose-spec/compose-go/v2/dotenv/format.go generated vendored
View File

@ -24,28 +24,28 @@ import (
const DotEnv = ".env"
var formats = map[string]Parser{
DotEnv: func(r io.Reader, filename string, lookup func(key string) (string, bool)) (map[string]string, error) {
m, err := ParseWithLookup(r, lookup)
DotEnv: func(r io.Reader, filename string, vars map[string]string, lookup func(key string) (string, bool)) error {
err := parseWithLookup(r, vars, lookup)
if err != nil {
return nil, fmt.Errorf("failed to read %s: %w", filename, err)
return fmt.Errorf("failed to read %s: %w", filename, err)
}
return m, nil
return nil
},
}
type Parser func(r io.Reader, filename string, lookup func(key string) (string, bool)) (map[string]string, error)
type Parser func(r io.Reader, filename string, vars map[string]string, lookup func(key string) (string, bool)) error
func RegisterFormat(format string, p Parser) {
formats[format] = p
}
func ParseWithFormat(r io.Reader, filename string, resolve LookupFn, format string) (map[string]string, error) {
func ParseWithFormat(r io.Reader, filename string, vars map[string]string, resolve LookupFn, format string) error {
if format == "" {
format = DotEnv
}
fn, ok := formats[format]
if !ok {
return nil, fmt.Errorf("unsupported env_file format %q", format)
return fmt.Errorf("unsupported env_file format %q", format)
}
return fn(r, filename, resolve)
return fn(r, filename, vars, resolve)
}

11
vendor/github.com/compose-spec/compose-go/v2/dotenv/godotenv.go generated vendored
View File

@ -41,16 +41,23 @@ func Parse(r io.Reader) (map[string]string, error) {
// ParseWithLookup reads an env file from io.Reader, returning a map of keys and values.
func ParseWithLookup(r io.Reader, lookupFn LookupFn) (map[string]string, error) {
vars := map[string]string{}
err := parseWithLookup(r, vars, lookupFn)
return vars, err
}
// ParseWithLookup reads an env file from io.Reader, returning a map of keys and values.
func parseWithLookup(r io.Reader, vars map[string]string, lookupFn LookupFn) error {
data, err := io.ReadAll(r)
if err != nil {
return nil, err
return err
}
// seek past the UTF-8 BOM if it exists (particularly on Windows, some
// editors tend to add it, and it'll cause parsing to fail)
data = bytes.TrimPrefix(data, utf8BOM)
return UnmarshalBytesWithLookup(data, lookupFn)
return newParser().parse(string(data), vars, lookupFn)
}
// Load will read your env file(s) and load them into ENV for this process.

2
vendor/github.com/compose-spec/compose-go/v2/graph/cycle.go generated vendored
View File

@ -18,11 +18,11 @@ package graph
import (
"fmt"
"slices"
"strings"
"github.com/compose-spec/compose-go/v2/types"
"github.com/compose-spec/compose-go/v2/utils"
"golang.org/x/exp/slices"
)
// CheckCycle analyze project's depends_on relation and report an error on cycle detection

2
vendor/github.com/compose-spec/compose-go/v2/graph/traversal.go generated vendored
View File

@ -18,9 +18,9 @@ package graph
import (
"context"
"slices"
"sync"
"golang.org/x/exp/slices"
"golang.org/x/sync/errgroup"
)

8
vendor/github.com/compose-spec/compose-go/v2/loader/loader.go generated vendored
View File

@ -26,6 +26,7 @@ import (
"path/filepath"
"reflect"
"regexp"
"slices"
"strconv"
"strings"
@ -42,7 +43,6 @@ import (
"github.com/compose-spec/compose-go/v2/validation"
"github.com/go-viper/mapstructure/v2"
"github.com/sirupsen/logrus"
"golang.org/x/exp/slices"
"gopkg.in/yaml.v3"
)
@ -337,7 +337,7 @@ func LoadModelWithContext(ctx context.Context, configDetails types.ConfigDetails
// LoadModelWithContext reads a ConfigDetails and returns a fully loaded configuration as a yaml dictionary
func loadModelWithContext(ctx context.Context, configDetails *types.ConfigDetails, opts *Options) (map[string]any, error) {
if len(configDetails.ConfigFiles) < 1 {
return nil, errors.New("No files specified")
return nil, errors.New("no compose file specified")
}
err := projectName(configDetails, opts)
@ -432,7 +432,7 @@ func loadYamlFile(ctx context.Context,
}
cfg, ok := converted.(map[string]interface{})
if !ok {
return errors.New("Top-level object must be a mapping")
return errors.New("top-level object must be a mapping")
}
if opts.Interpolate != nil && !opts.SkipInterpolation {
@ -877,7 +877,7 @@ func formatInvalidKeyError(keyPrefix string, key interface{}) error {
} else {
location = fmt.Sprintf("in %s", keyPrefix)
}
return fmt.Errorf("Non-string key %s: %#v", location, key)
return fmt.Errorf("non-string key %s: %#v", location, key)
}
// Windows path, c:\\my\\path\\shiny, need to be changed to be compatible with

6
vendor/github.com/compose-spec/compose-go/v2/loader/reset.go generated vendored
View File

@ -67,6 +67,8 @@ func (p *ResetProcessor) resolveReset(node *yaml.Node, path tree.Path) (*yaml.No
p.paths = append(p.paths, path)
return node, nil
}
keys := map[string]int{}
switch node.Kind {
case yaml.SequenceNode:
var nodes []*yaml.Node
@ -87,6 +89,10 @@ func (p *ResetProcessor) resolveReset(node *yaml.Node, path tree.Path) (*yaml.No
for idx, v := range node.Content {
if idx%2 == 0 {
key = v.Value
if line, seen := keys[key]; seen {
return nil, fmt.Errorf("line %d: mapping key %#v already defined at line %d", v.Line, key, line)
}
keys[key] = v.Line
} else {
resolved, err := p.resolveReset(v, path.Next(key))
if err != nil {

2
vendor/github.com/compose-spec/compose-go/v2/loader/validate.go generated vendored
View File

@ -29,7 +29,7 @@ import (
// checkConsistency validate a compose model is consistent
func checkConsistency(project *types.Project) error { //nolint:gocyclo
for name, s := range project.Services {
if s.Build == nil && s.Image == "" {
if s.Build == nil && s.Image == "" && s.Provider == nil {
return fmt.Errorf("service %q has neither an image nor a build context specified: %w", s.Name, errdefs.ErrInvalid)
}

18
vendor/github.com/compose-spec/compose-go/v2/override/merge.go generated vendored
View File

@ -19,10 +19,9 @@ package override
import (
"cmp"
"fmt"
"strings"
"slices"
"github.com/compose-spec/compose-go/v2/tree"
"golang.org/x/exp/slices"
)
// Merge applies overrides to a config model
@ -62,6 +61,7 @@ func init() {
mergeSpecials["services.*.extra_hosts"] = mergeExtraHosts
mergeSpecials["services.*.healthcheck.test"] = override
mergeSpecials["services.*.labels"] = mergeToSequence
mergeSpecials["services.*.volumes.*.volume.labels"] = mergeToSequence
mergeSpecials["services.*.logging"] = mergeLogging
mergeSpecials["services.*.networks"] = mergeNetworks
mergeSpecials["services.*.sysctls"] = mergeToSequence
@ -104,7 +104,7 @@ func mergeYaml(e any, o any, p tree.Path) (any, error) {
func mergeMappings(mapping map[string]any, other map[string]any, p tree.Path) (map[string]any, error) {
for k, v := range other {
e, ok := mapping[k]
if !ok || strings.HasPrefix(k, "x-") {
if !ok {
mapping[k] = v
continue
}
@ -227,9 +227,17 @@ func mergeUlimit(_ any, o any, p tree.Path) (any, error) {
func mergeIPAMConfig(c any, o any, path tree.Path) (any, error) {
var ipamConfigs []any
for _, original := range c.([]any) {
configs, ok := c.([]any)
if !ok {
return o, fmt.Errorf("%s: unexpected type %T", path, c)
}
overrides, ok := o.([]any)
if !ok {
return o, fmt.Errorf("%s: unexpected type %T", path, c)
}
for _, original := range configs {
right := convertIntoMapping(original, nil)
for _, override := range o.([]any) {
for _, override := range overrides {
left := convertIntoMapping(override, nil)
if left["subnet"] != right["subnet"] {
// check if left is already in ipamConfigs, add it if not and continue with the next config

28
vendor/github.com/compose-spec/compose-go/v2/schema/compose-spec.json generated vendored
View File

@ -259,6 +259,20 @@
}
]
},
"provider": {
"type": "object",
"properties": {
"type": {"type": "string"},
"options": {
"type": "object",
"patternProperties": {
"^.+$": {"type": ["string", "number", "null"]}
}
}
},
"additionalProperties": false,
"patternProperties": {"^x-": {}}
},
"external_links": {"type": "array", "items": {"type": "string"}, "uniqueItems": true},
"extra_hosts": {"$ref": "#/definitions/extra_hosts"},
"gpus": {"$ref": "#/definitions/gpus"},
@ -279,7 +293,6 @@
"links": {"type": "array", "items": {"type": "string"}, "uniqueItems": true},
"logging": {
"type": "object",
"properties": {
"driver": {"type": "string"},
"options": {
@ -405,7 +418,9 @@
"type": "object",
"required": ["type"],
"properties": {
"type": {"type": "string"},
"type": {"type": "string",
"enum": ["bind", "volume", "tmpfs", "cluster", "image"]
},
"source": {"type": "string"},
"target": {"type": "string"},
"read_only": {"type": ["boolean", "string"]},
@ -424,6 +439,7 @@
"volume": {
"type": "object",
"properties": {
"labels": {"$ref": "#/definitions/list_or_dict"},
"nocopy": {"type": ["boolean", "string"]},
"subpath": {"type": "string"}
},
@ -443,6 +459,14 @@
},
"additionalProperties": false,
"patternProperties": {"^x-": {}}
},
"image": {
"type": "object",
"properties": {
"subpath": {"type": "string"}
},
"additionalProperties": false,
"patternProperties": {"^x-": {}}
}
},
"additionalProperties": false,

432
vendor/github.com/compose-spec/compose-go/v2/types/derived.gen.go generated vendored
View File

@ -355,9 +355,15 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
}
copy(dst.Entrypoint, src.Entrypoint)
}
if src.Provider == nil {
dst.Provider = nil
} else {
dst.Provider = new(ServiceProviderConfig)
deriveDeepCopy_13(dst.Provider, src.Provider)
}
if src.Environment != nil {
dst.Environment = make(map[string]*string, len(src.Environment))
deriveDeepCopy_13(dst.Environment, src.Environment)
deriveDeepCopy_14(dst.Environment, src.Environment)
} else {
dst.Environment = nil
}
@ -423,7 +429,7 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
}
if src.ExtraHosts != nil {
dst.ExtraHosts = make(map[string][]string, len(src.ExtraHosts))
deriveDeepCopy_14(dst.ExtraHosts, src.ExtraHosts)
deriveDeepCopy_15(dst.ExtraHosts, src.ExtraHosts)
} else {
dst.ExtraHosts = nil
}
@ -461,14 +467,14 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
} else {
dst.Gpus = make([]DeviceRequest, len(src.Gpus))
}
deriveDeepCopy_15(dst.Gpus, src.Gpus)
deriveDeepCopy_16(dst.Gpus, src.Gpus)
}
dst.Hostname = src.Hostname
if src.HealthCheck == nil {
dst.HealthCheck = nil
} else {
dst.HealthCheck = new(HealthCheckConfig)
deriveDeepCopy_16(dst.HealthCheck, src.HealthCheck)
deriveDeepCopy_17(dst.HealthCheck, src.HealthCheck)
}
dst.Image = src.Image
if src.Init == nil {
@ -531,7 +537,7 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
dst.Logging = nil
} else {
dst.Logging = new(LoggingConfig)
deriveDeepCopy_17(dst.Logging, src.Logging)
deriveDeepCopy_18(dst.Logging, src.Logging)
}
dst.LogDriver = src.LogDriver
if src.LogOpt != nil {
@ -549,7 +555,7 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
dst.NetworkMode = src.NetworkMode
if src.Networks != nil {
dst.Networks = make(map[string]*ServiceNetworkConfig, len(src.Networks))
deriveDeepCopy_18(dst.Networks, src.Networks)
deriveDeepCopy_19(dst.Networks, src.Networks)
} else {
dst.Networks = nil
}
@ -574,7 +580,7 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
} else {
dst.Ports = make([]ServicePortConfig, len(src.Ports))
}
deriveDeepCopy_19(dst.Ports, src.Ports)
deriveDeepCopy_20(dst.Ports, src.Ports)
}
dst.Privileged = src.Privileged
dst.PullPolicy = src.PullPolicy
@ -603,7 +609,7 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
} else {
dst.Secrets = make([]ServiceSecretConfig, len(src.Secrets))
}
deriveDeepCopy_20(dst.Secrets, src.Secrets)
deriveDeepCopy_21(dst.Secrets, src.Secrets)
}
if src.SecurityOpt == nil {
dst.SecurityOpt = nil
@ -665,7 +671,7 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
dst.Tty = src.Tty
if src.Ulimits != nil {
dst.Ulimits = make(map[string]*UlimitsConfig, len(src.Ulimits))
deriveDeepCopy_21(dst.Ulimits, src.Ulimits)
deriveDeepCopy_22(dst.Ulimits, src.Ulimits)
} else {
dst.Ulimits = nil
}
@ -689,7 +695,7 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
} else {
dst.Volumes = make([]ServiceVolumeConfig, len(src.Volumes))
}
deriveDeepCopy_22(dst.Volumes, src.Volumes)
deriveDeepCopy_23(dst.Volumes, src.Volumes)
}
if src.VolumesFrom == nil {
dst.VolumesFrom = nil
@ -726,7 +732,7 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
} else {
dst.PostStart = make([]ServiceHook, len(src.PostStart))
}
deriveDeepCopy_23(dst.PostStart, src.PostStart)
deriveDeepCopy_24(dst.PostStart, src.PostStart)
}
if src.PreStop == nil {
dst.PreStop = nil
@ -744,7 +750,7 @@ func deriveDeepCopyService(dst, src *ServiceConfig) {
} else {
dst.PreStop = make([]ServiceHook, len(src.PreStop))
}
deriveDeepCopy_23(dst.PreStop, src.PreStop)
deriveDeepCopy_24(dst.PreStop, src.PreStop)
}
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
@ -770,7 +776,7 @@ func deriveDeepCopy_(dst, src map[string]NetworkConfig) {
for src_key, src_value := range src {
func() {
field := new(NetworkConfig)
deriveDeepCopy_24(field, &src_value)
deriveDeepCopy_25(field, &src_value)
dst[src_key] = *field
}()
}
@ -781,7 +787,7 @@ func deriveDeepCopy_1(dst, src map[string]VolumeConfig) {
for src_key, src_value := range src {
func() {
field := new(VolumeConfig)
deriveDeepCopy_25(field, &src_value)
deriveDeepCopy_26(field, &src_value)
dst[src_key] = *field
}()
}
@ -792,7 +798,7 @@ func deriveDeepCopy_2(dst, src map[string]SecretConfig) {
for src_key, src_value := range src {
func() {
field := new(SecretConfig)
deriveDeepCopy_26(field, &src_value)
deriveDeepCopy_27(field, &src_value)
dst[src_key] = *field
}()
}
@ -803,7 +809,7 @@ func deriveDeepCopy_3(dst, src map[string]ConfigObjConfig) {
for src_key, src_value := range src {
func() {
field := new(ConfigObjConfig)
deriveDeepCopy_27(field, &src_value)
deriveDeepCopy_28(field, &src_value)
dst[src_key] = *field
}()
}
@ -841,7 +847,7 @@ func deriveDeepCopy_5(dst, src *BuildConfig) {
}
if src.Args != nil {
dst.Args = make(map[string]*string, len(src.Args))
deriveDeepCopy_13(dst.Args, src.Args)
deriveDeepCopy_14(dst.Args, src.Args)
} else {
dst.Args = nil
}
@ -915,7 +921,7 @@ func deriveDeepCopy_5(dst, src *BuildConfig) {
dst.Pull = src.Pull
if src.ExtraHosts != nil {
dst.ExtraHosts = make(map[string][]string, len(src.ExtraHosts))
deriveDeepCopy_14(dst.ExtraHosts, src.ExtraHosts)
deriveDeepCopy_15(dst.ExtraHosts, src.ExtraHosts)
} else {
dst.ExtraHosts = nil
}
@ -938,7 +944,7 @@ func deriveDeepCopy_5(dst, src *BuildConfig) {
} else {
dst.Secrets = make([]ServiceSecretConfig, len(src.Secrets))
}
deriveDeepCopy_20(dst.Secrets, src.Secrets)
deriveDeepCopy_21(dst.Secrets, src.Secrets)
}
dst.ShmSize = src.ShmSize
if src.Tags == nil {
@ -961,7 +967,7 @@ func deriveDeepCopy_5(dst, src *BuildConfig) {
}
if src.Ulimits != nil {
dst.Ulimits = make(map[string]*UlimitsConfig, len(src.Ulimits))
deriveDeepCopy_21(dst.Ulimits, src.Ulimits)
deriveDeepCopy_22(dst.Ulimits, src.Ulimits)
} else {
dst.Ulimits = nil
}
@ -1010,7 +1016,7 @@ func deriveDeepCopy_6(dst, src *DevelopConfig) {
} else {
dst.Watch = make([]Trigger, len(src.Watch))
}
deriveDeepCopy_28(dst.Watch, src.Watch)
deriveDeepCopy_29(dst.Watch, src.Watch)
}
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
@ -1039,7 +1045,7 @@ func deriveDeepCopy_7(dst, src *BlkioConfig) {
} else {
dst.WeightDevice = make([]WeightDevice, len(src.WeightDevice))
}
deriveDeepCopy_29(dst.WeightDevice, src.WeightDevice)
deriveDeepCopy_30(dst.WeightDevice, src.WeightDevice)
}
if src.DeviceReadBps == nil {
dst.DeviceReadBps = nil
@ -1057,7 +1063,7 @@ func deriveDeepCopy_7(dst, src *BlkioConfig) {
} else {
dst.DeviceReadBps = make([]ThrottleDevice, len(src.DeviceReadBps))
}
deriveDeepCopy_30(dst.DeviceReadBps, src.DeviceReadBps)
deriveDeepCopy_31(dst.DeviceReadBps, src.DeviceReadBps)
}
if src.DeviceReadIOps == nil {
dst.DeviceReadIOps = nil
@ -1075,7 +1081,7 @@ func deriveDeepCopy_7(dst, src *BlkioConfig) {
} else {
dst.DeviceReadIOps = make([]ThrottleDevice, len(src.DeviceReadIOps))
}
deriveDeepCopy_30(dst.DeviceReadIOps, src.DeviceReadIOps)
deriveDeepCopy_31(dst.DeviceReadIOps, src.DeviceReadIOps)
}
if src.DeviceWriteBps == nil {
dst.DeviceWriteBps = nil
@ -1093,7 +1099,7 @@ func deriveDeepCopy_7(dst, src *BlkioConfig) {
} else {
dst.DeviceWriteBps = make([]ThrottleDevice, len(src.DeviceWriteBps))
}
deriveDeepCopy_30(dst.DeviceWriteBps, src.DeviceWriteBps)
deriveDeepCopy_31(dst.DeviceWriteBps, src.DeviceWriteBps)
}
if src.DeviceWriteIOps == nil {
dst.DeviceWriteIOps = nil
@ -1111,7 +1117,7 @@ func deriveDeepCopy_7(dst, src *BlkioConfig) {
} else {
dst.DeviceWriteIOps = make([]ThrottleDevice, len(src.DeviceWriteIOps))
}
deriveDeepCopy_30(dst.DeviceWriteIOps, src.DeviceWriteIOps)
deriveDeepCopy_31(dst.DeviceWriteIOps, src.DeviceWriteIOps)
}
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
@ -1126,7 +1132,7 @@ func deriveDeepCopy_8(dst, src []ServiceConfigObjConfig) {
for src_i, src_value := range src {
func() {
field := new(ServiceConfigObjConfig)
deriveDeepCopy_31(field, &src_value)
deriveDeepCopy_32(field, &src_value)
dst[src_i] = *field
}()
}
@ -1150,7 +1156,7 @@ func deriveDeepCopy_10(dst, src map[string]ServiceDependency) {
for src_key, src_value := range src {
func() {
field := new(ServiceDependency)
deriveDeepCopy_32(field, &src_value)
deriveDeepCopy_33(field, &src_value)
dst[src_key] = *field
}()
}
@ -1175,28 +1181,28 @@ func deriveDeepCopy_11(dst, src *DeployConfig) {
dst.UpdateConfig = nil
} else {
dst.UpdateConfig = new(UpdateConfig)
deriveDeepCopy_33(dst.UpdateConfig, src.UpdateConfig)
deriveDeepCopy_34(dst.UpdateConfig, src.UpdateConfig)
}
if src.RollbackConfig == nil {
dst.RollbackConfig = nil
} else {
dst.RollbackConfig = new(UpdateConfig)
deriveDeepCopy_33(dst.RollbackConfig, src.RollbackConfig)
deriveDeepCopy_34(dst.RollbackConfig, src.RollbackConfig)
}
func() {
field := new(Resources)
deriveDeepCopy_34(field, &src.Resources)
deriveDeepCopy_35(field, &src.Resources)
dst.Resources = *field
}()
if src.RestartPolicy == nil {
dst.RestartPolicy = nil
} else {
dst.RestartPolicy = new(RestartPolicy)
deriveDeepCopy_35(dst.RestartPolicy, src.RestartPolicy)
deriveDeepCopy_36(dst.RestartPolicy, src.RestartPolicy)
}
func() {
field := new(Placement)
deriveDeepCopy_36(field, &src.Placement)
deriveDeepCopy_37(field, &src.Placement)
dst.Placement = *field
}()
dst.EndpointMode = src.EndpointMode
@ -1213,14 +1219,31 @@ func deriveDeepCopy_12(dst, src []DeviceMapping) {
for src_i, src_value := range src {
func() {
field := new(DeviceMapping)
deriveDeepCopy_37(field, &src_value)
deriveDeepCopy_38(field, &src_value)
dst[src_i] = *field
}()
}
}
// deriveDeepCopy_13 recursively copies the contents of src into dst.
func deriveDeepCopy_13(dst, src map[string]*string) {
func deriveDeepCopy_13(dst, src *ServiceProviderConfig) {
dst.Type = src.Type
if src.Options != nil {
dst.Options = make(map[string]string, len(src.Options))
deriveDeepCopy_4(dst.Options, src.Options)
} else {
dst.Options = nil
}
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
src.Extensions.DeepCopy(dst.Extensions)
} else {
dst.Extensions = nil
}
}
// deriveDeepCopy_14 recursively copies the contents of src into dst.
func deriveDeepCopy_14(dst, src map[string]*string) {
for src_key, src_value := range src {
if src_value == nil {
dst[src_key] = nil
@ -1234,8 +1257,8 @@ func deriveDeepCopy_13(dst, src map[string]*string) {
}
}
// deriveDeepCopy_14 recursively copies the contents of src into dst.
func deriveDeepCopy_14(dst, src map[string][]string) {
// deriveDeepCopy_15 recursively copies the contents of src into dst.
func deriveDeepCopy_15(dst, src map[string][]string) {
for src_key, src_value := range src {
if src_value == nil {
dst[src_key] = nil
@ -1261,19 +1284,19 @@ func deriveDeepCopy_14(dst, src map[string][]string) {
}
}
// deriveDeepCopy_15 recursively copies the contents of src into dst.
func deriveDeepCopy_15(dst, src []DeviceRequest) {
// deriveDeepCopy_16 recursively copies the contents of src into dst.
func deriveDeepCopy_16(dst, src []DeviceRequest) {
for src_i, src_value := range src {
func() {
field := new(DeviceRequest)
deriveDeepCopy_38(field, &src_value)
deriveDeepCopy_39(field, &src_value)
dst[src_i] = *field
}()
}
}
// deriveDeepCopy_16 recursively copies the contents of src into dst.
func deriveDeepCopy_16(dst, src *HealthCheckConfig) {
// deriveDeepCopy_17 recursively copies the contents of src into dst.
func deriveDeepCopy_17(dst, src *HealthCheckConfig) {
if src.Test == nil {
dst.Test = nil
} else {
@ -1331,8 +1354,8 @@ func deriveDeepCopy_16(dst, src *HealthCheckConfig) {
}
}
// deriveDeepCopy_17 recursively copies the contents of src into dst.
func deriveDeepCopy_17(dst, src *LoggingConfig) {
// deriveDeepCopy_18 recursively copies the contents of src into dst.
func deriveDeepCopy_18(dst, src *LoggingConfig) {
dst.Driver = src.Driver
if src.Options != nil {
dst.Options = make(map[string]string, len(src.Options))
@ -1348,8 +1371,8 @@ func deriveDeepCopy_17(dst, src *LoggingConfig) {
}
}
// deriveDeepCopy_18 recursively copies the contents of src into dst.
func deriveDeepCopy_18(dst, src map[string]*ServiceNetworkConfig) {
// deriveDeepCopy_19 recursively copies the contents of src into dst.
func deriveDeepCopy_19(dst, src map[string]*ServiceNetworkConfig) {
for src_key, src_value := range src {
if src_value == nil {
dst[src_key] = nil
@ -1358,27 +1381,16 @@ func deriveDeepCopy_18(dst, src map[string]*ServiceNetworkConfig) {
dst[src_key] = nil
} else {
dst[src_key] = new(ServiceNetworkConfig)
deriveDeepCopy_39(dst[src_key], src_value)
deriveDeepCopy_40(dst[src_key], src_value)
}
}
}
// deriveDeepCopy_19 recursively copies the contents of src into dst.
func deriveDeepCopy_19(dst, src []ServicePortConfig) {
// deriveDeepCopy_20 recursively copies the contents of src into dst.
func deriveDeepCopy_20(dst, src []ServicePortConfig) {
for src_i, src_value := range src {
func() {
field := new(ServicePortConfig)
deriveDeepCopy_40(field, &src_value)
dst[src_i] = *field
}()
}
}
// deriveDeepCopy_20 recursively copies the contents of src into dst.
func deriveDeepCopy_20(dst, src []ServiceSecretConfig) {
for src_i, src_value := range src {
func() {
field := new(ServiceSecretConfig)
deriveDeepCopy_41(field, &src_value)
dst[src_i] = *field
}()
@ -1386,7 +1398,18 @@ func deriveDeepCopy_20(dst, src []ServiceSecretConfig) {
}
// deriveDeepCopy_21 recursively copies the contents of src into dst.
func deriveDeepCopy_21(dst, src map[string]*UlimitsConfig) {
func deriveDeepCopy_21(dst, src []ServiceSecretConfig) {
for src_i, src_value := range src {
func() {
field := new(ServiceSecretConfig)
deriveDeepCopy_42(field, &src_value)
dst[src_i] = *field
}()
}
}
// deriveDeepCopy_22 recursively copies the contents of src into dst.
func deriveDeepCopy_22(dst, src map[string]*UlimitsConfig) {
for src_key, src_value := range src {
if src_value == nil {
dst[src_key] = nil
@ -1395,27 +1418,16 @@ func deriveDeepCopy_21(dst, src map[string]*UlimitsConfig) {
dst[src_key] = nil
} else {
dst[src_key] = new(UlimitsConfig)
deriveDeepCopy_42(dst[src_key], src_value)
deriveDeepCopy_43(dst[src_key], src_value)
}
}
}
// deriveDeepCopy_22 recursively copies the contents of src into dst.
func deriveDeepCopy_22(dst, src []ServiceVolumeConfig) {
// deriveDeepCopy_23 recursively copies the contents of src into dst.
func deriveDeepCopy_23(dst, src []ServiceVolumeConfig) {
for src_i, src_value := range src {
func() {
field := new(ServiceVolumeConfig)
deriveDeepCopy_43(field, &src_value)
dst[src_i] = *field
}()
}
}
// deriveDeepCopy_23 recursively copies the contents of src into dst.
func deriveDeepCopy_23(dst, src []ServiceHook) {
for src_i, src_value := range src {
func() {
field := new(ServiceHook)
deriveDeepCopy_44(field, &src_value)
dst[src_i] = *field
}()
@ -1423,7 +1435,18 @@ func deriveDeepCopy_23(dst, src []ServiceHook) {
}
// deriveDeepCopy_24 recursively copies the contents of src into dst.
func deriveDeepCopy_24(dst, src *NetworkConfig) {
func deriveDeepCopy_24(dst, src []ServiceHook) {
for src_i, src_value := range src {
func() {
field := new(ServiceHook)
deriveDeepCopy_45(field, &src_value)
dst[src_i] = *field
}()
}
}
// deriveDeepCopy_25 recursively copies the contents of src into dst.
func deriveDeepCopy_25(dst, src *NetworkConfig) {
dst.Name = src.Name
dst.Driver = src.Driver
if src.DriverOpts != nil {
@ -1434,7 +1457,7 @@ func deriveDeepCopy_24(dst, src *NetworkConfig) {
}
func() {
field := new(IPAMConfig)
deriveDeepCopy_45(field, &src.Ipam)
deriveDeepCopy_46(field, &src.Ipam)
dst.Ipam = *field
}()
dst.External = src.External
@ -1472,8 +1495,8 @@ func deriveDeepCopy_24(dst, src *NetworkConfig) {
}
}
// deriveDeepCopy_25 recursively copies the contents of src into dst.
func deriveDeepCopy_25(dst, src *VolumeConfig) {
// deriveDeepCopy_26 recursively copies the contents of src into dst.
func deriveDeepCopy_26(dst, src *VolumeConfig) {
dst.Name = src.Name
dst.Driver = src.Driver
if src.DriverOpts != nil {
@ -1503,38 +1526,8 @@ func deriveDeepCopy_25(dst, src *VolumeConfig) {
}
}
// deriveDeepCopy_26 recursively copies the contents of src into dst.
func deriveDeepCopy_26(dst, src *SecretConfig) {
dst.Name = src.Name
dst.File = src.File
dst.Environment = src.Environment
dst.Content = src.Content
dst.marshallContent = src.marshallContent
dst.External = src.External
if src.Labels != nil {
dst.Labels = make(map[string]string, len(src.Labels))
deriveDeepCopy_4(dst.Labels, src.Labels)
} else {
dst.Labels = nil
}
dst.Driver = src.Driver
if src.DriverOpts != nil {
dst.DriverOpts = make(map[string]string, len(src.DriverOpts))
deriveDeepCopy_4(dst.DriverOpts, src.DriverOpts)
} else {
dst.DriverOpts = nil
}
dst.TemplateDriver = src.TemplateDriver
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
src.Extensions.DeepCopy(dst.Extensions)
} else {
dst.Extensions = nil
}
}
// deriveDeepCopy_27 recursively copies the contents of src into dst.
func deriveDeepCopy_27(dst, src *ConfigObjConfig) {
func deriveDeepCopy_27(dst, src *SecretConfig) {
dst.Name = src.Name
dst.File = src.File
dst.Environment = src.Environment
@ -1564,21 +1557,40 @@ func deriveDeepCopy_27(dst, src *ConfigObjConfig) {
}
// deriveDeepCopy_28 recursively copies the contents of src into dst.
func deriveDeepCopy_28(dst, src []Trigger) {
for src_i, src_value := range src {
func() {
field := new(Trigger)
deriveDeepCopy_46(field, &src_value)
dst[src_i] = *field
}()
func deriveDeepCopy_28(dst, src *ConfigObjConfig) {
dst.Name = src.Name
dst.File = src.File
dst.Environment = src.Environment
dst.Content = src.Content
dst.marshallContent = src.marshallContent
dst.External = src.External
if src.Labels != nil {
dst.Labels = make(map[string]string, len(src.Labels))
deriveDeepCopy_4(dst.Labels, src.Labels)
} else {
dst.Labels = nil
}
dst.Driver = src.Driver
if src.DriverOpts != nil {
dst.DriverOpts = make(map[string]string, len(src.DriverOpts))
deriveDeepCopy_4(dst.DriverOpts, src.DriverOpts)
} else {
dst.DriverOpts = nil
}
dst.TemplateDriver = src.TemplateDriver
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
src.Extensions.DeepCopy(dst.Extensions)
} else {
dst.Extensions = nil
}
}
// deriveDeepCopy_29 recursively copies the contents of src into dst.
func deriveDeepCopy_29(dst, src []WeightDevice) {
func deriveDeepCopy_29(dst, src []Trigger) {
for src_i, src_value := range src {
func() {
field := new(WeightDevice)
field := new(Trigger)
deriveDeepCopy_47(field, &src_value)
dst[src_i] = *field
}()
@ -1586,10 +1598,10 @@ func deriveDeepCopy_29(dst, src []WeightDevice) {
}
// deriveDeepCopy_30 recursively copies the contents of src into dst.
func deriveDeepCopy_30(dst, src []ThrottleDevice) {
func deriveDeepCopy_30(dst, src []WeightDevice) {
for src_i, src_value := range src {
func() {
field := new(ThrottleDevice)
field := new(WeightDevice)
deriveDeepCopy_48(field, &src_value)
dst[src_i] = *field
}()
@ -1597,7 +1609,18 @@ func deriveDeepCopy_30(dst, src []ThrottleDevice) {
}
// deriveDeepCopy_31 recursively copies the contents of src into dst.
func deriveDeepCopy_31(dst, src *ServiceConfigObjConfig) {
func deriveDeepCopy_31(dst, src []ThrottleDevice) {
for src_i, src_value := range src {
func() {
field := new(ThrottleDevice)
deriveDeepCopy_49(field, &src_value)
dst[src_i] = *field
}()
}
}
// deriveDeepCopy_32 recursively copies the contents of src into dst.
func deriveDeepCopy_32(dst, src *ServiceConfigObjConfig) {
dst.Source = src.Source
dst.Target = src.Target
dst.UID = src.UID
@ -1616,8 +1639,8 @@ func deriveDeepCopy_31(dst, src *ServiceConfigObjConfig) {
}
}
// deriveDeepCopy_32 recursively copies the contents of src into dst.
func deriveDeepCopy_32(dst, src *ServiceDependency) {
// deriveDeepCopy_33 recursively copies the contents of src into dst.
func deriveDeepCopy_33(dst, src *ServiceDependency) {
dst.Condition = src.Condition
dst.Restart = src.Restart
if src.Extensions != nil {
@ -1629,8 +1652,8 @@ func deriveDeepCopy_32(dst, src *ServiceDependency) {
dst.Required = src.Required
}
// deriveDeepCopy_33 recursively copies the contents of src into dst.
func deriveDeepCopy_33(dst, src *UpdateConfig) {
// deriveDeepCopy_34 recursively copies the contents of src into dst.
func deriveDeepCopy_34(dst, src *UpdateConfig) {
if src.Parallelism == nil {
dst.Parallelism = nil
} else {
@ -1650,19 +1673,19 @@ func deriveDeepCopy_33(dst, src *UpdateConfig) {
}
}
// deriveDeepCopy_34 recursively copies the contents of src into dst.
func deriveDeepCopy_34(dst, src *Resources) {
// deriveDeepCopy_35 recursively copies the contents of src into dst.
func deriveDeepCopy_35(dst, src *Resources) {
if src.Limits == nil {
dst.Limits = nil
} else {
dst.Limits = new(Resource)
deriveDeepCopy_49(dst.Limits, src.Limits)
deriveDeepCopy_50(dst.Limits, src.Limits)
}
if src.Reservations == nil {
dst.Reservations = nil
} else {
dst.Reservations = new(Resource)
deriveDeepCopy_49(dst.Reservations, src.Reservations)
deriveDeepCopy_50(dst.Reservations, src.Reservations)
}
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
@ -1672,8 +1695,8 @@ func deriveDeepCopy_34(dst, src *Resources) {
}
}
// deriveDeepCopy_35 recursively copies the contents of src into dst.
func deriveDeepCopy_35(dst, src *RestartPolicy) {
// deriveDeepCopy_36 recursively copies the contents of src into dst.
func deriveDeepCopy_36(dst, src *RestartPolicy) {
dst.Condition = src.Condition
if src.Delay == nil {
dst.Delay = nil
@ -1701,8 +1724,8 @@ func deriveDeepCopy_35(dst, src *RestartPolicy) {
}
}
// deriveDeepCopy_36 recursively copies the contents of src into dst.
func deriveDeepCopy_36(dst, src *Placement) {
// deriveDeepCopy_37 recursively copies the contents of src into dst.
func deriveDeepCopy_37(dst, src *Placement) {
if src.Constraints == nil {
dst.Constraints = nil
} else {
@ -1737,7 +1760,7 @@ func deriveDeepCopy_36(dst, src *Placement) {
} else {
dst.Preferences = make([]PlacementPreferences, len(src.Preferences))
}
deriveDeepCopy_50(dst.Preferences, src.Preferences)
deriveDeepCopy_51(dst.Preferences, src.Preferences)
}
dst.MaxReplicas = src.MaxReplicas
if src.Extensions != nil {
@ -1748,8 +1771,8 @@ func deriveDeepCopy_36(dst, src *Placement) {
}
}
// deriveDeepCopy_37 recursively copies the contents of src into dst.
func deriveDeepCopy_37(dst, src *DeviceMapping) {
// deriveDeepCopy_38 recursively copies the contents of src into dst.
func deriveDeepCopy_38(dst, src *DeviceMapping) {
dst.Source = src.Source
dst.Target = src.Target
dst.Permissions = src.Permissions
@ -1761,8 +1784,8 @@ func deriveDeepCopy_37(dst, src *DeviceMapping) {
}
}
// deriveDeepCopy_38 recursively copies the contents of src into dst.
func deriveDeepCopy_38(dst, src *DeviceRequest) {
// deriveDeepCopy_39 recursively copies the contents of src into dst.
func deriveDeepCopy_39(dst, src *DeviceRequest) {
if src.Capabilities == nil {
dst.Capabilities = nil
} else {
@ -1809,8 +1832,8 @@ func deriveDeepCopy_38(dst, src *DeviceRequest) {
}
}
// deriveDeepCopy_39 recursively copies the contents of src into dst.
func deriveDeepCopy_39(dst, src *ServiceNetworkConfig) {
// deriveDeepCopy_40 recursively copies the contents of src into dst.
func deriveDeepCopy_40(dst, src *ServiceNetworkConfig) {
dst.Priority = src.Priority
dst.GatewayPriority = src.GatewayPriority
if src.Aliases == nil {
@ -1866,8 +1889,8 @@ func deriveDeepCopy_39(dst, src *ServiceNetworkConfig) {
}
}
// deriveDeepCopy_40 recursively copies the contents of src into dst.
func deriveDeepCopy_40(dst, src *ServicePortConfig) {
// deriveDeepCopy_41 recursively copies the contents of src into dst.
func deriveDeepCopy_41(dst, src *ServicePortConfig) {
dst.Name = src.Name
dst.Mode = src.Mode
dst.HostIP = src.HostIP
@ -1883,8 +1906,8 @@ func deriveDeepCopy_40(dst, src *ServicePortConfig) {
}
}
// deriveDeepCopy_41 recursively copies the contents of src into dst.
func deriveDeepCopy_41(dst, src *ServiceSecretConfig) {
// deriveDeepCopy_42 recursively copies the contents of src into dst.
func deriveDeepCopy_42(dst, src *ServiceSecretConfig) {
dst.Source = src.Source
dst.Target = src.Target
dst.UID = src.UID
@ -1903,8 +1926,8 @@ func deriveDeepCopy_41(dst, src *ServiceSecretConfig) {
}
}
// deriveDeepCopy_42 recursively copies the contents of src into dst.
func deriveDeepCopy_42(dst, src *UlimitsConfig) {
// deriveDeepCopy_43 recursively copies the contents of src into dst.
func deriveDeepCopy_43(dst, src *UlimitsConfig) {
dst.Single = src.Single
dst.Soft = src.Soft
dst.Hard = src.Hard
@ -1916,8 +1939,8 @@ func deriveDeepCopy_42(dst, src *UlimitsConfig) {
}
}
// deriveDeepCopy_43 recursively copies the contents of src into dst.
func deriveDeepCopy_43(dst, src *ServiceVolumeConfig) {
// deriveDeepCopy_44 recursively copies the contents of src into dst.
func deriveDeepCopy_44(dst, src *ServiceVolumeConfig) {
dst.Type = src.Type
dst.Source = src.Source
dst.Target = src.Target
@ -1927,19 +1950,25 @@ func deriveDeepCopy_43(dst, src *ServiceVolumeConfig) {
dst.Bind = nil
} else {
dst.Bind = new(ServiceVolumeBind)
deriveDeepCopy_51(dst.Bind, src.Bind)
deriveDeepCopy_52(dst.Bind, src.Bind)
}
if src.Volume == nil {
dst.Volume = nil
} else {
dst.Volume = new(ServiceVolumeVolume)
deriveDeepCopy_52(dst.Volume, src.Volume)
deriveDeepCopy_53(dst.Volume, src.Volume)
}
if src.Tmpfs == nil {
dst.Tmpfs = nil
} else {
dst.Tmpfs = new(ServiceVolumeTmpfs)
deriveDeepCopy_53(dst.Tmpfs, src.Tmpfs)
deriveDeepCopy_54(dst.Tmpfs, src.Tmpfs)
}
if src.Image == nil {
dst.Image = nil
} else {
dst.Image = new(ServiceVolumeImage)
deriveDeepCopy_55(dst.Image, src.Image)
}
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
@ -1949,8 +1978,8 @@ func deriveDeepCopy_43(dst, src *ServiceVolumeConfig) {
}
}
// deriveDeepCopy_44 recursively copies the contents of src into dst.
func deriveDeepCopy_44(dst, src *ServiceHook) {
// deriveDeepCopy_45 recursively copies the contents of src into dst.
func deriveDeepCopy_45(dst, src *ServiceHook) {
if src.Command == nil {
dst.Command = nil
} else {
@ -1974,7 +2003,7 @@ func deriveDeepCopy_44(dst, src *ServiceHook) {
dst.WorkingDir = src.WorkingDir
if src.Environment != nil {
dst.Environment = make(map[string]*string, len(src.Environment))
deriveDeepCopy_13(dst.Environment, src.Environment)
deriveDeepCopy_14(dst.Environment, src.Environment)
} else {
dst.Environment = nil
}
@ -1986,8 +2015,8 @@ func deriveDeepCopy_44(dst, src *ServiceHook) {
}
}
// deriveDeepCopy_45 recursively copies the contents of src into dst.
func deriveDeepCopy_45(dst, src *IPAMConfig) {
// deriveDeepCopy_46 recursively copies the contents of src into dst.
func deriveDeepCopy_46(dst, src *IPAMConfig) {
dst.Driver = src.Driver
if src.Config == nil {
dst.Config = nil
@ -2005,7 +2034,7 @@ func deriveDeepCopy_45(dst, src *IPAMConfig) {
} else {
dst.Config = make([]*IPAMPool, len(src.Config))
}
deriveDeepCopy_54(dst.Config, src.Config)
deriveDeepCopy_56(dst.Config, src.Config)
}
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
@ -2015,14 +2044,14 @@ func deriveDeepCopy_45(dst, src *IPAMConfig) {
}
}
// deriveDeepCopy_46 recursively copies the contents of src into dst.
func deriveDeepCopy_46(dst, src *Trigger) {
// deriveDeepCopy_47 recursively copies the contents of src into dst.
func deriveDeepCopy_47(dst, src *Trigger) {
dst.Path = src.Path
dst.Action = src.Action
dst.Target = src.Target
func() {
field := new(ServiceHook)
deriveDeepCopy_44(field, &src.Exec)
deriveDeepCopy_45(field, &src.Exec)
dst.Exec = *field
}()
if src.Include == nil {
@ -2069,8 +2098,8 @@ func deriveDeepCopy_46(dst, src *Trigger) {
}
}
// deriveDeepCopy_47 recursively copies the contents of src into dst.
func deriveDeepCopy_47(dst, src *WeightDevice) {
// deriveDeepCopy_48 recursively copies the contents of src into dst.
func deriveDeepCopy_48(dst, src *WeightDevice) {
dst.Path = src.Path
dst.Weight = src.Weight
if src.Extensions != nil {
@ -2081,8 +2110,8 @@ func deriveDeepCopy_47(dst, src *WeightDevice) {
}
}
// deriveDeepCopy_48 recursively copies the contents of src into dst.
func deriveDeepCopy_48(dst, src *ThrottleDevice) {
// deriveDeepCopy_49 recursively copies the contents of src into dst.
func deriveDeepCopy_49(dst, src *ThrottleDevice) {
dst.Path = src.Path
dst.Rate = src.Rate
if src.Extensions != nil {
@ -2093,8 +2122,8 @@ func deriveDeepCopy_48(dst, src *ThrottleDevice) {
}
}
// deriveDeepCopy_49 recursively copies the contents of src into dst.
func deriveDeepCopy_49(dst, src *Resource) {
// deriveDeepCopy_50 recursively copies the contents of src into dst.
func deriveDeepCopy_50(dst, src *Resource) {
dst.NanoCPUs = src.NanoCPUs
dst.MemoryBytes = src.MemoryBytes
dst.Pids = src.Pids
@ -2114,7 +2143,7 @@ func deriveDeepCopy_49(dst, src *Resource) {
} else {
dst.Devices = make([]DeviceRequest, len(src.Devices))
}
deriveDeepCopy_15(dst.Devices, src.Devices)
deriveDeepCopy_16(dst.Devices, src.Devices)
}
if src.GenericResources == nil {
dst.GenericResources = nil
@ -2132,7 +2161,7 @@ func deriveDeepCopy_49(dst, src *Resource) {
} else {
dst.GenericResources = make([]GenericResource, len(src.GenericResources))
}
deriveDeepCopy_55(dst.GenericResources, src.GenericResources)
deriveDeepCopy_57(dst.GenericResources, src.GenericResources)
}
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
@ -2142,19 +2171,19 @@ func deriveDeepCopy_49(dst, src *Resource) {
}
}
// deriveDeepCopy_50 recursively copies the contents of src into dst.
func deriveDeepCopy_50(dst, src []PlacementPreferences) {
// deriveDeepCopy_51 recursively copies the contents of src into dst.
func deriveDeepCopy_51(dst, src []PlacementPreferences) {
for src_i, src_value := range src {
func() {
field := new(PlacementPreferences)
deriveDeepCopy_56(field, &src_value)
deriveDeepCopy_58(field, &src_value)
dst[src_i] = *field
}()
}
}
// deriveDeepCopy_51 recursively copies the contents of src into dst.
func deriveDeepCopy_51(dst, src *ServiceVolumeBind) {
// deriveDeepCopy_52 recursively copies the contents of src into dst.
func deriveDeepCopy_52(dst, src *ServiceVolumeBind) {
dst.SELinux = src.SELinux
dst.Propagation = src.Propagation
dst.CreateHostPath = src.CreateHostPath
@ -2167,8 +2196,14 @@ func deriveDeepCopy_51(dst, src *ServiceVolumeBind) {
}
}
// deriveDeepCopy_52 recursively copies the contents of src into dst.
func deriveDeepCopy_52(dst, src *ServiceVolumeVolume) {
// deriveDeepCopy_53 recursively copies the contents of src into dst.
func deriveDeepCopy_53(dst, src *ServiceVolumeVolume) {
if src.Labels != nil {
dst.Labels = make(map[string]string, len(src.Labels))
deriveDeepCopy_4(dst.Labels, src.Labels)
} else {
dst.Labels = nil
}
dst.NoCopy = src.NoCopy
dst.Subpath = src.Subpath
if src.Extensions != nil {
@ -2179,8 +2214,8 @@ func deriveDeepCopy_52(dst, src *ServiceVolumeVolume) {
}
}
// deriveDeepCopy_53 recursively copies the contents of src into dst.
func deriveDeepCopy_53(dst, src *ServiceVolumeTmpfs) {
// deriveDeepCopy_54 recursively copies the contents of src into dst.
func deriveDeepCopy_54(dst, src *ServiceVolumeTmpfs) {
dst.Size = src.Size
dst.Mode = src.Mode
if src.Extensions != nil {
@ -2191,31 +2226,42 @@ func deriveDeepCopy_53(dst, src *ServiceVolumeTmpfs) {
}
}
// deriveDeepCopy_54 recursively copies the contents of src into dst.
func deriveDeepCopy_54(dst, src []*IPAMPool) {
// deriveDeepCopy_55 recursively copies the contents of src into dst.
func deriveDeepCopy_55(dst, src *ServiceVolumeImage) {
dst.SubPath = src.SubPath
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
src.Extensions.DeepCopy(dst.Extensions)
} else {
dst.Extensions = nil
}
}
// deriveDeepCopy_56 recursively copies the contents of src into dst.
func deriveDeepCopy_56(dst, src []*IPAMPool) {
for src_i, src_value := range src {
if src_value == nil {
dst[src_i] = nil
} else {
dst[src_i] = new(IPAMPool)
deriveDeepCopy_57(dst[src_i], src_value)
deriveDeepCopy_59(dst[src_i], src_value)
}
}
}
// deriveDeepCopy_55 recursively copies the contents of src into dst.
func deriveDeepCopy_55(dst, src []GenericResource) {
// deriveDeepCopy_57 recursively copies the contents of src into dst.
func deriveDeepCopy_57(dst, src []GenericResource) {
for src_i, src_value := range src {
func() {
field := new(GenericResource)
deriveDeepCopy_58(field, &src_value)
deriveDeepCopy_60(field, &src_value)
dst[src_i] = *field
}()
}
}
// deriveDeepCopy_56 recursively copies the contents of src into dst.
func deriveDeepCopy_56(dst, src *PlacementPreferences) {
// deriveDeepCopy_58 recursively copies the contents of src into dst.
func deriveDeepCopy_58(dst, src *PlacementPreferences) {
dst.Spread = src.Spread
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
@ -2225,8 +2271,8 @@ func deriveDeepCopy_56(dst, src *PlacementPreferences) {
}
}
// deriveDeepCopy_57 recursively copies the contents of src into dst.
func deriveDeepCopy_57(dst, src *IPAMPool) {
// deriveDeepCopy_59 recursively copies the contents of src into dst.
func deriveDeepCopy_59(dst, src *IPAMPool) {
dst.Subnet = src.Subnet
dst.Gateway = src.Gateway
dst.IPRange = src.IPRange
@ -2244,13 +2290,13 @@ func deriveDeepCopy_57(dst, src *IPAMPool) {
}
}
// deriveDeepCopy_58 recursively copies the contents of src into dst.
func deriveDeepCopy_58(dst, src *GenericResource) {
// deriveDeepCopy_60 recursively copies the contents of src into dst.
func deriveDeepCopy_60(dst, src *GenericResource) {
if src.DiscreteResourceSpec == nil {
dst.DiscreteResourceSpec = nil
} else {
dst.DiscreteResourceSpec = new(DiscreteGenericResource)
deriveDeepCopy_59(dst.DiscreteResourceSpec, src.DiscreteResourceSpec)
deriveDeepCopy_61(dst.DiscreteResourceSpec, src.DiscreteResourceSpec)
}
if src.Extensions != nil {
dst.Extensions = make(map[string]any, len(src.Extensions))
@ -2260,8 +2306,8 @@ func deriveDeepCopy_58(dst, src *GenericResource) {
}
}
// deriveDeepCopy_59 recursively copies the contents of src into dst.
func deriveDeepCopy_59(dst, src *DiscreteGenericResource) {
// deriveDeepCopy_61 recursively copies the contents of src into dst.
func deriveDeepCopy_61(dst, src *DiscreteGenericResource) {
dst.Kind = src.Kind
dst.Value = src.Value
if src.Extensions != nil {

99
vendor/github.com/compose-spec/compose-go/v2/types/project.go generated vendored
View File

@ -21,8 +21,10 @@ import (
"context"
"encoding/json"
"fmt"
"maps"
"os"
"path/filepath"
"slices"
"sort"
"github.com/compose-spec/compose-go/v2/dotenv"
@ -30,7 +32,6 @@ import (
"github.com/compose-spec/compose-go/v2/utils"
"github.com/distribution/reference"
godigest "github.com/opencontainers/go-digest"
"golang.org/x/exp/maps"
"golang.org/x/sync/errgroup"
"gopkg.in/yaml.v3"
)
@ -120,21 +121,21 @@ func (p *Project) ServicesWithBuild() []string {
servicesBuild := p.Services.Filter(func(s ServiceConfig) bool {
return s.Build != nil && s.Build.Context != ""
})
return maps.Keys(servicesBuild)
return slices.Collect(maps.Keys(servicesBuild))
}
func (p *Project) ServicesWithExtends() []string {
servicesExtends := p.Services.Filter(func(s ServiceConfig) bool {
return s.Extends != nil && *s.Extends != (ExtendsConfig{})
})
return maps.Keys(servicesExtends)
return slices.Collect(maps.Keys(servicesExtends))
}
func (p *Project) ServicesWithDependsOn() []string {
servicesDependsOn := p.Services.Filter(func(s ServiceConfig) bool {
return len(s.DependsOn) > 0
})
return maps.Keys(servicesDependsOn)
return slices.Collect(maps.Keys(servicesDependsOn))
}
func (p *Project) ServicesWithCapabilities() ([]string, []string, []string) {
@ -156,9 +157,10 @@ func (p *Project) ServicesWithCapabilities() ([]string, []string, []string) {
capabilities = append(capabilities, service.Name)
}
for _, c := range d.Capabilities {
if c == "gpu" {
switch c {
case "gpu":
gpu = append(gpu, service.Name)
} else if c == "tpu" {
case "tpu":
tpu = append(tpu, service.Name)
}
}
@ -188,16 +190,25 @@ func (p *Project) getServicesByNames(names ...string) (Services, []string) {
if len(names) == 0 {
return p.Services, nil
}
services := Services{}
var servicesNotFound []string
for _, name := range names {
service, ok := p.Services[name]
if !ok {
servicesNotFound = append(servicesNotFound, name)
continue
matched := false
for serviceName, service := range p.Services {
match, _ := filepath.Match(name, serviceName)
if match {
services[serviceName] = service
matched = true
}
}
if !matched {
servicesNotFound = append(servicesNotFound, name)
}
services[name] = service
}
return services, servicesNotFound
}
@ -298,16 +309,25 @@ func (p *Project) withServices(names []string, fn ServiceFunc, seen map[string]b
return nil
}
func (p *Project) GetDependentsForService(s ServiceConfig) []string {
return utils.MapKeys(p.dependentsForService(s))
func (p *Project) GetDependentsForService(s ServiceConfig, filter ...func(ServiceDependency) bool) []string {
return utils.MapKeys(p.dependentsForService(s, filter...))
}
func (p *Project) dependentsForService(s ServiceConfig) map[string]ServiceDependency {
func (p *Project) dependentsForService(s ServiceConfig, filter ...func(ServiceDependency) bool) map[string]ServiceDependency {
dependent := make(map[string]ServiceDependency)
for _, service := range p.Services {
for name, dependency := range service.DependsOn {
if name == s.Name {
dependent[service.Name] = dependency
depends := true
for _, f := range filter {
if !f(dependency) {
depends = false
break
}
}
if depends {
dependent[service.Name] = dependency
}
}
}
}
@ -630,25 +650,25 @@ func (p Project) WithServicesEnvironmentResolved(discardEnvFiles bool) (*Project
for i, service := range newProject.Services {
service.Environment = service.Environment.Resolve(newProject.Environment.Resolve)
environment := MappingWithEquals{}
// resolve variables based on other files we already parsed, + project's environment
var resolve dotenv.LookupFn = func(s string) (string, bool) {
v, ok := environment[s]
if ok && v != nil {
return *v, ok
}
return newProject.Environment.Resolve(s)
}
environment := service.Environment.ToMapping()
for _, envFile := range service.EnvFiles {
vars, err := loadEnvFile(envFile, resolve)
err := loadEnvFile(envFile, environment, func(k string) (string, bool) {
// project.env has precedence doing interpolation
if resolve, ok := p.Environment.Resolve(k); ok {
return resolve, true
}
// then service.environment
if s, ok := service.Environment[k]; ok {
return *s, true
}
return "", false
})
if err != nil {
return nil, err
}
environment.OverrideBy(vars.ToMappingWithEquals())
}
service.Environment = environment.OverrideBy(service.Environment)
service.Environment = environment.ToMappingWithEquals().OverrideBy(service.Environment)
if discardEnvFiles {
service.EnvFiles = nil
@ -696,15 +716,16 @@ func (p Project) WithServicesLabelsResolved(discardLabelFiles bool) (*Project, e
return newProject, nil
}
func loadEnvFile(envFile EnvFile, resolve dotenv.LookupFn) (Mapping, error) {
func loadEnvFile(envFile EnvFile, environment Mapping, resolve dotenv.LookupFn) error {
if _, err := os.Stat(envFile.Path); os.IsNotExist(err) {
if envFile.Required {
return nil, fmt.Errorf("env file %s not found: %w", envFile.Path, err)
return fmt.Errorf("env file %s not found: %w", envFile.Path, err)
}
return nil, nil
return nil
}
return loadMappingFile(envFile.Path, envFile.Format, resolve)
err := loadMappingFile(envFile.Path, envFile.Format, environment, resolve)
return err
}
func loadLabelFile(labelFile string, resolve dotenv.LookupFn) (Mapping, error) {
@ -712,21 +733,19 @@ func loadLabelFile(labelFile string, resolve dotenv.LookupFn) (Mapping, error) {
return nil, fmt.Errorf("label file %s not found: %w", labelFile, err)
}
return loadMappingFile(labelFile, "", resolve)
labels := Mapping{}
err := loadMappingFile(labelFile, "", labels, resolve)
return labels, err
}
func loadMappingFile(path string, format string, resolve dotenv.LookupFn) (Mapping, error) {
func loadMappingFile(path string, format string, vars Mapping, resolve dotenv.LookupFn) error {
file, err := os.Open(path)
if err != nil {
return nil, err
return err
}
defer file.Close()
fileVars, err := dotenv.ParseWithFormat(file, path, resolve, format)
if err != nil {
return nil, err
}
return fileVars, nil
return dotenv.ParseWithFormat(file, path, vars, resolve, format)
}
func (p *Project) deepCopy() *Project {

23
vendor/github.com/compose-spec/compose-go/v2/types/types.go generated vendored
View File

@ -75,8 +75,8 @@ type ServiceConfig struct {
// If set, overrides ENTRYPOINT from the image.
//
// Set to `[]` or an empty string to clear the entrypoint from the image.
Entrypoint ShellCommand `yaml:"entrypoint,omitempty" json:"entrypoint"` // NOTE: we can NOT omitempty for JSON! see ShellCommand type for details.
Entrypoint ShellCommand `yaml:"entrypoint,omitempty" json:"entrypoint"` // NOTE: we can NOT omitempty for JSON! see ShellCommand type for details.
Provider *ServiceProviderConfig `yaml:"provider,omitempty" json:"provider,omitempty"`
Environment MappingWithEquals `yaml:"environment,omitempty" json:"environment,omitempty"`
EnvFiles []EnvFile `yaml:"env_file,omitempty" json:"env_file,omitempty"`
Expose StringOrNumberList `yaml:"expose,omitempty" json:"expose,omitempty"`
@ -142,6 +142,12 @@ type ServiceConfig struct {
Extensions Extensions `yaml:"#extensions,inline,omitempty" json:"-"`
}
type ServiceProviderConfig struct {
Type string `yaml:"type,omitempty" json:"driver,omitempty"`
Options Options `yaml:"options,omitempty" json:"options,omitempty"`
Extensions Extensions `yaml:"#extensions,inline,omitempty" json:"-"`
}
// MarshalYAML makes ServiceConfig implement yaml.Marshaller
func (s ServiceConfig) MarshalYAML() (interface{}, error) {
type t ServiceConfig
@ -535,6 +541,7 @@ type ServiceVolumeConfig struct {
Bind *ServiceVolumeBind `yaml:"bind,omitempty" json:"bind,omitempty"`
Volume *ServiceVolumeVolume `yaml:"volume,omitempty" json:"volume,omitempty"`
Tmpfs *ServiceVolumeTmpfs `yaml:"tmpfs,omitempty" json:"tmpfs,omitempty"`
Image *ServiceVolumeImage `yaml:"image,omitempty" json:"image,omitempty"`
Extensions Extensions `yaml:"#extensions,inline,omitempty" json:"-"`
}
@ -569,6 +576,8 @@ const (
VolumeTypeNamedPipe = "npipe"
// VolumeTypeCluster is the type for mounting container storage interface (CSI) volumes
VolumeTypeCluster = "cluster"
// VolumeTypeImage is the tpe for mounting an image
VolumeTypeImage = "image"
// SElinuxShared share the volume content
SElinuxShared = "z"
@ -612,8 +621,9 @@ const (
// ServiceVolumeVolume are options for a service volume of type volume
type ServiceVolumeVolume struct {
NoCopy bool `yaml:"nocopy,omitempty" json:"nocopy,omitempty"`
Subpath string `yaml:"subpath,omitempty" json:"subpath,omitempty"`
Labels Mapping `yaml:"labels,omitempty" json:"labels,omitempty"`
NoCopy bool `yaml:"nocopy,omitempty" json:"nocopy,omitempty"`
Subpath string `yaml:"subpath,omitempty" json:"subpath,omitempty"`
Extensions Extensions `yaml:"#extensions,inline,omitempty" json:"-"`
}
@ -627,6 +637,11 @@ type ServiceVolumeTmpfs struct {
Extensions Extensions `yaml:"#extensions,inline,omitempty" json:"-"`
}
type ServiceVolumeImage struct {
SubPath string `yaml:"subpath,omitempty" json:"subpath,omitempty"`
Extensions Extensions `yaml:"#extensions,inline,omitempty" json:"-"`
}
type FileMode int64
// FileReferenceConfig for a reference to a swarm file object

12
vendor/github.com/compose-spec/compose-go/v2/utils/collectionutils.go generated vendored
View File

@ -17,15 +17,13 @@
package utils
import (
"golang.org/x/exp/constraints"
"golang.org/x/exp/maps"
"golang.org/x/exp/slices"
"cmp"
"maps"
"slices"
)
func MapKeys[T constraints.Ordered, U any](theMap map[T]U) []T {
result := maps.Keys(theMap)
slices.Sort(result)
return result
func MapKeys[T cmp.Ordered, U any](theMap map[T]U) []T {
return slices.Sorted(maps.Keys(theMap))
}
func MapsAppend[T comparable, U any](target map[T]U, source map[T]U) map[T]U {