Merge pull request containerd#4512 from Swapnanil-Gupta/dockercompat-fix

fix: return block device paths instead of major:minor numbers in `container inspect`

Author: AkihiroSuda

cmd/nerdctl/container/container_inspect_linux_test.go

@@ -20,14 +20,14 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
-	"os/exec"
 	"slices"
 	"strings"
 	"testing"
 
 	"github.com/docker/go-connections/nat"
 	"gotest.tools/v3/assert"
 
+	"github.com/containerd/continuity/testutil/loopback"
 	"github.com/containerd/nerdctl/mod/tigron/expect"
 	"github.com/containerd/nerdctl/mod/tigron/test"
 	"github.com/containerd/nerdctl/mod/tigron/tig"
@@ -512,45 +512,45 @@ func TestContainerInspectBlkioSettings(t *testing.T) {
 	// For now, disable the test unless on a recent kernel.
 	testutil.RequireKernelVersion(t, ">= 6.0.0-0")
 
-	devPath := "/dev/dummy-zero"
-	// a dummy zero device: mknod /dev/dummy-zero c 1 5
-	helperCmd := exec.Command("mknod", []string{devPath, "c", "1", "5"}...)
-	if out, err := helperCmd.CombinedOutput(); err != nil {
-		err = fmt.Errorf("cannot create %q: %q: %w", devPath, string(out), err)
+	lo, err := loopback.New(4096)
+	if err != nil {
+		err = fmt.Errorf("cannot find a loop device: %w", err)
 		t.Fatal(err)
 	}
-
-	// ensure the file will be removed in case of failed in the test
-	defer func() {
-		if err := exec.Command("rm", "-f", devPath).Run(); err != nil {
-			t.Logf("failed to remove device %s: %v", devPath, err)
-		}
-	}()
+	defer lo.Close()
 
 	base := testutil.NewBase(t)
 	defer base.Cmd("rm", "-f", testContainer).AssertOK()
 
+	const (
+		weight    = 500
+		readBps   = 1048576
+		readIops  = 1000
+		writeBps  = 2097152
+		writeIops = 2000
+	)
 	base.Cmd("run", "-d", "--name", testContainer,
-		"--blkio-weight", "500",
-		"--blkio-weight-device", "/dev/dummy-zero:500",
-		"--device-read-bps", "/dev/dummy-zero:1048576",
-		"--device-read-iops", "/dev/dummy-zero:1000",
-		"--device-write-bps", "/dev/dummy-zero:2097152",
-		"--device-write-iops", "/dev/dummy-zero:2000",
+		"--blkio-weight", fmt.Sprintf("%d", weight),
+		"--blkio-weight-device", fmt.Sprintf("%s:%d", lo.Device, weight),
+		"--device-read-bps", fmt.Sprintf("%s:%d", lo.Device, readBps),
+		"--device-read-iops", fmt.Sprintf("%s:%d", lo.Device, readIops),
+		"--device-write-bps", fmt.Sprintf("%s:%d", lo.Device, writeBps),
+		"--device-write-iops", fmt.Sprintf("%s:%d", lo.Device, writeIops),
 		testutil.AlpineImage, "sleep", "infinity").AssertOK()
 
 	inspect := base.InspectContainer(testContainer)
-	assert.Equal(t, uint16(500), inspect.HostConfig.BlkioWeight)
+	assert.Equal(t, uint16(weight), inspect.HostConfig.BlkioWeight)
 	assert.Equal(t, 1, len(inspect.HostConfig.BlkioWeightDevice))
-	assert.Equal(t, uint16(500), *inspect.HostConfig.BlkioWeightDevice[0].Weight)
+	assert.Equal(t, lo.Device, inspect.HostConfig.BlkioWeightDevice[0].Path)
+	assert.Equal(t, uint16(weight), inspect.HostConfig.BlkioWeightDevice[0].Weight)
 	assert.Equal(t, 1, len(inspect.HostConfig.BlkioDeviceReadBps))
-	assert.Equal(t, uint64(1048576), inspect.HostConfig.BlkioDeviceReadBps[0].Rate)
+	assert.Equal(t, uint64(readBps), inspect.HostConfig.BlkioDeviceReadBps[0].Rate)
 	assert.Equal(t, 1, len(inspect.HostConfig.BlkioDeviceWriteBps))
-	assert.Equal(t, uint64(2097152), inspect.HostConfig.BlkioDeviceWriteBps[0].Rate)
+	assert.Equal(t, uint64(writeBps), inspect.HostConfig.BlkioDeviceWriteBps[0].Rate)
 	assert.Equal(t, 1, len(inspect.HostConfig.BlkioDeviceReadIOps))
-	assert.Equal(t, uint64(1000), inspect.HostConfig.BlkioDeviceReadIOps[0].Rate)
+	assert.Equal(t, uint64(readIops), inspect.HostConfig.BlkioDeviceReadIOps[0].Rate)
 	assert.Equal(t, 1, len(inspect.HostConfig.BlkioDeviceWriteIOps))
-	assert.Equal(t, uint64(2000), inspect.HostConfig.BlkioDeviceWriteIOps[0].Rate)
+	assert.Equal(t, uint64(writeIops), inspect.HostConfig.BlkioDeviceWriteIOps[0].Rate)
 }
 
 func TestContainerInspectUser(t *testing.T) {

cmd/nerdctl/container/container_run_cgroup_linux_test.go

@@ -21,7 +21,6 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -495,31 +494,33 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 	// For now, disable the test unless on a recent kernel.
 	testutil.RequireKernelVersion(t, ">= 6.0.0-0")
 
-	// Create dummy device path
-	dummyDev := "/dev/dummy-zero"
-
+	const (
+		weight       = "150"
+		deviceWeight = "100"
+		readBps      = "1048576"
+		readIops     = "1000"
+		writeBps     = "2097152"
+		writeIops    = "2000"
+	)
+	var lo *loopback.Loopback
 	testCase.Setup = func(data test.Data, helpers test.Helpers) {
-		// Create dummy device
-		helperCmd := exec.Command("mknod", dummyDev, "c", "1", "5")
-		if out, err := helperCmd.CombinedOutput(); err != nil {
-			t.Fatalf("cannot create %q: %q: %v", dummyDev, string(out), err)
-		}
+		var err error
+		lo, err = loopback.New(4096)
+		assert.NilError(t, err)
+		t.Logf("loopback device: %+v", lo)
 	}
-
 	testCase.Cleanup = func(data test.Data, helpers test.Helpers) {
-		// Clean up the dummy device
-		if err := exec.Command("rm", "-f", dummyDev).Run(); err != nil {
-			t.Logf("failed to remove device %s: %v", dummyDev, err)
+		if lo != nil {
+			_ = lo.Close()
 		}
 	}
-
 	testCase.SubTests = []*test.Case{
 		{
 			Description: "blkio-weight",
 			Require:     nerdtest.CGroupV2,
 			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
 				return helpers.Command("run", "-d", "--name", data.Identifier(),
-					"--blkio-weight", "150",
+					"--blkio-weight", weight,
 					testutil.AlpineImage, "sleep", "infinity")
 			},
 			Cleanup: func(data test.Data, helpers test.Helpers) {
@@ -530,7 +531,7 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 					ExitCode: 0,
 					Output: expect.All(
 						func(stdout string, t tig.T) {
-							assert.Assert(t, strings.Contains(helpers.Capture("inspect", "--format", "{{.HostConfig.BlkioWeight}}", data.Identifier()), "150"))
+							assert.Assert(t, strings.Contains(helpers.Capture("inspect", "--format", "{{.HostConfig.BlkioWeight}}", data.Identifier()), weight))
 						},
 					),
 				}
@@ -541,7 +542,7 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 			Require:     nerdtest.CGroupV2,
 			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
 				return helpers.Command("run", "-d", "--name", data.Identifier(),
-					"--blkio-weight-device", dummyDev+":100",
+					"--blkio-weight-device", fmt.Sprintf("%s:%s", lo.Device, deviceWeight),
 					testutil.AlpineImage, "sleep", "infinity")
 			},
 			Cleanup: func(data test.Data, helpers test.Helpers) {
@@ -553,7 +554,11 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 					Output: expect.All(
 						func(stdout string, t tig.T) {
 							inspectOut := helpers.Capture("inspect", "--format", "{{range .HostConfig.BlkioWeightDevice}}{{.Weight}}{{end}}", data.Identifier())
-							assert.Assert(t, strings.Contains(inspectOut, "100"))
+							assert.Assert(t, strings.Contains(inspectOut, deviceWeight))
+						},
+						func(stdout string, t tig.T) {
+							inspectOut := helpers.Capture("inspect", "--format", "{{range .HostConfig.BlkioWeightDevice}}{{.Path}}{{end}}", data.Identifier())
+							assert.Assert(t, strings.Contains(inspectOut, lo.Device))
 						},
 					),
 				}
@@ -570,7 +575,7 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 			),
 			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
 				return helpers.Command("run", "-d", "--name", data.Identifier(),
-					"--device-read-bps", dummyDev+":1048576",
+					"--device-read-bps", fmt.Sprintf("%s:%s", lo.Device, readBps),
 					testutil.AlpineImage, "sleep", "infinity")
 			},
 			Cleanup: func(data test.Data, helpers test.Helpers) {
@@ -582,7 +587,11 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 					Output: expect.All(
 						func(stdout string, t tig.T) {
 							inspectOut := helpers.Capture("inspect", "--format", "{{range .HostConfig.BlkioDeviceReadBps}}{{.Rate}}{{end}}", data.Identifier())
-							assert.Assert(t, strings.Contains(inspectOut, "1048576"))
+							assert.Assert(t, strings.Contains(inspectOut, readBps))
+						},
+						func(stdout string, t tig.T) {
+							inspectOut := helpers.Capture("inspect", "--format", "{{range .HostConfig.BlkioDeviceReadBps}}{{.Path}}{{end}}", data.Identifier())
+							assert.Assert(t, strings.Contains(inspectOut, lo.Device))
 						},
 					),
 				}
@@ -599,7 +608,7 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 			),
 			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
 				return helpers.Command("run", "-d", "--name", data.Identifier(),
-					"--device-write-bps", dummyDev+":2097152",
+					"--device-write-bps", fmt.Sprintf("%s:%s", lo.Device, writeBps),
 					testutil.AlpineImage, "sleep", "infinity")
 			},
 			Cleanup: func(data test.Data, helpers test.Helpers) {
@@ -611,7 +620,11 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 					Output: expect.All(
 						func(stdout string, t tig.T) {
 							inspectOut := helpers.Capture("inspect", "--format", "{{range .HostConfig.BlkioDeviceWriteBps}}{{.Rate}}{{end}}", data.Identifier())
-							assert.Assert(t, strings.Contains(inspectOut, "2097152"))
+							assert.Assert(t, strings.Contains(inspectOut, writeBps))
+						},
+						func(stdout string, t tig.T) {
+							inspectOut := helpers.Capture("inspect", "--format", "{{range .HostConfig.BlkioDeviceWriteBps}}{{.Path}}{{end}}", data.Identifier())
+							assert.Assert(t, strings.Contains(inspectOut, lo.Device))
 						},
 					),
 				}
@@ -628,7 +641,7 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 			),
 			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
 				return helpers.Command("run", "-d", "--name", data.Identifier(),
-					"--device-read-iops", dummyDev+":1000",
+					"--device-read-iops", fmt.Sprintf("%s:%s", lo.Device, readIops),
 					testutil.AlpineImage, "sleep", "infinity")
 			},
 			Cleanup: func(data test.Data, helpers test.Helpers) {
@@ -640,7 +653,11 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 					Output: expect.All(
 						func(stdout string, t tig.T) {
 							inspectOut := helpers.Capture("inspect", "--format", "{{range .HostConfig.BlkioDeviceReadIOps}}{{.Rate}}{{end}}", data.Identifier())
-							assert.Assert(t, strings.Contains(inspectOut, "1000"))
+							assert.Assert(t, strings.Contains(inspectOut, readIops))
+						},
+						func(stdout string, t tig.T) {
+							inspectOut := helpers.Capture("inspect", "--format", "{{range .HostConfig.BlkioDeviceReadIOps}}{{.Path}}{{end}}", data.Identifier())
+							assert.Assert(t, strings.Contains(inspectOut, lo.Device))
 						},
 					),
 				}
@@ -657,7 +674,7 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 			),
 			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
 				return helpers.Command("run", "-d", "--name", data.Identifier(),
-					"--device-write-iops", dummyDev+":2000",
+					"--device-write-iops", fmt.Sprintf("%s:%s", lo.Device, writeIops),
 					testutil.AlpineImage, "sleep", "infinity")
 			},
 			Cleanup: func(data test.Data, helpers test.Helpers) {
@@ -669,7 +686,11 @@ func TestRunBlkioSettingCgroupV2(t *testing.T) {
 					Output: expect.All(
 						func(stdout string, t tig.T) {
 							inspectOut := helpers.Capture("inspect", "--format", "{{range .HostConfig.BlkioDeviceWriteIOps}}{{.Rate}}{{end}}", data.Identifier())
-							assert.Assert(t, strings.Contains(inspectOut, "2000"))
+							assert.Assert(t, strings.Contains(inspectOut, writeIops))
+						},
+						func(stdout string, t tig.T) {
+							inspectOut := helpers.Capture("inspect", "--format", "{{range .HostConfig.BlkioDeviceWriteIOps}}{{.Path}}{{end}}", data.Identifier())
+							assert.Assert(t, strings.Contains(inspectOut, lo.Device))
 						},
 					),
 				}