Clean all volume paths

Signed-off-by: Mathieu Champlon <[email protected]>

Author: mat007

loader/loader.go

@@ -342,8 +342,8 @@ func createTransformHook(additionalTransformers ...Transformer) mapstructure.Dec
 		reflect.TypeOf(types.UlimitsConfig{}):                    transformUlimits,
 		reflect.TypeOf(types.UnitBytes(0)):                       transformSize,
 		reflect.TypeOf([]types.ServicePortConfig{}):              transformServicePort,
-		reflect.TypeOf(types.ServiceSecretConfig{}):              transformStringSourceMap,
-		reflect.TypeOf(types.ServiceConfigObjConfig{}):           transformStringSourceMap,
+		reflect.TypeOf(types.ServiceSecretConfig{}):              transformFileReferenceConfig,
+		reflect.TypeOf(types.ServiceConfigObjConfig{}):           transformFileReferenceConfig,
 		reflect.TypeOf(types.StringOrNumberList{}):               transformStringOrNumberList,
 		reflect.TypeOf(map[string]*types.ServiceNetworkConfig{}): transformServiceNetworkMap,
 		reflect.TypeOf(types.Mapping{}):                          transformMappingOrListFunc("=", false),
@@ -852,17 +852,27 @@ var transformServiceDeviceRequest TransformerFunc = func(data interface{}) (inte
 	}
 }
 
-var transformStringSourceMap TransformerFunc = func(data interface{}) (interface{}, error) {
+var transformFileReferenceConfig TransformerFunc = func(data interface{}) (interface{}, error) {
 	switch value := data.(type) {
 	case string:
 		return map[string]interface{}{"source": value}, nil
 	case map[string]interface{}:
-		return groupXFieldsIntoExtensions(data.(map[string]interface{})), nil
+		if target, ok := value["target"]; ok {
+			value["target"] = cleanTarget(target.(string))
+		}
+		return groupXFieldsIntoExtensions(value), nil
 	default:
 		return data, errors.Errorf("invalid type %T for secret", value)
 	}
 }
 
+func cleanTarget(target string) string {
+	if target == "" {
+		return ""
+	}
+	return path.Clean(target)
+}
+
 var transformBuildConfig TransformerFunc = func(data interface{}) (interface{}, error) {
 	switch value := data.(type) {
 	case string:
@@ -906,9 +916,15 @@ var transformExtendsConfig TransformerFunc = func(data interface{}) (interface{}
 var transformServiceVolumeConfig TransformerFunc = func(data interface{}) (interface{}, error) {
 	switch value := data.(type) {
 	case string:
-		return ParseVolume(value)
+		volume, err := ParseVolume(value)
+		volume.Target = cleanTarget(volume.Target)
+		return volume, err
 	case map[string]interface{}:
-		return groupXFieldsIntoExtensions(data.(map[string]interface{})), nil
+		data := groupXFieldsIntoExtensions(data.(map[string]interface{}))
+		if target, ok := data["target"]; ok {
+			data["target"] = cleanTarget(target.(string))
+		}
+		return data, nil
 	default:
 		return data, errors.Errorf("invalid type %T for service volume", value)
 	}

loader/loader_test.go

@@ -1812,7 +1812,7 @@ services:
 	assert.NilError(t, err)
 }
 
-func TestLoadService(t *testing.T) {
+func TestLoadServiceWithEnvFile(t *testing.T) {
 	file, err := os.CreateTemp("", "test-compose-go")
 	assert.NilError(t, err)
 	defer os.Remove(file.Name())
@@ -1830,3 +1830,33 @@ func TestLoadService(t *testing.T) {
 	assert.NilError(t, err)
 	assert.Equal(t, "YES", *s.Environment["HALLO"])
 }
+
+func TestLoadServiceWithVolumes(t *testing.T) {
+	m := map[string]interface{}{
+		"volumes": []interface{}{
+			"source:/path 1/",
+			map[string]interface{}{
+				"target": "/path 2/",
+			},
+		},
+		"configs": []interface{}{
+			map[string]interface{}{
+				"target": "/path 3/",
+			},
+		},
+		"secrets": []interface{}{
+			map[string]interface{}{
+				"target": "/path 4/",
+			},
+		},
+	}
+	s, err := LoadService("Test Name", m, ".", nil, true)
+	assert.NilError(t, err)
+	assert.Equal(t, len(s.Volumes), 2)
+	assert.Equal(t, "/path 1", s.Volumes[0].Target)
+	assert.Equal(t, "/path 2", s.Volumes[1].Target)
+	assert.Equal(t, len(s.Configs), 1)
+	assert.Equal(t, "/path 3", s.Configs[0].Target)
+	assert.Equal(t, len(s.Secrets), 1)
+	assert.Equal(t, "/path 4", s.Secrets[0].Target)
+}

loader/volume.go

@@ -17,7 +17,6 @@
 package loader
 
 import (
-	"path"
 	"strings"
 	"unicode"
 	"unicode/utf8"
@@ -57,7 +56,6 @@ func ParseVolume(spec string) (types.ServiceVolumeConfig, error) {
 		}
 	}
 
-	volume.Target = path.Clean(volume.Target)
 	populateType(&volume)
 	return volume, nil
 }

loader/volume_test.go

@@ -34,13 +34,6 @@ func TestParseVolumeAnonymousVolume(t *testing.T) {
 	}
 }
 
-func TestParseVolumeCleanTarget(t *testing.T) {
-	volume, err := ParseVolume("/path/")
-	expected := types.ServiceVolumeConfig{Type: "volume", Target: "/path", Volume: &types.ServiceVolumeVolume{}}
-	assert.NilError(t, err)
-	assert.Check(t, is.DeepEqual(expected, volume))
-}
-
 func TestParseVolumeAnonymousVolumeWindows(t *testing.T) {
 	for _, path := range []string{"C:\\path", "Z:\\path\\foo"} {
 		volume, err := ParseVolume(path)