add mapping for ssh property in build section

Signed-off-by: Guillaume Lours <[email protected]>

Author: glours

loader/full-example.yml

@@ -7,6 +7,7 @@ services:
       dockerfile: Dockerfile
       args:
         foo: bar
+      ssh: default
       target: foo
       network: foo
       cache_from:

loader/full-struct_test.go

@@ -53,6 +53,7 @@ func services(workingDir, homeDir string) []types.ServiceConfig {
 				Context:    "./dir",
 				Dockerfile: "Dockerfile",
 				Args:       map[string]*string{"foo": strPtr("bar")},
+				SSH:        map[string]string{"default": ""},
 				Target:     "foo",
 				Network:    "foo",
 				CacheFrom:  []string{"foo", "bar"},
@@ -569,6 +570,8 @@ services:
       dockerfile: Dockerfile
       args:
         foo: bar
+      ssh:
+        default: ""
       labels:
         FOO: BAR
       cache_from:
@@ -1082,6 +1085,9 @@ func fullExampleJSON(workingDir, homeDir string) string {
         "args": {
           "foo": "bar"
         },
+        "ssh": {
+          "default": ""
+        },
         "labels": {
           "FOO": "BAR"
         },

loader/loader.go

@@ -390,6 +390,7 @@ func createTransformHook(additionalTransformers ...Transformer) mapstructure.Dec
 		reflect.TypeOf(types.DependsOnConfig{}):                  transformDependsOnConfig,
 		reflect.TypeOf(types.ExtendsConfig{}):                    transformExtendsConfig,
 		reflect.TypeOf(types.DeviceRequest{}):                    transformServiceDeviceRequest,
+		reflect.TypeOf(types.SSHConfig{}):                        transformSSHConfig,
 	}
 
 	for _, transformer := range additionalTransformers {
@@ -978,6 +979,24 @@ var transformServiceNetworkMap TransformerFunc = func(value interface{}) (interf
 	return value, nil
 }
 
+var transformSSHConfig TransformerFunc = func(data interface{}) (interface{}, error) {
+	switch value := data.(type) {
+	case map[string]interface{}:
+		return toMapStringString(value, true), nil
+	case []interface{}:
+		return transformMappingOrList(value, "=", true)
+	case string:
+		result := make(map[string]interface{})
+		if value == "" {
+			value = "default"
+		}
+		key, val := transformValueToMapEntry(value, "=", true)
+		result[key] = val
+		return result, nil
+	}
+	return nil, errors.Errorf("expected a sting, map or a list, got %T: %#v", data, data)
+}
+
 var transformStringOrNumberList TransformerFunc = func(value interface{}) (interface{}, error) {
 	list := value.([]interface{})
 	result := make([]string, len(list))
@@ -1000,47 +1019,52 @@ var transformStringList TransformerFunc = func(data interface{}) (interface{}, e
 
 func transformMappingOrListFunc(sep string, allowNil bool) TransformerFunc {
 	return func(data interface{}) (interface{}, error) {
-		return transformMappingOrList(data, sep, allowNil), nil
+		return transformMappingOrList(data, sep, allowNil)
 	}
 }
 
 func transformListOrMappingFunc(sep string, allowNil bool) TransformerFunc {
 	return func(data interface{}) (interface{}, error) {
-		return transformListOrMapping(data, sep, allowNil), nil
+		return transformListOrMapping(data, sep, allowNil)
 	}
 }
 
-func transformListOrMapping(listOrMapping interface{}, sep string, allowNil bool) interface{} {
+func transformListOrMapping(listOrMapping interface{}, sep string, allowNil bool) (interface{}, error) {
 	switch value := listOrMapping.(type) {
 	case map[string]interface{}:
-		return toStringList(value, sep, allowNil)
+		return toStringList(value, sep, allowNil), nil
 	case []interface{}:
-		return listOrMapping
+		return listOrMapping, nil
 	}
-	panic(errors.Errorf("expected a map or a list, got %T: %#v", listOrMapping, listOrMapping))
+	return nil, errors.Errorf("expected a map or a list, got %T: %#v", listOrMapping, listOrMapping)
 }
 
-func transformMappingOrList(mappingOrList interface{}, sep string, allowNil bool) interface{} {
+func transformMappingOrList(mappingOrList interface{}, sep string, allowNil bool) (interface{}, error) {
 	switch value := mappingOrList.(type) {
 	case map[string]interface{}:
-		return toMapStringString(value, allowNil)
+		return toMapStringString(value, allowNil), nil
 	case []interface{}:
 		result := make(map[string]interface{})
 		for _, value := range value {
-			parts := strings.SplitN(value.(string), sep, 2)
-			key := parts[0]
-			switch {
-			case len(parts) == 1 && allowNil:
-				result[key] = nil
-			case len(parts) == 1 && !allowNil:
-				result[key] = ""
-			default:
-				result[key] = parts[1]
-			}
+			key, val := transformValueToMapEntry(value.(string), sep, allowNil)
+			result[key] = val
 		}
-		return result
+		return result, nil
+	}
+	return nil, errors.Errorf("expected a map or a list, got %T: %#v", mappingOrList, mappingOrList)
+}
+
+func transformValueToMapEntry(value string, separator string, allowNil bool) (string, interface{}) {
+	parts := strings.SplitN(value, separator, 2)
+	key := parts[0]
+	switch {
+	case len(parts) == 1 && allowNil:
+		return key, nil
+	case len(parts) == 1 && !allowNil:
+		return key, ""
+	default:
+		return key, parts[1]
 	}
-	panic(errors.Errorf("expected a map or a list, got %T: %#v", mappingOrList, mappingOrList))
 }
 
 var transformShellCommand TransformerFunc = func(value interface{}) (interface{}, error) {

loader/loader_test.go

@@ -1867,3 +1867,59 @@ func TestLoadServiceWithVolumes(t *testing.T) {
 	assert.Equal(t, len(s.Secrets), 1)
 	assert.Equal(t, "/path 4", s.Secrets[0].Target)
 }
+
+func TestLoadNoSSHInBuildConfig(t *testing.T) {
+	actual, err := loadYAML(`
+services:
+  test:
+    build:
+      context: .
+`)
+	assert.NilError(t, err)
+	svc, err := actual.GetService("test")
+	assert.NilError(t, err)
+	assert.Check(t, nil == svc.Build.SSH)
+}
+
+func TestLoadSSHWithoutValueInBuildConfig(t *testing.T) {
+	_, err := loadYAML(`
+services:
+  test:
+    build:
+      context: .
+      ssh:
+`)
+	assert.ErrorContains(t, err, "services.test.build.ssh must be a mapping")
+}
+
+func TestLoadSSHWithDefaultValueInBuildConfig(t *testing.T) {
+	actual, err := loadYAML(`
+services:
+  test:
+    build:
+      context: .
+      ssh: ssh-agent
+`)
+	assert.NilError(t, err)
+	svc, err := actual.GetService("test")
+	assert.NilError(t, err)
+	assert.Assert(t, is.Contains(svc.Build.SSH, "ssh-agent"))
+	assert.Equal(t, "", svc.Build.SSH["ssh-agent"])
+}
+
+func TestLoadSSHWithKeysValuesInBuildConfig(t *testing.T) {
+	actual, err := loadYAML(`
+services:
+  test:
+    build:
+      context: .
+      ssh: 
+        - key1=value1
+        - key2=value2
+`)
+	assert.NilError(t, err)
+	svc, err := actual.GetService("test")
+	assert.NilError(t, err)
+	assert.Equal(t, "value1", svc.Build.SSH["key1"])
+	assert.Equal(t, "value2", svc.Build.SSH["key2"])
+}

schema/compose-spec.json

@@ -91,6 +91,16 @@
                 "context": {"type": "string"},
                 "dockerfile": {"type": "string"},
                 "args": {"$ref": "#/definitions/list_or_dict"},
+                "ssh": {
+                  "oneOf": [
+                    {
+                      "type": "string"
+                    },
+                    {
+                      "$ref": "#/definitions/list_or_dict"
+                    }
+                  ]
+                },
                 "labels": {"$ref": "#/definitions/list_or_dict"},
                 "cache_from": {"type": "array", "items": {"type": "string"}},
                 "cache_to": {"type": "array", "items": {"type": "string"}},

types/types.go

@@ -294,6 +294,7 @@ type BuildConfig struct {
 	Context    string            `yaml:",omitempty" json:"context,omitempty"`
 	Dockerfile string            `yaml:",omitempty" json:"dockerfile,omitempty"`
 	Args       MappingWithEquals `yaml:",omitempty" json:"args,omitempty"`
+	SSH        SSHConfig         `yaml:"ssh,omitempty" json:"ssh,omitempty"`
 	Labels     Labels            `yaml:",omitempty" json:"labels,omitempty"`
 	CacheFrom  StringList        `mapstructure:"cache_from" yaml:"cache_from,omitempty" json:"cache_from,omitempty"`
 	CacheTo    StringList        `mapstructure:"cache_to" yaml:"cache_to,omitempty" json:"cache_to,omitempty"`
@@ -426,6 +427,9 @@ func (l Labels) Add(key, value string) Labels {
 	return l
 }
 
+// SSHConfig is a mapping type for SSH build config
+type SSHConfig map[string]string
+
 // MappingWithColon is a mapping type that can be converted from a list of
 // 'key: value' strings
 type MappingWithColon map[string]string