feat: Use nerdctl parsing logic for port publishing (runfinch#265)

Signed-off-by: Swagat Bora <[email protected]>

Author: swagatbora90

api/handlers/container/create.go

@@ -9,13 +9,13 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
-	"strconv"
 	"strings"
 
 	"github.com/containerd/containerd/v2/pkg/namespaces"
 	gocni "github.com/containerd/go-cni"
 	ncTypes "github.com/containerd/nerdctl/v2/pkg/api/types"
 	"github.com/containerd/nerdctl/v2/pkg/defaults"
+	"github.com/containerd/nerdctl/v2/pkg/portutil"
 	"github.com/docker/go-connections/nat"
 	"github.com/moby/moby/api/types/blkiodev"
 	"github.com/sirupsen/logrus"
@@ -320,7 +320,6 @@ func (h *handler) create(w http.ResponseWriter, r *http.Request) {
 		// #endregion
 
 	}
-
 	portMappings, err := translatePortMappings(req.HostConfig.PortBindings)
 	if err != nil {
 		logrus.Debugf("failed to parse port mappings: %s", err)
@@ -393,25 +392,30 @@ func translatePortMappings(portMappings nat.PortMap) ([]gocni.PortMapping, error
 	if portMappings == nil {
 		return ports, nil
 	}
+	seenPortMappings := make(map[string]bool)
 	for portName, portBindings := range portMappings {
 		for _, portBinding := range portBindings {
-			hostPort, err := strconv.ParseInt(portBinding.HostPort, 10, 32)
-			if err != nil {
-				return []gocni.PortMapping{}, fmt.Errorf("failed to parse host port (%s) to integer: %w", portBinding.HostPort, err)
+			portStr := ""
+			if portBinding.HostIP != "" {
+				portStr += portBinding.HostIP + ":"
 			}
-			// Cannot use portName.Int() because it assumes nat.NewPort() was used
-			// for error handling.
-			containerPort, err := strconv.ParseInt(portName.Port(), 10, 32)
-			if err != nil {
-				return []gocni.PortMapping{}, fmt.Errorf("failed to parse container port (%s) to integer: %w", portName, err)
+
+			// Add host port (or empty string if not specified)
+			portStr += portBinding.HostPort + ":"
+
+			// Add container port and protocol
+			portStr += portName.Port() + "/" + portName.Proto()
+
+			if seenPortMappings[portStr] {
+				continue
 			}
-			portMap := gocni.PortMapping{
-				HostPort:      int32(hostPort),
-				ContainerPort: int32(containerPort),
-				Protocol:      portName.Proto(),
-				HostIP:        portBinding.HostIP,
+			seenPortMappings[portStr] = true
+
+			portMaps, err := portutil.ParseFlagP(portStr)
+			if err != nil {
+				return []gocni.PortMapping{}, fmt.Errorf("failed to parse port mapping %q: %w", portStr, err)
 			}
-			ports = append(ports, portMap)
+			ports = append(ports, portMaps...)
 		}
 	}
 	return ports, nil

api/handlers/container/create_test.go

@@ -101,7 +101,7 @@ var _ = Describe("Container Create API ", func() {
 					HostPort:      8001,
 					ContainerPort: 8000,
 					Protocol:      "tcp",
-					HostIP:        "",
+					HostIP:        "0.0.0.0",
 				},
 				{
 					HostPort:      9001,
@@ -140,7 +140,7 @@ var _ = Describe("Container Create API ", func() {
 				"ExposedPorts": {"8000/tcp": {}},
 				"HostConfig": {
 					"PortBindings": {
-						"8000/tcp": [{"HostIp": "", "HostPort": ""}],
+						"8000/tcp": [{"HostIp": "", "HostPort": "invalid-port"}]
 					}
 				}
 			}`)

e2e/tests/container_create.go

@@ -210,6 +210,44 @@ func ContainerCreate(opt *option.Option, pOpt util.NewOpt) {
 			Expect(portMap[udpPort][0]).Should(Equal(udpPortBinding))
 		})
 
+		It("should create a container with automatic port allocation on the host", func() {
+			ctrPort := "8080"
+
+			// define options with empty host port for automatic allocation
+			tcpPort := nat.Port(fmt.Sprintf("%s/tcp", ctrPort))
+			tcpPortBinding := nat.PortBinding{HostIP: "0.0.0.0", HostPort: ""}
+
+			options.Cmd = []string{"sleep", "Infinity"}
+			options.HostConfig.PortBindings = nat.PortMap{
+				tcpPort: []nat.PortBinding{tcpPortBinding},
+			}
+
+			// create and start container
+			statusCode, ctr := createContainer(uClient, url, testContainerName, options)
+			Expect(statusCode).Should(Equal(http.StatusCreated))
+			Expect(ctr.ID).ShouldNot(BeEmpty())
+			command.Run(opt, "start", testContainerName)
+
+			// inspect container
+			resp := command.Stdout(opt, "inspect", testContainerName)
+			var inspect []*dockercompat.Container
+			err := json.Unmarshal(resp, &inspect)
+			Expect(err).Should(BeNil())
+			Expect(inspect).Should(HaveLen(1))
+
+			// verify port mappings with automatic allocation
+			Expect(inspect[0].NetworkSettings).ShouldNot(BeNil())
+			portMap := *inspect[0].NetworkSettings.Ports
+			Expect(portMap).Should(HaveLen(1))
+			Expect(portMap[tcpPort]).Should(HaveLen(1))
+			Expect(portMap[tcpPort][0].HostIP).Should(Equal("0.0.0.0"))
+			Expect(portMap[tcpPort][0].HostPort).ShouldNot(BeEmpty())
+			// Verify that a port was actually allocated (not empty string)
+			port, err := strconv.Atoi(portMap[tcpPort][0].HostPort)
+			Expect(err).Should(BeNil())
+			Expect(port).Should(BeNumerically(">", 0))
+		})
+
 		// Volume Mounts
 
 		It("should create a container with a directory mounted from the host", func() {