fix: support tmpfs long syntax in compose volumes

In the current implementation, nerdctl compose command ignores tmpfs
configurations specified in the long syntax within the volumes section of
compose.yml [1].

[1] https://docs.docker.com/reference/compose-file/services/#long-syntax-6

> - `type`: The mount type. Either `volume`, `bind`, `tmpfs`, `image`, `npipe`, or `cluster`
> - `target`: The path in the container where the volume is mounted.
> - `read_only`: Flag to set the volume as read-only.
> - `tmpfs`: Configures additional tmpfs options:
>   - `size`: The size for the tmpfs mount in bytes (either numeric or as bytes unit).
>   - `mode`: The file mode for the tmpfs mount as Unix permission bits as an octal number. Introduced in Docker Compose version [2.14.0](https://docs.docker.com/compose/releases/release-notes/#2260).

This behavior has been reported in issue#4556.

Therefore, this commit modifies so that when tmpfs is specified using the
long syntax in the volumes section, tmpfs is created within the container.

Signed-off-by: Hayato Kiwata <[email protected]>

Author: haytok

cmd/nerdctl/compose/compose_up_linux_test.go

@@ -671,3 +671,73 @@ services:
 	base.Cmd("images").AssertOutNotContains(testutil.CommonImage)
 	base.ComposeCmd("-f", comp.YAMLFullPath(), "up").AssertExitCode(1)
 }
+
+func TestComposeTmpfsVolume(t *testing.T) {
+	testCase := nerdtest.Setup()
+
+	testCase.Setup = func(data test.Data, helpers test.Helpers) {
+		containerName := data.Identifier("tmpfs")
+		composeYAML := fmt.Sprintf(`
+services:
+  tmpfs:
+    container_name: %s
+    image: %s
+    command: sleep infinity
+    volumes:
+      - type: tmpfs
+        target: /target-rw
+        tmpfs:
+          size: 64m
+      - type: tmpfs
+        target: /target-ro
+        read_only: true
+        tmpfs:
+          size: 64m
+          mode: 0o1770
+`, containerName, testutil.CommonImage)
+
+		composeYAMLPath := data.Temp().Save(composeYAML, "compose.yaml")
+
+		helpers.Ensure("compose", "-f", composeYAMLPath, "up", "-d")
+		nerdtest.EnsureContainerStarted(helpers, containerName)
+
+		data.Labels().Set("composeYAML", composeYAMLPath)
+		data.Labels().Set("containerName", containerName)
+	}
+
+	testCase.SubTests = []*test.Case{
+		{
+			Description: "rw tmpfs mount",
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				return helpers.Command("exec", data.Labels().Get("containerName"), "grep", "/target-rw", "/proc/mounts")
+			},
+			Expected: test.Expects(0, nil,
+				expect.All(
+					expect.Contains("/target-rw"),
+					expect.Contains("rw"),
+					expect.Contains("size=65536k"),
+				),
+			),
+		},
+		{
+			Description: "ro tmpfs mount with mode",
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				return helpers.Command("exec", data.Labels().Get("containerName"), "grep", "/target-ro", "/proc/mounts")
+			},
+			Expected: test.Expects(0, nil,
+				expect.All(
+					expect.Contains("/target-ro"),
+					expect.Contains("ro"),
+					expect.Contains("size=65536k"),
+					expect.Contains("mode=1770"),
+				),
+			),
+		},
+	}
+
+	testCase.Cleanup = func(data test.Data, helpers test.Helpers) {
+		helpers.Anyhow("compose", "-f", data.Labels().Get("composeYAML"), "down")
+	}
+
+	testCase.Run(t)
+}

pkg/composer/serviceparser/serviceparser.go

@@ -699,7 +699,14 @@ func newContainer(project *types.Project, parsed *Service, i int) (*Container, e
 		if err != nil {
 			return nil, err
 		}
-		c.RunArgs = append(c.RunArgs, "-v="+vStr)
+
+		switch v.Type {
+		case "tmpfs":
+			c.RunArgs = append(c.RunArgs, "--tmpfs="+vStr)
+		default:
+			c.RunArgs = append(c.RunArgs, "-v="+vStr)
+		}
+
 		c.Mkdir = mkdir
 	}
 
@@ -778,6 +785,7 @@ func serviceVolumeConfigToFlagV(c types.ServiceVolumeConfig, project *types.Proj
 		"ReadOnly",
 		"Bind",
 		"Volume",
+		"Tmpfs",
 	); len(unknown) > 0 {
 		log.L.Warnf("Ignoring: volume: %+v", unknown)
 	}
@@ -800,6 +808,29 @@ func serviceVolumeConfigToFlagV(c types.ServiceVolumeConfig, project *types.Proj
 		return "", nil, fmt.Errorf("volume target must be an absolute path, got %q", c.Target)
 	}
 
+	if c.Type == "tmpfs" {
+		var opts []string
+
+		if c.ReadOnly {
+			opts = append(opts, "ro")
+		}
+		if c.Tmpfs != nil {
+			if c.Tmpfs.Size != 0 {
+				opts = append(opts, fmt.Sprintf("size=%d", c.Tmpfs.Size))
+			}
+			if c.Tmpfs.Mode != 0 {
+				opts = append(opts, fmt.Sprintf("mode=%o", c.Tmpfs.Mode))
+			}
+		}
+
+		s := c.Target
+		if len(opts) > 0 {
+			s = fmt.Sprintf("%s:%s", s, strings.Join(opts, ","))
+		}
+
+		return s, mkdir, nil
+	}
+
 	if c.Source == "" {
 		// anonymous volume
 		s := c.Target

pkg/composer/serviceparser/serviceparser_test.go

@@ -439,6 +439,43 @@ services:
 	}
 }
 
+func TestTmpfsVolumeLongSyntax(t *testing.T) {
+	t.Parallel()
+
+	if runtime.GOOS == "windows" {
+		t.Skip("test is not compatible with windows")
+	}
+
+	const dockerComposeYAML = `
+services:
+  foo:
+    image: nginx:alpine
+    volumes:
+      - type: tmpfs
+        target: /target
+        read_only: true
+        tmpfs:
+          size: 2G
+          mode: 0o1770
+`
+	comp := testutil.NewComposeDir(t, dockerComposeYAML)
+	defer comp.CleanUp()
+
+	project, err := testutil.LoadProject(comp.YAMLFullPath(), comp.ProjectName(), nil)
+	assert.NilError(t, err)
+
+	fooSvc, err := project.GetService("foo")
+	assert.NilError(t, err)
+
+	foo, err := Parse(project, fooSvc)
+	assert.NilError(t, err)
+
+	t.Logf("foo: %+v", foo)
+	for _, c := range foo.Containers {
+		assert.Assert(t, in(c.RunArgs, "--tmpfs=/target:ro,size=2147483648,mode=1770"))
+	}
+}
+
 func TestParseNetworkMode(t *testing.T) {
 	t.Parallel()
 	const dockerComposeYAML = `