{
					ContainerPort: 8001,
					HostPort:      8001,
					Protocol:      v1.ProtocolTCP,
				},
				{
					ContainerPort: 8002,
					HostPort:      8002,
					Protocol:      v1.ProtocolTCP,
				},
				{
					ContainerPort: 8003,
					HostPort:      8003,
					Protocol:      v1.ProtocolTCP,
				},
				{
					ContainerPort: 8004,
					HostPort:      8004,
					Protocol:      v1.ProtocolTCP,

			hostport:      "cp.k8s.io:-987654321",
			expectedError: true,
		},
		{
			name:          "invalid port(out of range, negative port number)",
			hostport:      "cp.k8s.io:123:123",
			expectedError: true,
		},
		{
			name:          "invalid dns",
			hostport:      "bad!!cp.k8s.io",
			expectedError: true,
		},
		{
			name:          "invalid valid dns:port",

						Ports: []api.ContainerPort{
							{ContainerPort: 80, HostPort: 80, Protocol: api.ProtocolUDP},
							{ContainerPort: 180, HostPort: 80, Protocol: api.ProtocolUDP},
							{ContainerPort: 80, HostPort: 80, Protocol: api.ProtocolUDP},
						},
					},
					{
						Name: "foo",
						Ports: []api.ContainerPort{
							{ContainerPort: 80, HostPort: 80, Protocol: api.ProtocolUDP},

		if bytealg.IndexByteString(host, ':') >= 0 {
			return addrErr(hostport, tooManyColons)
		}
	}
	if bytealg.IndexByteString(hostport[j:], '[') >= 0 {
		return addrErr(hostport, "unexpected '[' in address")
	}
	if bytealg.IndexByteString(hostport[k:], ']') >= 0 {
		return addrErr(hostport, "unexpected ']' in address")
	}

	port = hostport[i+1:]
	return host, port, nil
}

	ClientConfigForFunc        func(hostPort string) (*rest.Config, error)
	ClientConfigForServiceFunc func(serviceName, serviceNamespace string, servicePort int) (*rest.Config, error)
}

// ClientConfigFor returns client config for given hostPort.
func (a *AuthenticationInfoResolverDelegator) ClientConfigFor(hostPort string) (*rest.Config, error) {
	return a.ClientConfigForFunc(hostPort)
}

		accumulator *sets.String
		fldPath     *field.Path
	}{{
		name: "HostPort is not allocated while containers use the same port with different protocol",
		containers: []v1.Container{{
			Ports: []v1.ContainerPort{{
				HostPort: 8080,
				Protocol: v1.ProtocolUDP,
			}},
		}, {
			Ports: []v1.ContainerPort{{
				HostPort: 8080,
				Protocol: v1.ProtocolTCP,
			}},
		}},
		accumulator: &sets.String{},

		s.instancesByHostAndPort.Delete(hostPort{ikey, i.ServicePort.Port})
		oldInstances := s.instances[ikey][key]
		delete(s.instances[ikey], key)
		if len(s.instances[ikey]) == 0 {
			delete(s.instances, ikey)
		}
		delete(s.ip2instance, i.Endpoint.Address)
		// Cleanup stale IPs, if the IPs changed
		for _, oi := range oldInstances {
			s.instancesByHostAndPort.Delete(hostPort{ikey, oi.ServicePort.Port})

func ParseHostPort(hostport string) (string, string, error) {
	var host, port string
	var err error

	// try to split host and port
	if host, port, err = net.SplitHostPort(hostport); err != nil {
		// if SplitHostPort returns an error, the entire hostport is considered as host
		host = hostport
	}

	// if port is defined, parse and validate it
	if port != "" {

      timeoutSeconds: 60
    ports:
    - name: agentport
      containerPort: {{ agent_port }}
      hostPort: {{ agent_port }}
    - name: healthport
      containerPort: {{ health_port }}
      hostPort: {{ health_port }}
    - name: adminport
      containerPort: {{ admin_port }}
      hostPort: {{ admin_port }}
    volumeMounts:
    - name: varlogkonnectivityserver
      mountPath: /var/log/konnectivity-server.log

	return b
}

// WithHostPort sets the HostPort field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the HostPort field is set to the value of the last call.
func (b *ContainerPortApplyConfiguration) WithHostPort(value int32) *ContainerPortApplyConfiguration {
	b.HostPort = &value
	return b
}