InfraContainer Rework

InfraContainer should go through the same creation process as regular containers. This change was from the cmd level
down, involving new container CLI opts and specgen creating functions. What now happens is that both container and pod
cli options are populated in cmd and used to create a podSpecgen and a containerSpecgen. The process then goes as follows

FillOutSpecGen (infra) -> MapSpec (podOpts -> infraOpts) -> PodCreate -> MakePod -> createPodOptions -> NewPod -> CompleteSpec (infra) -> MakeContainer -> NewContainer -> newContainer -> AddInfra (to pod state)

Signed-off-by: cdoern <cdoern@redhat.com>

1 files changed, 0 insertions, 274 deletions

diff --git a/cmd/podman/common/util.go b/cmd/podman/common/util.go
deleted file mode 100644
index cdfff9d6f..000000000
--- a/cmd/podman/common/util.go
+++ /dev/null
@@ -1,274 +0,0 @@
-package common
-
-import (
-	"io/ioutil"
-	"net"
-	"strconv"
-	"strings"
-
-	"github.com/containers/podman/v3/libpod/network/types"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-)
-
-// ReadPodIDFile reads the specified file and returns its content (i.e., first
-// line).
-func ReadPodIDFile(path string) (string, error) {
-	content, err := ioutil.ReadFile(path)
-	if err != nil {
-		return "", errors.Wrap(err, "error reading pod ID file")
-	}
-	return strings.Split(string(content), "\n")[0], nil
-}
-
-// ReadPodIDFiles reads the specified files and returns their content (i.e.,
-// first line).
-func ReadPodIDFiles(files []string) ([]string, error) {
-	ids := []string{}
-	for _, file := range files {
-		id, err := ReadPodIDFile(file)
-		if err != nil {
-			return nil, err
-		}
-		ids = append(ids, id)
-	}
-	return ids, nil
-}
-
-// ParseFilters transforms one filter format to another and validates input
-func ParseFilters(filter []string) (map[string][]string, error) {
-	// TODO Remove once filter refactor is finished and url.Values done.
-	filters := map[string][]string{}
-	for _, f := range filter {
-		t := strings.SplitN(f, "=", 2)
-		filters = make(map[string][]string)
-		if len(t) < 2 {
-			return map[string][]string{}, errors.Errorf("filter input must be in the form of filter=value: %s is invalid", f)
-		}
-		filters[t[0]] = append(filters[t[0]], t[1])
-	}
-	return filters, nil
-}
-
-// createExpose parses user-provided exposed port definitions and converts them
-// into SpecGen format.
-// TODO: The SpecGen format should really handle ranges more sanely - we could
-// be massively inflating what is sent over the wire with a large range.
-func createExpose(expose []string) (map[uint16]string, error) {
-	toReturn := make(map[uint16]string)
-
-	for _, e := range expose {
-		// Check for protocol
-		proto := "tcp"
-		splitProto := strings.Split(e, "/")
-		if len(splitProto) > 2 {
-			return nil, errors.Errorf("invalid expose format - protocol can only be specified once")
-		} else if len(splitProto) == 2 {
-			proto = splitProto[1]
-		}
-
-		// Check for a range
-		start, len, err := parseAndValidateRange(splitProto[0])
-		if err != nil {
-			return nil, err
-		}
-
-		var index uint16
-		for index = 0; index < len; index++ {
-			portNum := start + index
-			protocols, ok := toReturn[portNum]
-			if !ok {
-				toReturn[portNum] = proto
-			} else {
-				newProto := strings.Join(append(strings.Split(protocols, ","), strings.Split(proto, ",")...), ",")
-				toReturn[portNum] = newProto
-			}
-		}
-	}
-
-	return toReturn, nil
-}
-
-// CreatePortBindings iterates ports mappings into SpecGen format.
-func CreatePortBindings(ports []string) ([]types.PortMapping, error) {
-	// --publish is formatted as follows:
-	// [[hostip:]hostport[-endPort]:]containerport[-endPort][/protocol]
-	toReturn := make([]types.PortMapping, 0, len(ports))
-
-	for _, p := range ports {
-		var (
-			ctrPort                 string
-			proto, hostIP, hostPort *string
-		)
-
-		splitProto := strings.Split(p, "/")
-		switch len(splitProto) {
-		case 1:
-			// No protocol was provided
-		case 2:
-			proto = &(splitProto[1])
-		default:
-			return nil, errors.Errorf("invalid port format - protocol can only be specified once")
-		}
-
-		remainder := splitProto[0]
-		haveV6 := false
-
-		// Check for an IPv6 address in brackets
-		splitV6 := strings.Split(remainder, "]")
-		switch len(splitV6) {
-		case 1:
-			// Do nothing, proceed as before
-		case 2:
-			// We potentially have an IPv6 address
-			haveV6 = true
-			if !strings.HasPrefix(splitV6[0], "[") {
-				return nil, errors.Errorf("invalid port format - IPv6 addresses must be enclosed by []")
-			}
-			if !strings.HasPrefix(splitV6[1], ":") {
-				return nil, errors.Errorf("invalid port format - IPv6 address must be followed by a colon (':')")
-			}
-			ipNoPrefix := strings.TrimPrefix(splitV6[0], "[")
-			hostIP = &ipNoPrefix
-			remainder = strings.TrimPrefix(splitV6[1], ":")
-		default:
-			return nil, errors.Errorf("invalid port format - at most one IPv6 address can be specified in a --publish")
-		}
-
-		splitPort := strings.Split(remainder, ":")
-		switch len(splitPort) {
-		case 1:
-			if haveV6 {
-				return nil, errors.Errorf("invalid port format - must provide host and destination port if specifying an IP")
-			}
-			ctrPort = splitPort[0]
-		case 2:
-			hostPort = &(splitPort[0])
-			ctrPort = splitPort[1]
-		case 3:
-			if haveV6 {
-				return nil, errors.Errorf("invalid port format - when v6 address specified, must be [ipv6]:hostPort:ctrPort")
-			}
-			hostIP = &(splitPort[0])
-			hostPort = &(splitPort[1])
-			ctrPort = splitPort[2]
-		default:
-			return nil, errors.Errorf("invalid port format - format is [[hostIP:]hostPort:]containerPort")
-		}
-
-		newPort, err := parseSplitPort(hostIP, hostPort, ctrPort, proto)
-		if err != nil {
-			return nil, err
-		}
-
-		toReturn = append(toReturn, newPort)
-	}
-
-	return toReturn, nil
-}
-
-// parseSplitPort parses individual components of the --publish flag to produce
-// a single port mapping in SpecGen format.
-func parseSplitPort(hostIP, hostPort *string, ctrPort string, protocol *string) (types.PortMapping, error) {
-	newPort := types.PortMapping{}
-	if ctrPort == "" {
-		return newPort, errors.Errorf("must provide a non-empty container port to publish")
-	}
-	ctrStart, ctrLen, err := parseAndValidateRange(ctrPort)
-	if err != nil {
-		return newPort, errors.Wrapf(err, "error parsing container port")
-	}
-	newPort.ContainerPort = ctrStart
-	newPort.Range = ctrLen
-
-	if protocol != nil {
-		if *protocol == "" {
-			return newPort, errors.Errorf("must provide a non-empty protocol to publish")
-		}
-		newPort.Protocol = *protocol
-	}
-	if hostIP != nil {
-		if *hostIP == "" {
-			return newPort, errors.Errorf("must provide a non-empty container host IP to publish")
-		} else if *hostIP != "0.0.0.0" {
-			// If hostIP is 0.0.0.0, leave it unset - CNI treats
-			// 0.0.0.0 and empty differently, Docker does not.
-			testIP := net.ParseIP(*hostIP)
-			if testIP == nil {
-				return newPort, errors.Errorf("cannot parse %q as an IP address", *hostIP)
-			}
-			newPort.HostIP = testIP.String()
-		}
-	}
-	if hostPort != nil {
-		if *hostPort == "" {
-			// Set 0 as a placeholder. The server side of Specgen
-			// will find a random, open, unused port to use.
-			newPort.HostPort = 0
-		} else {
-			hostStart, hostLen, err := parseAndValidateRange(*hostPort)
-			if err != nil {
-				return newPort, errors.Wrapf(err, "error parsing host port")
-			}
-			if hostLen != ctrLen {
-				return newPort, errors.Errorf("host and container port ranges have different lengths: %d vs %d", hostLen, ctrLen)
-			}
-			newPort.HostPort = hostStart
-		}
-	}
-
-	hport := newPort.HostPort
-	logrus.Debugf("Adding port mapping from %d to %d length %d protocol %q", hport, newPort.ContainerPort, newPort.Range, newPort.Protocol)
-
-	return newPort, nil
-}
-
-// Parse and validate a port range.
-// Returns start port, length of range, error.
-func parseAndValidateRange(portRange string) (uint16, uint16, error) {
-	splitRange := strings.Split(portRange, "-")
-	if len(splitRange) > 2 {
-		return 0, 0, errors.Errorf("invalid port format - port ranges are formatted as startPort-stopPort")
-	}
-
-	if splitRange[0] == "" {
-		return 0, 0, errors.Errorf("port numbers cannot be negative")
-	}
-
-	startPort, err := parseAndValidatePort(splitRange[0])
-	if err != nil {
-		return 0, 0, err
-	}
-
-	var rangeLen uint16 = 1
-	if len(splitRange) == 2 {
-		if splitRange[1] == "" {
-			return 0, 0, errors.Errorf("must provide ending number for port range")
-		}
-		endPort, err := parseAndValidatePort(splitRange[1])
-		if err != nil {
-			return 0, 0, err
-		}
-		if endPort <= startPort {
-			return 0, 0, errors.Errorf("the end port of a range must be higher than the start port - %d is not higher than %d", endPort, startPort)
-		}
-		// Our range is the total number of ports
-		// involved, so we need to add 1 (8080:8081 is
-		// 2 ports, for example, not 1)
-		rangeLen = endPort - startPort + 1
-	}
-
-	return startPort, rangeLen, nil
-}
-
-// Turn a single string into a valid U16 port.
-func parseAndValidatePort(port string) (uint16, error) {
-	num, err := strconv.Atoi(port)
-	if err != nil {
-		return 0, errors.Wrapf(err, "invalid port number")
-	}
-	if num < 1 || num > 65535 {
-		return 0, errors.Errorf("port numbers must be between 1 and 65535 (inclusive), got %d", num)
-	}
-	return uint16(num), nil
-}