func loadPorts()

in pkg/loader/compose/v1v2.go [90:167]
63 lines of code
17 McCabe index (conditional complexity)

func loadPorts(composePorts []string, expose []string) ([]kobject.Ports, error) {
	kp := []kobject.Ports{}
	exist := map[string]bool{}

	for _, cp := range composePorts {
		var hostIP string

		if parts := strings.Split(cp, ":"); len(parts) == 3 {
			if ip := net.ParseIP(parts[0]); ip.To4() == nil && ip.To16() == nil {
				return nil, fmt.Errorf("%q contains an invalid IPv4 or IPv6 IP address", parts[0])
			}
			hostIP = parts[0]
		}

		np, pbs, err := nat.ParsePortSpecs([]string{cp})
		if err != nil {
			return nil, fmt.Errorf("invalid port, error = %v", err)
		}
		// Force HostIP value to avoid warning raised by github.com/docker/cli/opts
		// The opts package will warn if the bindings contains host IP except
		// 0.0.0.0. However, the message is not useful in this case since the value
		// should be handled by kompose properly.
		for _, pb := range pbs {
			for i, p := range pb {
				p.HostIP = ""
				pb[i] = p
			}
		}

		var ports []string
		for p := range np {
			ports = append(ports, string(p))
		}
		sort.Strings(ports)

		for _, p := range ports {
			pc, err := opts.ConvertPortToPortConfig(nat.Port(p), pbs)
			if err != nil {
				return nil, fmt.Errorf("invalid port, error = %v", err)
			}
			for _, cfg := range pc {
				kp = append(kp, kobject.Ports{
					HostPort:      int32(cfg.PublishedPort),
					ContainerPort: int32(cfg.TargetPort),
					HostIP:        hostIP,
					Protocol:      strings.ToUpper(string(cfg.Protocol)),
				})
			}
		}
	}

	// load remain expose ports
	for _, p := range kp {
		// must use cast...
		exist[cast.ToString(p.ContainerPort)+p.Protocol] = true
	}

	if expose != nil {
		for _, port := range expose {
			portValue := port
			protocol := string(api.ProtocolTCP)
			if strings.Contains(portValue, "/") {
				splits := strings.Split(port, "/")
				portValue = splits[0]
				protocol = splits[1]
			}

			if !exist[portValue+protocol] {
				kp = append(kp, kobject.Ports{
					ContainerPort: cast.ToInt32(portValue),
					Protocol:      strings.ToUpper(protocol),
				})
			}
		}
	}

	return kp, nil
}