feature: add port mapping for container

apis/swagger.yml

@@ -1184,8 +1184,7 @@ definitions:
           PortBindings:
             type: "object"
             description: "A map of exposed container ports and the host port they should map to."
-            additionalProperties:
-              $ref: "#/definitions/PortBinding"
+            $ref: "#/definitions/PortMap"
           AutoRemove:
             type: "boolean"
             description: "Automatically remove the container when the container's process exits. This has no effect if `RestartPolicy` is set."

cli/common_flags.go

@@ -52,6 +52,8 @@ func addCommonFlags(flagSet *pflag.FlagSet) *container {
 	flagSet.StringVar(&c.name, "name", "", "Specify name of container")
 
 	flagSet.StringSliceVar(&c.networks, "net", nil, "Set networks to container")
+	flagSet.StringSliceVarP(&c.ports, "port", "p", nil, "Set container ports mapping")
+	flagSet.StringSliceVar(&c.expose, "expose", nil, "Set expose container's ports")
 
 	flagSet.StringVar(&c.pidMode, "pid", "", "PID namespace to use")
 	flagSet.BoolVar(&c.privileged, "privileged", false, "Give extended privileges to the container")

cli/container.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/alibaba/pouch/apis/types"
 	"github.com/alibaba/pouch/pkg/runconfig"
+	"github.com/docker/go-connections/nat"
 
 	units "github.com/docker/go-units"
 	strfmt "github.com/go-openapi/strfmt"
@@ -45,6 +46,9 @@ type container struct {
 	utsMode              string
 	sysctls              []string
 	networks             []string
+	ports                []string
+	expose               []string
+	publicAll            bool
 	securityOpt          []string
 	capAdd               []string
 	capDrop              []string
@@ -131,18 +135,61 @@ func (c *container) config() (*types.ContainerCreateConfig, error) {
 		}
 	}
 
+	// parse port binding
+	tmpPorts, tmpPortBindings, err := nat.ParsePortSpecs(c.ports)
+	if err != nil {
+		return nil, err
+	}
+	// translate ports and portbingings
+	ports := map[string]interface{}{}
+	for n, p := range tmpPorts {
+		ports[string(n)] = p
+	}
+	portBindings := make(types.PortMap)
+	for n, pbs := range tmpPortBindings {
+		portBindings[string(n)] = []types.PortBinding{}
+		for _, tmpPb := range pbs {
+			pb := types.PortBinding{HostIP: tmpPb.HostIP, HostPort: tmpPb.HostPort}
+			portBindings[string(n)] = append(portBindings[string(n)], pb)
+		}
+	}
+
+	for _, e := range c.expose {
+		if strings.Contains(e, ":") {
+			return nil, fmt.Errorf("invalid port format for --expose: %s", e)
+		}
+
+		//support two formats for expose, original format <portnum>/[<proto>] or <startport-endport>/[<proto>]
+		proto, port := nat.SplitProtoPort(e)
+		//parse the start and end port and create a sequence of ports to expose
+		//if expose a port, the start and end port are the same
+		start, end, err := nat.ParsePortRange(port)
+		if err != nil {
+			return nil, fmt.Errorf("invalid range format for --expose: %s, error: %s", e, err)
+		}
+		for i := start; i <= end; i++ {
+			p, err := nat.NewPort(proto, strconv.FormatUint(i, 10))
+			if err != nil {
+				return nil, err
+			}
+			if _, exists := ports[string(p)]; !exists {
+				ports[string(p)] = struct{}{}
+			}
+		}
+	}
 	config := &types.ContainerCreateConfig{
 		ContainerConfig: types.ContainerConfig{
-			Tty:        c.tty,
-			Env:        c.env,
-			Entrypoint: strings.Fields(c.entrypoint),
-			WorkingDir: c.workdir,
-			User:       c.user,
-			Hostname:   strfmt.Hostname(c.hostname),
-			Labels:     labels,
-			Rich:       c.rich,
-			RichMode:   c.richMode,
-			InitScript: c.initScript,
+			Tty:          c.tty,
+			Env:          c.env,
+			Entrypoint:   strings.Fields(c.entrypoint),
+			WorkingDir:   c.workdir,
+			User:         c.user,
+			Hostname:     strfmt.Hostname(c.hostname),
+			Labels:       labels,
+			Rich:         c.rich,
+			RichMode:     c.richMode,
+			InitScript:   c.initScript,
+			ExposedPorts: ports,
 		},
 
 		HostConfig: &types.HostConfig{
@@ -182,6 +229,7 @@ func (c *container) config() (*types.ContainerCreateConfig, error) {
 			NetworkMode:   networkMode,
 			CapAdd:        c.capAdd,
 			CapDrop:       c.capDrop,
+			PortBindings:  portBindings,
 		},
 
 		NetworkingConfig: networkingConfig,

daemon/mgr/container.go

@@ -1019,6 +1019,7 @@ func (mgr *ContainerManager) buildContainerEndpoint(c *ContainerMeta) *networkty
 		DNSOptions:      c.HostConfig.DNSOptions,
 		DNSSearch:       c.HostConfig.DNSSearch,
 		MacAddress:      c.Config.MacAddress,
+		PublishAllPorts: c.HostConfig.PublishAllPorts,
 		ExposedPorts:    c.Config.ExposedPorts,
 		PortBindings:    c.HostConfig.PortBindings,
 		NetworkConfig:   c.NetworkSettings,

daemon/mgr/network.go

@@ -15,6 +15,7 @@ import (
 	"github.com/alibaba/pouch/pkg/randomid"
 
 	netlog "github.com/Sirupsen/logrus"
+	"github.com/docker/go-connections/nat"
 	"github.com/docker/libnetwork"
 	nwconfig "github.com/docker/libnetwork/config"
 	"github.com/docker/libnetwork/netlabel"
@@ -508,6 +509,65 @@ func (nm *NetworkManager) sandboxOptions(endpoint *types.Endpoint) ([]libnetwork
 	// TODO: secondary ip address
 	// TODO: parse extra hosts
 	// TODO: port mapping
+	var bindings = make(nat.PortMap)
+	if endpoint.PortBindings != nil {
+		for p, b := range endpoint.PortBindings {
+			bindings[nat.Port(p)] = []nat.PortBinding{}
+			for _, bb := range b {
+				bindings[nat.Port(p)] = append(bindings[nat.Port(p)], nat.PortBinding{
+					HostIP:   bb.HostIP,
+					HostPort: bb.HostPort,
+				})
+			}
+		}
+	}
+
+	portSpecs := endpoint.ExposedPorts
+	var ports = make([]nat.Port, len(portSpecs))
+	var i int
+	for p := range endpoint.ExposedPorts {
+		ports[i] = nat.Port(p)
+		i++
+	}
+	nat.SortPortMap(ports, bindings)
+
+	var (
+		exposeList []networktypes.TransportPort
+		pbList     []networktypes.PortBinding
+	)
+	for _, port := range ports {
+		expose := networktypes.TransportPort{}
+		expose.Proto = networktypes.ParseProtocol(port.Proto())
+		expose.Port = uint16(port.Int())
+		exposeList = append(exposeList, expose)
+
+		pb := networktypes.PortBinding{Port: expose.Port, Proto: expose.Proto}
+		binding := bindings[port]
+		for i := 0; i < len(binding); i++ {
+			pbCopy := pb.GetCopy()
+			newP, err := nat.NewPort(nat.SplitProtoPort(binding[i].HostPort))
+			var portStart, portEnd int
+			if err == nil {
+				portStart, portEnd, err = newP.Range()
+			}
+			if err != nil {
+				return nil, fmt.Errorf("failed to parsing HostPort value(%s):%v", binding[i].HostPort, err)
+			}
+			pbCopy.HostPort = uint16(portStart)
+			pbCopy.HostPortEnd = uint16(portEnd)
+			pbCopy.HostIP = net.ParseIP(binding[i].HostIP)
+			pbList = append(pbList, pbCopy)
+		}
+
+		if endpoint.PublishAllPorts && len(binding) == 0 {
+			pbList = append(pbList, pb)
+		}
+	}
+
+	sandboxOptions = append(sandboxOptions,
+		libnetwork.OptionPortMapping(pbList),
+		libnetwork.OptionExposedPorts(exposeList))
+
 	return sandboxOptions, nil
 }
 

network/types/endpoint.go

@@ -25,8 +25,9 @@ type Endpoint struct {
 	NetworkDisabled bool
 	NetworkMode     string
 	MacAddress      string
+	PublishAllPorts bool
 	ExposedPorts    map[string]interface{}
-	PortBindings    map[string]types.PortBinding
+	PortBindings    types.PortMap
 
 	NetworkConfig  *types.NetworkSettings
 	EndpointConfig *types.EndpointSettings

test/cli_network_test.go

@@ -3,6 +3,7 @@ package main
 import (
 	"runtime"
 	"strings"
+	"time"
 
 	"github.com/alibaba/pouch/test/command"
 	"github.com/alibaba/pouch/test/environment"
@@ -283,3 +284,36 @@ func (suite *PouchNetworkSuite) TestNetworkCreateDup(c *check.C) {
 
 	command.PouchRun("network", "remove", funcname)
 }
+
+func (suite *PouchNetworkSuite) TestNetworkPortMapping(c *check.C) {
+	pc, _, _, _ := runtime.Caller(0)
+	tmpname := strings.Split(runtime.FuncForPC(pc).Name(), ".")
+	var funcname string
+	for i := range tmpname {
+		funcname = tmpname[i]
+	}
+
+	ret := icmd.RunCommand("which", "curl")
+	if ret.ExitCode != 0 {
+		c.Skip("Host does not have curl")
+	}
+
+	expct := icmd.Expected{
+		ExitCode: 0,
+		Out:      "It works",
+	}
+
+	image := "registry.hub.docker.com/library/httpd"
+
+	command.PouchRun("pull", image).Assert(c, icmd.Success)
+	command.PouchRun("run", "-d",
+		"--name", funcname,
+		"-p", "9999:80",
+		image).Assert(c, icmd.Success)
+
+	time.Sleep(1 * time.Second)
+	err := icmd.RunCommand("curl", "localhost:9999").Compare(expct)
+	c.Assert(err, check.IsNil)
+
+	command.PouchRun("rm", "-f", funcname)
+}