github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-27 21:47:07 +00:00
Code Issues Projects Releases Wiki Activity

Add Namespace to e2eservice.TestJig, make all methods use jig namespace and name

Browse Source 
Many TestJig methods made the caller pass a serviceName argument, even
though the jig already has a name, and every caller was passing the
same name to each function as they had passed to NewTestJig().

Likewise, many methods made the caller pass a namespace argument, but
only a single test used more than one namespace, and it can easily be
rewritten to use two test jigs as well.
This commit is contained in:
Dan Winship 2019-07-31 17:40:00 -04:00
parent a0ad420018
commit 52b366457f
9 changed files with 274 additions and 272 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
test/e2e/apps/deployment.go
View File

@ -899,9 +899,9 @@ func testRollingUpdateDeploymentWithLocalTrafficLoadBalancer(f *framework.Framew
framework.ExpectNoError(err) framework.ExpectNoError(err)
framework.Logf("Creating a service %s with type=LoadBalancer and externalTrafficPolicy=Local in namespace %s", name, ns) framework.Logf("Creating a service %s with type=LoadBalancer and externalTrafficPolicy=Local in namespace %s", name, ns)
jig := e2eservice.NewTestJig(c, name) jig := e2eservice.NewTestJig(c, ns, name)
jig.Labels = podLabels jig.Labels = podLabels
service, err := jig.CreateLoadBalancerService(ns, name, e2eservice.LoadBalancerCreateTimeoutDefault, func(svc *v1.Service) { service, err := jig.CreateLoadBalancerService(e2eservice.LoadBalancerCreateTimeoutDefault, func(svc *v1.Service) {
svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -922,14 +922,14 @@ func testRollingUpdateDeploymentWithLocalTrafficLoadBalancer(f *framework.Framew
defer close(done) defer close(done)
go func() { go func() {
defer ginkgo.GinkgoRecover() defer ginkgo.GinkgoRecover()
expectedNodes, err := jig.GetEndpointNodeNames(service) expectedNodes, err := jig.GetEndpointNodeNames()
framework.ExpectNoError(err) framework.ExpectNoError(err)
// The affinity policy should ensure that before an old pod is // The affinity policy should ensure that before an old pod is
// deleted, a new pod will have been created on the same node. // deleted, a new pod will have been created on the same node.
// Thus the set of nodes with local endpoints for the service // Thus the set of nodes with local endpoints for the service
// should remain unchanged. // should remain unchanged.
wait.Until(func() { wait.Until(func() {
actualNodes, err := jig.GetEndpointNodeNames(service) actualNodes, err := jig.GetEndpointNodeNames()
framework.ExpectNoError(err) framework.ExpectNoError(err)
if !actualNodes.Equal(expectedNodes) { if !actualNodes.Equal(expectedNodes) {
framework.Logf("The set of nodes with local endpoints changed; started with %v, now have %v", expectedNodes.List(), actualNodes.List()) framework.Logf("The set of nodes with local endpoints changed; started with %v, now have %v", expectedNodes.List(), actualNodes.List())

6
test/e2e/framework/ingress/ingress_utils.go
View File

@ -841,8 +841,8 @@ func (cont *NginxIngressController) Init() {
// --publish-service flag (see <IngressManifestPath>/nginx/rc.yaml) to make it work in private // --publish-service flag (see <IngressManifestPath>/nginx/rc.yaml) to make it work in private
// clusters, i.e. clusters where nodes don't have public IPs. // clusters, i.e. clusters where nodes don't have public IPs.
framework.Logf("Creating load balancer service for nginx ingress controller") framework.Logf("Creating load balancer service for nginx ingress controller")
serviceJig := e2eservice.NewTestJig(cont.Client, "nginx-ingress-lb") serviceJig := e2eservice.NewTestJig(cont.Client, cont.Ns, "nginx-ingress-lb")
_, err := serviceJig.CreateTCPService(cont.Ns, func(svc *v1.Service) { _, err := serviceJig.CreateTCPService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.Type = v1.ServiceTypeLoadBalancer
svc.Spec.Selector = map[string]string{"k8s-app": "nginx-ingress-lb"} svc.Spec.Selector = map[string]string{"k8s-app": "nginx-ingress-lb"}
svc.Spec.Ports = []v1.ServicePort{ svc.Spec.Ports = []v1.ServicePort{
@ -851,7 +851,7 @@ func (cont *NginxIngressController) Init() {
{Name: "stats", Port: 18080}} {Name: "stats", Port: 18080}}
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
cont.lbSvc, err = serviceJig.WaitForLoadBalancer(cont.Ns, "nginx-ingress-lb", e2eservice.GetServiceLoadBalancerCreationTimeout(cont.Client)) cont.lbSvc, err = serviceJig.WaitForLoadBalancer(e2eservice.GetServiceLoadBalancerCreationTimeout(cont.Client))
framework.ExpectNoError(err) framework.ExpectNoError(err)
read := func(file string) string { read := func(file string) string {

224
test/e2e/framework/service/jig.go
View File

@ -53,16 +53,18 @@ var NodePortRange = utilnet.PortRange{Base: 30000, Size: 2768}
// TestJig is a test jig to help service testing. // TestJig is a test jig to help service testing.
type TestJig struct { type TestJig struct {
ID string Client clientset.Interface
Name string Namespace string
Client clientset.Interface Name string
Labels map[string]string ID string
Labels map[string]string
} }
// NewTestJig allocates and inits a new TestJig. // NewTestJig allocates and inits a new TestJig.
func NewTestJig(client clientset.Interface, name string) *TestJig { func NewTestJig(client clientset.Interface, namespace, name string) *TestJig {
j := &TestJig{} j := &TestJig{}
j.Client = client j.Client = client
j.Namespace = namespace
j.Name = name j.Name = name
j.ID = j.Name + "-" + string(uuid.NewUUID()) j.ID = j.Name + "-" + string(uuid.NewUUID())
j.Labels = map[string]string{"testid": j.ID} j.Labels = map[string]string{"testid": j.ID}
@ -73,10 +75,10 @@ func NewTestJig(client clientset.Interface, name string) *TestJig {
// newServiceTemplate returns the default v1.Service template for this j, but // newServiceTemplate returns the default v1.Service template for this j, but
// does not actually create the Service. The default Service has the same name // does not actually create the Service. The default Service has the same name
// as the j and exposes the given port. // as the j and exposes the given port.
func (j *TestJig) newServiceTemplate(namespace string, proto v1.Protocol, port int32) *v1.Service { func (j *TestJig) newServiceTemplate(proto v1.Protocol, port int32) *v1.Service {
service := &v1.Service{ service := &v1.Service{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
Namespace: namespace, Namespace: j.Namespace,
Name: j.Name, Name: j.Name,
Labels: j.Labels, Labels: j.Labels,
}, },
@ -96,12 +98,12 @@ func (j *TestJig) newServiceTemplate(namespace string, proto v1.Protocol, port i
// CreateTCPServiceWithPort creates a new TCP Service with given port based on the // CreateTCPServiceWithPort creates a new TCP Service with given port based on the
// j's defaults. Callers can provide a function to tweak the Service object before // j's defaults. Callers can provide a function to tweak the Service object before
// it is created. // it is created.
func (j *TestJig) CreateTCPServiceWithPort(namespace string, tweak func(svc *v1.Service), port int32) (*v1.Service, error) { func (j *TestJig) CreateTCPServiceWithPort(tweak func(svc *v1.Service), port int32) (*v1.Service, error) {
svc := j.newServiceTemplate(namespace, v1.ProtocolTCP, port) svc := j.newServiceTemplate(v1.ProtocolTCP, port)
if tweak != nil { if tweak != nil {
tweak(svc) tweak(svc)
} }
result, err := j.Client.CoreV1().Services(namespace).Create(svc) result, err := j.Client.CoreV1().Services(j.Namespace).Create(svc)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to create TCP Service %q: %v", svc.Name, err) return nil, fmt.Errorf("failed to create TCP Service %q: %v", svc.Name, err)
} }
@ -111,12 +113,12 @@ func (j *TestJig) CreateTCPServiceWithPort(namespace string, tweak func(svc *v1.
// CreateTCPService creates a new TCP Service based on the j's // CreateTCPService creates a new TCP Service based on the j's
// defaults. Callers can provide a function to tweak the Service object before // defaults. Callers can provide a function to tweak the Service object before
// it is created. // it is created.
func (j *TestJig) CreateTCPService(namespace string, tweak func(svc *v1.Service)) (*v1.Service, error) { func (j *TestJig) CreateTCPService(tweak func(svc *v1.Service)) (*v1.Service, error) {
svc := j.newServiceTemplate(namespace, v1.ProtocolTCP, 80) svc := j.newServiceTemplate(v1.ProtocolTCP, 80)
if tweak != nil { if tweak != nil {
tweak(svc) tweak(svc)
} }
result, err := j.Client.CoreV1().Services(namespace).Create(svc) result, err := j.Client.CoreV1().Services(j.Namespace).Create(svc)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to create TCP Service %q: %v", svc.Name, err) return nil, fmt.Errorf("failed to create TCP Service %q: %v", svc.Name, err)
} }
@ -126,12 +128,12 @@ func (j *TestJig) CreateTCPService(namespace string, tweak func(svc *v1.Service)
// CreateUDPService creates a new UDP Service based on the j's // CreateUDPService creates a new UDP Service based on the j's
// defaults. Callers can provide a function to tweak the Service object before // defaults. Callers can provide a function to tweak the Service object before
// it is created. // it is created.
func (j *TestJig) CreateUDPService(namespace string, tweak func(svc *v1.Service)) (*v1.Service, error) { func (j *TestJig) CreateUDPService(tweak func(svc *v1.Service)) (*v1.Service, error) {
svc := j.newServiceTemplate(namespace, v1.ProtocolUDP, 80) svc := j.newServiceTemplate(v1.ProtocolUDP, 80)
if tweak != nil { if tweak != nil {
tweak(svc) tweak(svc)
} }
result, err := j.Client.CoreV1().Services(namespace).Create(svc) result, err := j.Client.CoreV1().Services(j.Namespace).Create(svc)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to create UDP Service %q: %v", svc.Name, err) return nil, fmt.Errorf("failed to create UDP Service %q: %v", svc.Name, err)
} }
@ -140,10 +142,10 @@ func (j *TestJig) CreateUDPService(namespace string, tweak func(svc *v1.Service)
// CreateExternalNameService creates a new ExternalName type Service based on the j's defaults. // CreateExternalNameService creates a new ExternalName type Service based on the j's defaults.
// Callers can provide a function to tweak the Service object before it is created. // Callers can provide a function to tweak the Service object before it is created.
func (j *TestJig) CreateExternalNameService(namespace string, tweak func(svc *v1.Service)) (*v1.Service, error) { func (j *TestJig) CreateExternalNameService(tweak func(svc *v1.Service)) (*v1.Service, error) {
svc := &v1.Service{ svc := &v1.Service{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
Namespace: namespace, Namespace: j.Namespace,
Name: j.Name, Name: j.Name,
Labels: j.Labels, Labels: j.Labels,
}, },
@ -156,7 +158,7 @@ func (j *TestJig) CreateExternalNameService(namespace string, tweak func(svc *v1
if tweak != nil { if tweak != nil {
tweak(svc) tweak(svc)
} }
result, err := j.Client.CoreV1().Services(namespace).Create(svc) result, err := j.Client.CoreV1().Services(j.Namespace).Create(svc)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to create ExternalName Service %q: %v", svc.Name, err) return nil, fmt.Errorf("failed to create ExternalName Service %q: %v", svc.Name, err)
} }
@ -164,9 +166,9 @@ func (j *TestJig) CreateExternalNameService(namespace string, tweak func(svc *v1
} }
// ChangeServiceType updates the given service's ServiceType to the given newType. // ChangeServiceType updates the given service's ServiceType to the given newType.
func (j *TestJig) ChangeServiceType(namespace, name string, newType v1.ServiceType, timeout time.Duration) error { func (j *TestJig) ChangeServiceType(newType v1.ServiceType, timeout time.Duration) error {
ingressIP := "" ingressIP := ""
svc, err := j.UpdateService(namespace, name, func(s *v1.Service) { svc, err := j.UpdateService(func(s *v1.Service) {
for _, ing := range s.Status.LoadBalancer.Ingress { for _, ing := range s.Status.LoadBalancer.Ingress {
if ing.IP != "" { if ing.IP != "" {
ingressIP = ing.IP ingressIP = ing.IP
@ -179,7 +181,7 @@ func (j *TestJig) ChangeServiceType(namespace, name string, newType v1.ServiceTy
return err return err
} }
if ingressIP != "" { if ingressIP != "" {
_, err = j.WaitForLoadBalancerDestroy(namespace, svc.Name, ingressIP, int(svc.Spec.Ports[0].Port), timeout) _, err = j.WaitForLoadBalancerDestroy(ingressIP, int(svc.Spec.Ports[0].Port), timeout)
} }
return err return err
} }
@ -188,9 +190,9 @@ func (j *TestJig) ChangeServiceType(namespace, name string, newType v1.ServiceTy
// ExternalTrafficPolicy set to Local and sanity checks its nodePort. // ExternalTrafficPolicy set to Local and sanity checks its nodePort.
// If createPod is true, it also creates an RC with 1 replica of // If createPod is true, it also creates an RC with 1 replica of
// the standard netexec container used everywhere in this test. // the standard netexec container used everywhere in this test.
func (j *TestJig) CreateOnlyLocalNodePortService(namespace, serviceName string, createPod bool) (*v1.Service, error) { func (j *TestJig) CreateOnlyLocalNodePortService(createPod bool) (*v1.Service, error) {
ginkgo.By("creating a service " + namespace + "/" + serviceName + " with type=NodePort and ExternalTrafficPolicy=Local") ginkgo.By("creating a service " + j.Namespace + "/" + j.Name + " with type=NodePort and ExternalTrafficPolicy=Local")
svc, err := j.CreateTCPService(namespace, func(svc *v1.Service) { svc, err := j.CreateTCPService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeNodePort svc.Spec.Type = v1.ServiceTypeNodePort
svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal
svc.Spec.Ports = []v1.ServicePort{{Protocol: v1.ProtocolTCP, Port: 80}} svc.Spec.Ports = []v1.ServicePort{{Protocol: v1.ProtocolTCP, Port: 80}}
@ -200,8 +202,8 @@ func (j *TestJig) CreateOnlyLocalNodePortService(namespace, serviceName string,
} }
if createPod { if createPod {
ginkgo.By("creating a pod to be part of the service " + serviceName) ginkgo.By("creating a pod to be part of the service " + j.Name)
_, err = j.Run(namespace, nil) _, err = j.Run(nil)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -213,9 +215,9 @@ func (j *TestJig) CreateOnlyLocalNodePortService(namespace, serviceName string,
// ExternalTrafficPolicy set to Local and waits for it to acquire an ingress IP. // ExternalTrafficPolicy set to Local and waits for it to acquire an ingress IP.
// If createPod is true, it also creates an RC with 1 replica of // If createPod is true, it also creates an RC with 1 replica of
// the standard netexec container used everywhere in this test. // the standard netexec container used everywhere in this test.
func (j *TestJig) CreateOnlyLocalLoadBalancerService(namespace, serviceName string, timeout time.Duration, createPod bool, func (j *TestJig) CreateOnlyLocalLoadBalancerService(timeout time.Duration, createPod bool,
tweak func(svc *v1.Service)) (*v1.Service, error) { tweak func(svc *v1.Service)) (*v1.Service, error) {
_, err := j.CreateLoadBalancerService(namespace, serviceName, timeout, func(svc *v1.Service) { _, err := j.CreateLoadBalancerService(timeout, func(svc *v1.Service) {
ginkgo.By("setting ExternalTrafficPolicy=Local") ginkgo.By("setting ExternalTrafficPolicy=Local")
svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal
if tweak != nil { if tweak != nil {
@ -227,44 +229,44 @@ func (j *TestJig) CreateOnlyLocalLoadBalancerService(namespace, serviceName stri
} }
if createPod { if createPod {
ginkgo.By("creating a pod to be part of the service " + serviceName) ginkgo.By("creating a pod to be part of the service " + j.Name)
_, err = j.Run(namespace, nil) _, err = j.Run(nil)
if err != nil { if err != nil {
return nil, err return nil, err
} }
} }
ginkgo.By("waiting for loadbalancer for service " + namespace + "/" + serviceName) ginkgo.By("waiting for loadbalancer for service " + j.Namespace + "/" + j.Name)
return j.WaitForLoadBalancer(namespace, serviceName, timeout) return j.WaitForLoadBalancer(timeout)
} }
// CreateLoadBalancerService creates a loadbalancer service and waits // CreateLoadBalancerService creates a loadbalancer service and waits
// for it to acquire an ingress IP. // for it to acquire an ingress IP.
func (j *TestJig) CreateLoadBalancerService(namespace, serviceName string, timeout time.Duration, tweak func(svc *v1.Service)) (*v1.Service, error) { func (j *TestJig) CreateLoadBalancerService(timeout time.Duration, tweak func(svc *v1.Service)) (*v1.Service, error) {
ginkgo.By("creating a service " + namespace + "/" + serviceName + " with type=LoadBalancer") ginkgo.By("creating a service " + j.Namespace + "/" + j.Name + " with type=LoadBalancer")
svc := j.newServiceTemplate(namespace, v1.ProtocolTCP, 80) svc := j.newServiceTemplate(v1.ProtocolTCP, 80)
svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.Type = v1.ServiceTypeLoadBalancer
// We need to turn affinity off for our LB distribution tests // We need to turn affinity off for our LB distribution tests
svc.Spec.SessionAffinity = v1.ServiceAffinityNone svc.Spec.SessionAffinity = v1.ServiceAffinityNone
if tweak != nil { if tweak != nil {
tweak(svc) tweak(svc)
} }
_, err := j.Client.CoreV1().Services(namespace).Create(svc) _, err := j.Client.CoreV1().Services(j.Namespace).Create(svc)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to create LoadBalancer Service %q: %v", svc.Name, err) return nil, fmt.Errorf("failed to create LoadBalancer Service %q: %v", svc.Name, err)
} }
ginkgo.By("waiting for loadbalancer for service " + namespace + "/" + serviceName) ginkgo.By("waiting for loadbalancer for service " + j.Namespace + "/" + j.Name)
return j.WaitForLoadBalancer(namespace, serviceName, timeout) return j.WaitForLoadBalancer(timeout)
} }
// GetEndpointNodes returns a map of nodenames:external-ip on which the // GetEndpointNodes returns a map of nodenames:external-ip on which the
// endpoints of the given Service are running. // endpoints of the Service are running.
func (j *TestJig) GetEndpointNodes(svc *v1.Service) (map[string][]string, error) { func (j *TestJig) GetEndpointNodes() (map[string][]string, error) {
nodes, err := e2enode.GetBoundedReadySchedulableNodes(j.Client, MaxNodesForEndpointsTests) nodes, err := e2enode.GetBoundedReadySchedulableNodes(j.Client, MaxNodesForEndpointsTests)
if err != nil { if err != nil {
return nil, err return nil, err
} }
epNodes, err := j.GetEndpointNodeNames(svc) epNodes, err := j.GetEndpointNodeNames()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -279,10 +281,10 @@ func (j *TestJig) GetEndpointNodes(svc *v1.Service) (map[string][]string, error)
// GetEndpointNodeNames returns a string set of node names on which the // GetEndpointNodeNames returns a string set of node names on which the
// endpoints of the given Service are running. // endpoints of the given Service are running.
func (j *TestJig) GetEndpointNodeNames(svc *v1.Service) (sets.String, error) { func (j *TestJig) GetEndpointNodeNames() (sets.String, error) {
endpoints, err := j.Client.CoreV1().Endpoints(svc.Namespace).Get(svc.Name, metav1.GetOptions{}) endpoints, err := j.Client.CoreV1().Endpoints(j.Namespace).Get(j.Name, metav1.GetOptions{})
if err != nil { if err != nil {
return nil, fmt.Errorf("get endpoints for service %s/%s failed (%s)", svc.Namespace, svc.Name, err) return nil, fmt.Errorf("get endpoints for service %s/%s failed (%s)", j.Namespace, j.Name, err)
} }
if len(endpoints.Subsets) == 0 { if len(endpoints.Subsets) == 0 {
return nil, fmt.Errorf("endpoint has no subsets, cannot determine node addresses") return nil, fmt.Errorf("endpoint has no subsets, cannot determine node addresses")
@ -299,11 +301,11 @@ func (j *TestJig) GetEndpointNodeNames(svc *v1.Service) (sets.String, error) {
} }
// WaitForEndpointOnNode waits for a service endpoint on the given node. // WaitForEndpointOnNode waits for a service endpoint on the given node.
func (j *TestJig) WaitForEndpointOnNode(namespace, serviceName, nodeName string) error { func (j *TestJig) WaitForEndpointOnNode(nodeName string) error {
return wait.PollImmediate(framework.Poll, LoadBalancerCreateTimeoutDefault, func() (bool, error) { return wait.PollImmediate(framework.Poll, LoadBalancerCreateTimeoutDefault, func() (bool, error) {
endpoints, err := j.Client.CoreV1().Endpoints(namespace).Get(serviceName, metav1.GetOptions{}) endpoints, err := j.Client.CoreV1().Endpoints(j.Namespace).Get(j.Name, metav1.GetOptions{})
if err != nil { if err != nil {
framework.Logf("Get endpoints for service %s/%s failed (%s)", namespace, serviceName, err) framework.Logf("Get endpoints for service %s/%s failed (%s)", j.Namespace, j.Name, err)
return false, nil return false, nil
} }
if len(endpoints.Subsets) == 0 { if len(endpoints.Subsets) == 0 {
@ -316,7 +318,7 @@ func (j *TestJig) WaitForEndpointOnNode(namespace, serviceName, nodeName string)
return false, nil return false, nil
} }
epHostName := *endpoints.Subsets[0].Addresses[0].NodeName epHostName := *endpoints.Subsets[0].Addresses[0].NodeName
framework.Logf("Pod for service %s/%s is on node %s", namespace, serviceName, epHostName) framework.Logf("Pod for service %s/%s is on node %s", j.Namespace, j.Name, epHostName)
if epHostName != nodeName { if epHostName != nodeName {
framework.Logf("Found endpoint on wrong node, expected %v, got %v", nodeName, epHostName) framework.Logf("Found endpoint on wrong node, expected %v, got %v", nodeName, epHostName)
return false, nil return false, nil
@ -326,9 +328,9 @@ func (j *TestJig) WaitForEndpointOnNode(namespace, serviceName, nodeName string)
} }
// WaitForAvailableEndpoint waits for at least 1 endpoint to be available till timeout // WaitForAvailableEndpoint waits for at least 1 endpoint to be available till timeout
func (j *TestJig) WaitForAvailableEndpoint(namespace, serviceName string, timeout time.Duration) error { func (j *TestJig) WaitForAvailableEndpoint(timeout time.Duration) error {
//Wait for endpoints to be created, this may take longer time if service backing pods are taking longer time to run //Wait for endpoints to be created, this may take longer time if service backing pods are taking longer time to run
endpointSelector := fields.OneTermEqualSelector("metadata.name", serviceName) endpointSelector := fields.OneTermEqualSelector("metadata.name", j.Name)
stopCh := make(chan struct{}) stopCh := make(chan struct{})
endpointAvailable := false endpointAvailable := false
var controller cache.Controller var controller cache.Controller
@ -336,12 +338,12 @@ func (j *TestJig) WaitForAvailableEndpoint(namespace, serviceName string, timeou
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
options.FieldSelector = endpointSelector.String() options.FieldSelector = endpointSelector.String()
obj, err := j.Client.CoreV1().Endpoints(namespace).List(options) obj, err := j.Client.CoreV1().Endpoints(j.Namespace).List(options)
return runtime.Object(obj), err return runtime.Object(obj), err
}, },
WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
options.FieldSelector = endpointSelector.String() options.FieldSelector = endpointSelector.String()
return j.Client.CoreV1().Endpoints(namespace).Watch(options) return j.Client.CoreV1().Endpoints(j.Namespace).Watch(options)
}, },
}, },
&v1.Endpoints{}, &v1.Endpoints{},
@ -373,7 +375,7 @@ func (j *TestJig) WaitForAvailableEndpoint(namespace, serviceName string, timeou
return endpointAvailable, nil return endpointAvailable, nil
}) })
if err != nil { if err != nil {
return fmt.Errorf("no subset of available IP address found for the endpoint %s within timeout %v", serviceName, timeout) return fmt.Errorf("no subset of available IP address found for the endpoint %s within timeout %v", j.Name, timeout)
} }
return nil return nil
} }
@ -438,28 +440,28 @@ func (j *TestJig) sanityCheckService(svc *v1.Service, svcType v1.ServiceType) (*
// UpdateService fetches a service, calls the update function on it, and // UpdateService fetches a service, calls the update function on it, and
// then attempts to send the updated service. It tries up to 3 times in the // then attempts to send the updated service. It tries up to 3 times in the
// face of timeouts and conflicts. // face of timeouts and conflicts.
func (j *TestJig) UpdateService(namespace, name string, update func(*v1.Service)) (*v1.Service, error) { func (j *TestJig) UpdateService(update func(*v1.Service)) (*v1.Service, error) {
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
service, err := j.Client.CoreV1().Services(namespace).Get(name, metav1.GetOptions{}) service, err := j.Client.CoreV1().Services(j.Namespace).Get(j.Name, metav1.GetOptions{})
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to get Service %q: %v", name, err) return nil, fmt.Errorf("failed to get Service %q: %v", j.Name, err)
} }
update(service) update(service)
result, err := j.Client.CoreV1().Services(namespace).Update(service) result, err := j.Client.CoreV1().Services(j.Namespace).Update(service)
if err == nil { if err == nil {
return j.sanityCheckService(result, service.Spec.Type) return j.sanityCheckService(result, service.Spec.Type)
} }
if !errors.IsConflict(err) && !errors.IsServerTimeout(err) { if !errors.IsConflict(err) && !errors.IsServerTimeout(err) {
return nil, fmt.Errorf("failed to update Service %q: %v", name, err) return nil, fmt.Errorf("failed to update Service %q: %v", j.Name, err)
} }
} }
return nil, fmt.Errorf("too many retries updating Service %q", name) return nil, fmt.Errorf("too many retries updating Service %q", j.Name)
} }
// WaitForNewIngressIP waits for the given service to get a new ingress IP, or returns an error after the given timeout // WaitForNewIngressIP waits for the given service to get a new ingress IP, or returns an error after the given timeout
func (j *TestJig) WaitForNewIngressIP(namespace, name, existingIP string, timeout time.Duration) (*v1.Service, error) { func (j *TestJig) WaitForNewIngressIP(existingIP string, timeout time.Duration) (*v1.Service, error) {
framework.Logf("Waiting up to %v for service %q to get a new ingress IP", timeout, name) framework.Logf("Waiting up to %v for service %q to get a new ingress IP", timeout, j.Name)
service, err := j.waitForCondition(namespace, name, timeout, "have a new ingress IP", func(svc *v1.Service) bool { service, err := j.waitForCondition(timeout, "have a new ingress IP", func(svc *v1.Service) bool {
if len(svc.Status.LoadBalancer.Ingress) == 0 { if len(svc.Status.LoadBalancer.Ingress) == 0 {
return false return false
} }
@ -476,14 +478,14 @@ func (j *TestJig) WaitForNewIngressIP(namespace, name, existingIP string, timeou
} }
// ChangeServiceNodePort changes node ports of the given service. // ChangeServiceNodePort changes node ports of the given service.
func (j *TestJig) ChangeServiceNodePort(namespace, name string, initial int) (*v1.Service, error) { func (j *TestJig) ChangeServiceNodePort(initial int) (*v1.Service, error) {
var err error var err error
var service *v1.Service var service *v1.Service
for i := 1; i < NodePortRange.Size; i++ { for i := 1; i < NodePortRange.Size; i++ {
offs1 := initial - NodePortRange.Base offs1 := initial - NodePortRange.Base
offs2 := (offs1 + i) % NodePortRange.Size offs2 := (offs1 + i) % NodePortRange.Size
newPort := NodePortRange.Base + offs2 newPort := NodePortRange.Base + offs2
service, err = j.UpdateService(namespace, name, func(s *v1.Service) { service, err = j.UpdateService(func(s *v1.Service) {
s.Spec.Ports[0].NodePort = int32(newPort) s.Spec.Ports[0].NodePort = int32(newPort)
}) })
if err != nil && strings.Contains(err.Error(), portallocator.ErrAllocated.Error()) { if err != nil && strings.Contains(err.Error(), portallocator.ErrAllocated.Error()) {
@ -497,9 +499,9 @@ func (j *TestJig) ChangeServiceNodePort(namespace, name string, initial int) (*v
} }
// WaitForLoadBalancer waits the given service to have a LoadBalancer, or returns an error after the given timeout // WaitForLoadBalancer waits the given service to have a LoadBalancer, or returns an error after the given timeout
func (j *TestJig) WaitForLoadBalancer(namespace, name string, timeout time.Duration) (*v1.Service, error) { func (j *TestJig) WaitForLoadBalancer(timeout time.Duration) (*v1.Service, error) {
framework.Logf("Waiting up to %v for service %q to have a LoadBalancer", timeout, name) framework.Logf("Waiting up to %v for service %q to have a LoadBalancer", timeout, j.Name)
service, err := j.waitForCondition(namespace, name, timeout, "have a load balancer", func(svc *v1.Service) bool { service, err := j.waitForCondition(timeout, "have a load balancer", func(svc *v1.Service) bool {
return len(svc.Status.LoadBalancer.Ingress) > 0 return len(svc.Status.LoadBalancer.Ingress) > 0
}) })
if err != nil { if err != nil {
@ -509,7 +511,7 @@ func (j *TestJig) WaitForLoadBalancer(namespace, name string, timeout time.Durat
} }
// WaitForLoadBalancerDestroy waits the given service to destroy a LoadBalancer, or returns an error after the given timeout // WaitForLoadBalancerDestroy waits the given service to destroy a LoadBalancer, or returns an error after the given timeout
func (j *TestJig) WaitForLoadBalancerDestroy(namespace, name string, ip string, port int, timeout time.Duration) (*v1.Service, error) { func (j *TestJig) WaitForLoadBalancerDestroy(ip string, port int, timeout time.Duration) (*v1.Service, error) {
// TODO: once support ticket 21807001 is resolved, reduce this timeout back to something reasonable // TODO: once support ticket 21807001 is resolved, reduce this timeout back to something reasonable
defer func() { defer func() {
if err := framework.EnsureLoadBalancerResourcesDeleted(ip, strconv.Itoa(port)); err != nil { if err := framework.EnsureLoadBalancerResourcesDeleted(ip, strconv.Itoa(port)); err != nil {
@ -517,8 +519,8 @@ func (j *TestJig) WaitForLoadBalancerDestroy(namespace, name string, ip string,
} }
}() }()
framework.Logf("Waiting up to %v for service %q to have no LoadBalancer", timeout, name) framework.Logf("Waiting up to %v for service %q to have no LoadBalancer", timeout, j.Name)
service, err := j.waitForCondition(namespace, name, timeout, "have no load balancer", func(svc *v1.Service) bool { service, err := j.waitForCondition(timeout, "have no load balancer", func(svc *v1.Service) bool {
return len(svc.Status.LoadBalancer.Ingress) == 0 return len(svc.Status.LoadBalancer.Ingress) == 0
}) })
if err != nil { if err != nil {
@ -527,10 +529,10 @@ func (j *TestJig) WaitForLoadBalancerDestroy(namespace, name string, ip string,
return j.sanityCheckService(service, v1.ServiceTypeLoadBalancer) return j.sanityCheckService(service, v1.ServiceTypeLoadBalancer)
} }
func (j *TestJig) waitForCondition(namespace, name string, timeout time.Duration, message string, conditionFn func(*v1.Service) bool) (*v1.Service, error) { func (j *TestJig) waitForCondition(timeout time.Duration, message string, conditionFn func(*v1.Service) bool) (*v1.Service, error) {
var service *v1.Service var service *v1.Service
pollFunc := func() (bool, error) { pollFunc := func() (bool, error) {
svc, err := j.Client.CoreV1().Services(namespace).Get(name, metav1.GetOptions{}) svc, err := j.Client.CoreV1().Services(j.Namespace).Get(j.Name, metav1.GetOptions{})
if err != nil { if err != nil {
return false, err return false, err
} }
@ -541,7 +543,7 @@ func (j *TestJig) waitForCondition(namespace, name string, timeout time.Duration
return false, nil return false, nil
} }
if err := wait.PollImmediate(framework.Poll, timeout, pollFunc); err != nil { if err := wait.PollImmediate(framework.Poll, timeout, pollFunc); err != nil {
return nil, fmt.Errorf("timed out waiting for service %q to %s", name, message) return nil, fmt.Errorf("timed out waiting for service %q to %s", j.Name, message)
} }
return service, nil return service, nil
} }
@ -549,13 +551,13 @@ func (j *TestJig) waitForCondition(namespace, name string, timeout time.Duration
// newRCTemplate returns the default v1.ReplicationController object for // newRCTemplate returns the default v1.ReplicationController object for
// this j, but does not actually create the RC. The default RC has the same // this j, but does not actually create the RC. The default RC has the same
// name as the j and runs the "netexec" container. // name as the j and runs the "netexec" container.
func (j *TestJig) newRCTemplate(namespace string) *v1.ReplicationController { func (j *TestJig) newRCTemplate() *v1.ReplicationController {
var replicas int32 = 1 var replicas int32 = 1
var grace int64 = 3 // so we don't race with kube-proxy when scaling up/down var grace int64 = 3 // so we don't race with kube-proxy when scaling up/down
rc := &v1.ReplicationController{ rc := &v1.ReplicationController{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
Namespace: namespace, Namespace: j.Namespace,
Name: j.Name, Name: j.Name,
Labels: j.Labels, Labels: j.Labels,
}, },
@ -612,13 +614,13 @@ func (j *TestJig) AddRCAntiAffinity(rc *v1.ReplicationController) {
} }
// CreatePDB returns a PodDisruptionBudget for the given ReplicationController, or returns an error if a PodDisruptionBudget isn't ready // CreatePDB returns a PodDisruptionBudget for the given ReplicationController, or returns an error if a PodDisruptionBudget isn't ready
func (j *TestJig) CreatePDB(namespace string, rc *v1.ReplicationController) (*policyv1beta1.PodDisruptionBudget, error) { func (j *TestJig) CreatePDB(rc *v1.ReplicationController) (*policyv1beta1.PodDisruptionBudget, error) {
pdb := j.newPDBTemplate(namespace, rc) pdb := j.newPDBTemplate(rc)
newPdb, err := j.Client.PolicyV1beta1().PodDisruptionBudgets(namespace).Create(pdb) newPdb, err := j.Client.PolicyV1beta1().PodDisruptionBudgets(j.Namespace).Create(pdb)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to create PDB %q %v", pdb.Name, err) return nil, fmt.Errorf("failed to create PDB %q %v", pdb.Name, err)
} }
if err := j.waitForPdbReady(namespace); err != nil { if err := j.waitForPdbReady(); err != nil {
return nil, fmt.Errorf("failed waiting for PDB to be ready: %v", err) return nil, fmt.Errorf("failed waiting for PDB to be ready: %v", err)
} }
@ -628,12 +630,12 @@ func (j *TestJig) CreatePDB(namespace string, rc *v1.ReplicationController) (*po
// newPDBTemplate returns the default policyv1beta1.PodDisruptionBudget object for // newPDBTemplate returns the default policyv1beta1.PodDisruptionBudget object for
// this j, but does not actually create the PDB. The default PDB specifies a // this j, but does not actually create the PDB. The default PDB specifies a
// MinAvailable of N-1 and matches the pods created by the RC. // MinAvailable of N-1 and matches the pods created by the RC.
func (j *TestJig) newPDBTemplate(namespace string, rc *v1.ReplicationController) *policyv1beta1.PodDisruptionBudget { func (j *TestJig) newPDBTemplate(rc *v1.ReplicationController) *policyv1beta1.PodDisruptionBudget {
minAvailable := intstr.FromInt(int(*rc.Spec.Replicas) - 1) minAvailable := intstr.FromInt(int(*rc.Spec.Replicas) - 1)
pdb := &policyv1beta1.PodDisruptionBudget{ pdb := &policyv1beta1.PodDisruptionBudget{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
Namespace: namespace, Namespace: j.Namespace,
Name: j.Name, Name: j.Name,
Labels: j.Labels, Labels: j.Labels,
}, },
@ -649,52 +651,52 @@ func (j *TestJig) newPDBTemplate(namespace string, rc *v1.ReplicationController)
// Run creates a ReplicationController and Pod(s) and waits for the // Run creates a ReplicationController and Pod(s) and waits for the
// Pod(s) to be running. Callers can provide a function to tweak the RC object // Pod(s) to be running. Callers can provide a function to tweak the RC object
// before it is created. // before it is created.
func (j *TestJig) Run(namespace string, tweak func(rc *v1.ReplicationController)) (*v1.ReplicationController, error) { func (j *TestJig) Run(tweak func(rc *v1.ReplicationController)) (*v1.ReplicationController, error) {
rc := j.newRCTemplate(namespace) rc := j.newRCTemplate()
if tweak != nil { if tweak != nil {
tweak(rc) tweak(rc)
} }
result, err := j.Client.CoreV1().ReplicationControllers(namespace).Create(rc) result, err := j.Client.CoreV1().ReplicationControllers(j.Namespace).Create(rc)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to create RC %q: %v", rc.Name, err) return nil, fmt.Errorf("failed to create RC %q: %v", rc.Name, err)
} }
pods, err := j.waitForPodsCreated(namespace, int(*(rc.Spec.Replicas))) pods, err := j.waitForPodsCreated(int(*(rc.Spec.Replicas)))
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to create pods: %v", err) return nil, fmt.Errorf("failed to create pods: %v", err)
} }
if err := j.waitForPodsReady(namespace, pods); err != nil { if err := j.waitForPodsReady(pods); err != nil {
return nil, fmt.Errorf("failed waiting for pods to be running: %v", err) return nil, fmt.Errorf("failed waiting for pods to be running: %v", err)
} }
return result, nil return result, nil
} }
// Scale scales pods to the given replicas // Scale scales pods to the given replicas
func (j *TestJig) Scale(namespace string, replicas int) error { func (j *TestJig) Scale(replicas int) error {
rc := j.Name rc := j.Name
scale, err := j.Client.CoreV1().ReplicationControllers(namespace).GetScale(rc, metav1.GetOptions{}) scale, err := j.Client.CoreV1().ReplicationControllers(j.Namespace).GetScale(rc, metav1.GetOptions{})
if err != nil { if err != nil {
return fmt.Errorf("failed to get scale for RC %q: %v", rc, err) return fmt.Errorf("failed to get scale for RC %q: %v", rc, err)
} }
scale.Spec.Replicas = int32(replicas) scale.Spec.Replicas = int32(replicas)
_, err = j.Client.CoreV1().ReplicationControllers(namespace).UpdateScale(rc, scale) _, err = j.Client.CoreV1().ReplicationControllers(j.Namespace).UpdateScale(rc, scale)
if err != nil { if err != nil {
return fmt.Errorf("failed to scale RC %q: %v", rc, err) return fmt.Errorf("failed to scale RC %q: %v", rc, err)
} }
pods, err := j.waitForPodsCreated(namespace, replicas) pods, err := j.waitForPodsCreated(replicas)
if err != nil { if err != nil {
return fmt.Errorf("failed waiting for pods: %v", err) return fmt.Errorf("failed waiting for pods: %v", err)
} }
if err := j.waitForPodsReady(namespace, pods); err != nil { if err := j.waitForPodsReady(pods); err != nil {
return fmt.Errorf("failed waiting for pods to be running: %v", err) return fmt.Errorf("failed waiting for pods to be running: %v", err)
} }
return nil return nil
} }
func (j *TestJig) waitForPdbReady(namespace string) error { func (j *TestJig) waitForPdbReady() error {
timeout := 2 * time.Minute timeout := 2 * time.Minute
for start := time.Now(); time.Since(start) < timeout; time.Sleep(2 * time.Second) { for start := time.Now(); time.Since(start) < timeout; time.Sleep(2 * time.Second) {
pdb, err := j.Client.PolicyV1beta1().PodDisruptionBudgets(namespace).Get(j.Name, metav1.GetOptions{}) pdb, err := j.Client.PolicyV1beta1().PodDisruptionBudgets(j.Namespace).Get(j.Name, metav1.GetOptions{})
if err != nil { if err != nil {
return err return err
} }
@ -706,14 +708,14 @@ func (j *TestJig) waitForPdbReady(namespace string) error {
return fmt.Errorf("timeout waiting for PDB %q to be ready", j.Name) return fmt.Errorf("timeout waiting for PDB %q to be ready", j.Name)
} }
func (j *TestJig) waitForPodsCreated(namespace string, replicas int) ([]string, error) { func (j *TestJig) waitForPodsCreated(replicas int) ([]string, error) {
timeout := 2 * time.Minute timeout := 2 * time.Minute
// List the pods, making sure we observe all the replicas. // List the pods, making sure we observe all the replicas.
label := labels.SelectorFromSet(labels.Set(j.Labels)) label := labels.SelectorFromSet(labels.Set(j.Labels))
framework.Logf("Waiting up to %v for %d pods to be created", timeout, replicas) framework.Logf("Waiting up to %v for %d pods to be created", timeout, replicas)
for start := time.Now(); time.Since(start) < timeout; time.Sleep(2 * time.Second) { for start := time.Now(); time.Since(start) < timeout; time.Sleep(2 * time.Second) {
options := metav1.ListOptions{LabelSelector: label.String()} options := metav1.ListOptions{LabelSelector: label.String()}
pods, err := j.Client.CoreV1().Pods(namespace).List(options) pods, err := j.Client.CoreV1().Pods(j.Namespace).List(options)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -734,9 +736,9 @@ func (j *TestJig) waitForPodsCreated(namespace string, replicas int) ([]string,
return nil, fmt.Errorf("timeout waiting for %d pods to be created", replicas) return nil, fmt.Errorf("timeout waiting for %d pods to be created", replicas)
} }
func (j *TestJig) waitForPodsReady(namespace string, pods []string) error { func (j *TestJig) waitForPodsReady(pods []string) error {
timeout := 2 * time.Minute timeout := 2 * time.Minute
if !e2epod.CheckPodsRunningReady(j.Client, namespace, pods, timeout) { if !e2epod.CheckPodsRunningReady(j.Client, j.Namespace, pods, timeout) {
return fmt.Errorf("timeout waiting for %d pods to be ready", len(pods)) return fmt.Errorf("timeout waiting for %d pods to be ready", len(pods))
} }
return nil return nil
@ -822,11 +824,11 @@ func testEndpointReachability(endpoint string, port int32, protocol v1.Protocol,
// checkClusterIPServiceReachability ensures that service of type ClusterIP is reachable over // checkClusterIPServiceReachability ensures that service of type ClusterIP is reachable over
// - ServiceName:ServicePort, ClusterIP:ServicePort // - ServiceName:ServicePort, ClusterIP:ServicePort
func (j *TestJig) checkClusterIPServiceReachability(namespace string, svc *v1.Service, pod *v1.Pod) error { func (j *TestJig) checkClusterIPServiceReachability(svc *v1.Service, pod *v1.Pod) error {
clusterIP := svc.Spec.ClusterIP clusterIP := svc.Spec.ClusterIP
servicePorts := svc.Spec.Ports servicePorts := svc.Spec.Ports
err := j.WaitForAvailableEndpoint(namespace, svc.Name, ServiceEndpointsTimeout) err := j.WaitForAvailableEndpoint(ServiceEndpointsTimeout)
if err != nil { if err != nil {
return err return err
} }
@ -849,7 +851,7 @@ func (j *TestJig) checkClusterIPServiceReachability(namespace string, svc *v1.Se
// ServiceName:ServicePort, ClusterIP:ServicePort and NodeInternalIPs:NodePort // ServiceName:ServicePort, ClusterIP:ServicePort and NodeInternalIPs:NodePort
// - External clients should be reachable to service over - // - External clients should be reachable to service over -
// NodePublicIPs:NodePort // NodePublicIPs:NodePort
func (j *TestJig) checkNodePortServiceReachability(namespace string, svc *v1.Service, pod *v1.Pod) error { func (j *TestJig) checkNodePortServiceReachability(svc *v1.Service, pod *v1.Pod) error {
clusterIP := svc.Spec.ClusterIP clusterIP := svc.Spec.ClusterIP
servicePorts := svc.Spec.Ports servicePorts := svc.Spec.Ports
@ -859,7 +861,7 @@ func (j *TestJig) checkNodePortServiceReachability(namespace string, svc *v1.Ser
return err return err
} }
err = j.WaitForAvailableEndpoint(namespace, svc.Name, ServiceEndpointsTimeout) err = j.WaitForAvailableEndpoint(ServiceEndpointsTimeout)
if err != nil { if err != nil {
return err return err
} }
@ -895,7 +897,7 @@ func (j *TestJig) checkExternalServiceReachability(svc *v1.Service, pod *v1.Pod)
} }
// CheckServiceReachability ensures that request are served by the services. Only supports Services with type ClusterIP, NodePort and ExternalName. // CheckServiceReachability ensures that request are served by the services. Only supports Services with type ClusterIP, NodePort and ExternalName.
func (j *TestJig) CheckServiceReachability(namespace string, svc *v1.Service, pod *v1.Pod) error { func (j *TestJig) CheckServiceReachability(svc *v1.Service, pod *v1.Pod) error {
svcType := svc.Spec.Type svcType := svc.Spec.Type
_, err := j.sanityCheckService(svc, svcType) _, err := j.sanityCheckService(svc, svcType)
@ -905,9 +907,9 @@ func (j *TestJig) CheckServiceReachability(namespace string, svc *v1.Service, po
switch svcType { switch svcType {
case v1.ServiceTypeClusterIP: case v1.ServiceTypeClusterIP:
return j.checkClusterIPServiceReachability(namespace, svc, pod) return j.checkClusterIPServiceReachability(svc, pod)
case v1.ServiceTypeNodePort: case v1.ServiceTypeNodePort:
return j.checkNodePortServiceReachability(namespace, svc, pod) return j.checkNodePortServiceReachability(svc, pod)
case v1.ServiceTypeExternalName: case v1.ServiceTypeExternalName:
return j.checkExternalServiceReachability(svc, pod) return j.checkExternalServiceReachability(svc, pod)
default: default:
@ -916,13 +918,13 @@ func (j *TestJig) CheckServiceReachability(namespace string, svc *v1.Service, po
} }
// CreateServicePods creates a replication controller with the label same as service. Service listens to HTTP. // CreateServicePods creates a replication controller with the label same as service. Service listens to HTTP.
func (j *TestJig) CreateServicePods(c clientset.Interface, ns string, replica int) error { func (j *TestJig) CreateServicePods(replica int) error {
config := testutils.RCConfig{ config := testutils.RCConfig{
Client: c, Client: j.Client,
Name: j.Name, Name: j.Name,
Image: framework.ServeHostnameImage, Image: framework.ServeHostnameImage,
Command: []string{"/agnhost", "serve-hostname"}, Command: []string{"/agnhost", "serve-hostname"},
Namespace: ns, Namespace: j.Namespace,
Labels: j.Labels, Labels: j.Labels,
PollInterval: 3 * time.Second, PollInterval: 3 * time.Second,
Timeout: framework.PodReadyBeforeTimeout, Timeout: framework.PodReadyBeforeTimeout,
@ -932,13 +934,13 @@ func (j *TestJig) CreateServicePods(c clientset.Interface, ns string, replica in
} }
// CreateTCPUDPServicePods creates a replication controller with the label same as service. Service listens to TCP and UDP. // CreateTCPUDPServicePods creates a replication controller with the label same as service. Service listens to TCP and UDP.
func (j *TestJig) CreateTCPUDPServicePods(c clientset.Interface, ns string, replica int) error { func (j *TestJig) CreateTCPUDPServicePods(replica int) error {
config := testutils.RCConfig{ config := testutils.RCConfig{
Client: c, Client: j.Client,
Name: j.Name, Name: j.Name,
Image: framework.ServeHostnameImage, Image: framework.ServeHostnameImage,
Command: []string{"/agnhost", "serve-hostname", "--http=false", "--tcp", "--udp"}, Command: []string{"/agnhost", "serve-hostname", "--http=false", "--tcp", "--udp"},
Namespace: ns, Namespace: j.Namespace,
Labels: j.Labels, Labels: j.Labels,
PollInterval: 3 * time.Second, PollInterval: 3 * time.Second,
Timeout: framework.PodReadyBeforeTimeout, Timeout: framework.PodReadyBeforeTimeout,

15
test/e2e/network/dual_stack.go
View File

@ -210,7 +210,7 @@ var _ = SIGDescribe("[Feature:IPv6DualStackAlphaFeature] [LinuxOnly]", func() {
ginkgo.It("should create service with cluster ip from primary service range [Feature:IPv6DualStackAlphaFeature:Phase2]", func() { ginkgo.It("should create service with cluster ip from primary service range [Feature:IPv6DualStackAlphaFeature:Phase2]", func() {
serviceName := "defaultclusterip" serviceName := "defaultclusterip"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
defaultIPFamily := v1.IPv4Protocol defaultIPFamily := v1.IPv4Protocol
if framework.TestContext.ClusterIsIPv6() { if framework.TestContext.ClusterIsIPv6() {
@ -229,7 +229,8 @@ var _ = SIGDescribe("[Feature:IPv6DualStackAlphaFeature] [LinuxOnly]", func() {
service := createService(t.ServiceName, t.Namespace, t.Labels, nil) service := createService(t.ServiceName, t.Namespace, t.Labels, nil)
jig.Labels = t.Labels jig.Labels = t.Labels
jig.CreateServicePods(cs, ns, 2) err := jig.CreateServicePods(2)
framework.ExpectNoError(err)
svc, err := t.CreateService(service) svc, err := t.CreateService(service)
framework.ExpectNoError(err, "failed to create service: %s in namespace: %s", serviceName, ns) framework.ExpectNoError(err, "failed to create service: %s in namespace: %s", serviceName, ns)
@ -251,7 +252,7 @@ var _ = SIGDescribe("[Feature:IPv6DualStackAlphaFeature] [LinuxOnly]", func() {
ns := f.Namespace.Name ns := f.Namespace.Name
ipv4 := v1.IPv4Protocol ipv4 := v1.IPv4Protocol
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
t := e2eservice.NewServerTest(cs, ns, serviceName) t := e2eservice.NewServerTest(cs, ns, serviceName)
defer func() { defer func() {
@ -265,7 +266,8 @@ var _ = SIGDescribe("[Feature:IPv6DualStackAlphaFeature] [LinuxOnly]", func() {
service := createService(t.ServiceName, t.Namespace, t.Labels, &ipv4) service := createService(t.ServiceName, t.Namespace, t.Labels, &ipv4)
jig.Labels = t.Labels jig.Labels = t.Labels
jig.CreateServicePods(cs, ns, 2) err := jig.CreateServicePods(2)
framework.ExpectNoError(err)
svc, err := t.CreateService(service) svc, err := t.CreateService(service)
framework.ExpectNoError(err, "failed to create service: %s in namespace: %s", serviceName, ns) framework.ExpectNoError(err, "failed to create service: %s in namespace: %s", serviceName, ns)
@ -287,7 +289,7 @@ var _ = SIGDescribe("[Feature:IPv6DualStackAlphaFeature] [LinuxOnly]", func() {
ns := f.Namespace.Name ns := f.Namespace.Name
ipv6 := v1.IPv6Protocol ipv6 := v1.IPv6Protocol
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
t := e2eservice.NewServerTest(cs, ns, serviceName) t := e2eservice.NewServerTest(cs, ns, serviceName)
defer func() { defer func() {
@ -301,7 +303,8 @@ var _ = SIGDescribe("[Feature:IPv6DualStackAlphaFeature] [LinuxOnly]", func() {
service := createService(t.ServiceName, t.Namespace, t.Labels, &ipv6) service := createService(t.ServiceName, t.Namespace, t.Labels, &ipv6)
jig.Labels = t.Labels jig.Labels = t.Labels
jig.CreateServicePods(cs, ns, 2) err := jig.CreateServicePods(2)
framework.ExpectNoError(err)
svc, err := t.CreateService(service) svc, err := t.CreateService(service)
framework.ExpectNoError(err, "failed to create service: %s in namespace: %s", serviceName, ns) framework.ExpectNoError(err, "failed to create service: %s in namespace: %s", serviceName, ns)

8
test/e2e/network/firewall.go
View File

@ -71,7 +71,7 @@ var _ = SIGDescribe("Firewall rule", func() {
framework.ExpectNoError(err) framework.ExpectNoError(err)
framework.Logf("Got cluster ID: %v", clusterID) framework.Logf("Got cluster ID: %v", clusterID)
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
nodeList, err := e2enode.GetBoundedReadySchedulableNodes(cs, e2eservice.MaxNodesForEndpointsTests) nodeList, err := e2enode.GetBoundedReadySchedulableNodes(cs, e2eservice.MaxNodesForEndpointsTests)
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -82,13 +82,13 @@ var _ = SIGDescribe("Firewall rule", func() {
nodesSet := sets.NewString(nodesNames...) nodesSet := sets.NewString(nodesNames...)
ginkgo.By("Creating a LoadBalancer type service with ExternalTrafficPolicy=Global") ginkgo.By("Creating a LoadBalancer type service with ExternalTrafficPolicy=Global")
svc, err := jig.CreateLoadBalancerService(ns, serviceName, e2eservice.LoadBalancerCreateTimeoutDefault, func(svc *v1.Service) { svc, err := jig.CreateLoadBalancerService(e2eservice.LoadBalancerCreateTimeoutDefault, func(svc *v1.Service) {
svc.Spec.Ports = []v1.ServicePort{{Protocol: v1.ProtocolTCP, Port: firewallTestHTTPPort}} svc.Spec.Ports = []v1.ServicePort{{Protocol: v1.ProtocolTCP, Port: firewallTestHTTPPort}}
svc.Spec.LoadBalancerSourceRanges = firewallTestSourceRanges svc.Spec.LoadBalancerSourceRanges = firewallTestSourceRanges
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
defer func() { defer func() {
_, err = jig.UpdateService(svc.Namespace, svc.Name, func(svc *v1.Service) { _, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeNodePort svc.Spec.Type = v1.ServiceTypeNodePort
svc.Spec.LoadBalancerSourceRanges = nil svc.Spec.LoadBalancerSourceRanges = nil
}) })
@ -118,7 +118,7 @@ var _ = SIGDescribe("Firewall rule", func() {
// OnlyLocal service is needed to examine which exact nodes the requests are being forwarded to by the Load Balancer on GCE // OnlyLocal service is needed to examine which exact nodes the requests are being forwarded to by the Load Balancer on GCE
ginkgo.By("Updating LoadBalancer service to ExternalTrafficPolicy=Local") ginkgo.By("Updating LoadBalancer service to ExternalTrafficPolicy=Local")
svc, err = jig.UpdateService(svc.Namespace, svc.Name, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)

20
test/e2e/network/network_tiers.go
View File

@ -65,15 +65,15 @@ var _ = SIGDescribe("Services [Feature:GCEAlphaFeature][Slow]", func() {
svcName := "net-tiers-svc" svcName := "net-tiers-svc"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, svcName) jig := e2eservice.NewTestJig(cs, ns, svcName)
ginkgo.By("creating a pod to be part of the service " + svcName) ginkgo.By("creating a pod to be part of the service " + svcName)
_, err := jig.Run(ns, nil) _, err := jig.Run(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
// Test 1: create a standard tiered LB for the Service. // Test 1: create a standard tiered LB for the Service.
ginkgo.By("creating a Service of type LoadBalancer using the standard network tier") ginkgo.By("creating a Service of type LoadBalancer using the standard network tier")
svc, err := jig.CreateTCPService(ns, func(svc *v1.Service) { svc, err := jig.CreateTCPService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.Type = v1.ServiceTypeLoadBalancer
setNetworkTier(svc, string(gcecloud.NetworkTierAnnotationStandard)) setNetworkTier(svc, string(gcecloud.NetworkTierAnnotationStandard))
}) })
@ -86,11 +86,11 @@ var _ = SIGDescribe("Services [Feature:GCEAlphaFeature][Slow]", func() {
serviceLBNames = append(serviceLBNames, cloudprovider.DefaultLoadBalancerName(svc)) serviceLBNames = append(serviceLBNames, cloudprovider.DefaultLoadBalancerName(svc))
// Wait and verify the LB. // Wait and verify the LB.
ingressIP := waitAndVerifyLBWithTier(jig, ns, svcName, "", createTimeout, lagTimeout) ingressIP := waitAndVerifyLBWithTier(jig, "", createTimeout, lagTimeout)
// Test 2: re-create a LB of a different tier for the updated Service. // Test 2: re-create a LB of a different tier for the updated Service.
ginkgo.By("updating the Service to use the premium (default) tier") ginkgo.By("updating the Service to use the premium (default) tier")
svc, err = jig.UpdateService(ns, svcName, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
clearNetworkTier(svc) clearNetworkTier(svc)
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -101,7 +101,7 @@ var _ = SIGDescribe("Services [Feature:GCEAlphaFeature][Slow]", func() {
// Wait until the ingress IP changes. Each tier has its own pool of // Wait until the ingress IP changes. Each tier has its own pool of
// IPs, so changing tiers implies changing IPs. // IPs, so changing tiers implies changing IPs.
ingressIP = waitAndVerifyLBWithTier(jig, ns, svcName, ingressIP, createTimeout, lagTimeout) ingressIP = waitAndVerifyLBWithTier(jig, ingressIP, createTimeout, lagTimeout)
// Test 3: create a standard-tierd LB with a user-requested IP. // Test 3: create a standard-tierd LB with a user-requested IP.
ginkgo.By("reserving a static IP for the load balancer") ginkgo.By("reserving a static IP for the load balancer")
@ -122,7 +122,7 @@ var _ = SIGDescribe("Services [Feature:GCEAlphaFeature][Slow]", func() {
framework.Logf("Allocated static IP to be used by the load balancer: %q", requestedIP) framework.Logf("Allocated static IP to be used by the load balancer: %q", requestedIP)
ginkgo.By("updating the Service to use the standard tier with a requested IP") ginkgo.By("updating the Service to use the standard tier with a requested IP")
svc, err = jig.UpdateService(ns, svc.Name, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.LoadBalancerIP = requestedIP svc.Spec.LoadBalancerIP = requestedIP
setNetworkTier(svc, string(gcecloud.NetworkTierAnnotationStandard)) setNetworkTier(svc, string(gcecloud.NetworkTierAnnotationStandard))
}) })
@ -134,14 +134,14 @@ var _ = SIGDescribe("Services [Feature:GCEAlphaFeature][Slow]", func() {
framework.ExpectEqual(svcTier, cloud.NetworkTierStandard) framework.ExpectEqual(svcTier, cloud.NetworkTierStandard)
// Wait until the ingress IP changes and verifies the LB. // Wait until the ingress IP changes and verifies the LB.
ingressIP = waitAndVerifyLBWithTier(jig, ns, svcName, ingressIP, createTimeout, lagTimeout) ingressIP = waitAndVerifyLBWithTier(jig, ingressIP, createTimeout, lagTimeout)
}) })
}) })
func waitAndVerifyLBWithTier(jig *e2eservice.TestJig, ns, svcName, existingIP string, waitTimeout, checkTimeout time.Duration) string { func waitAndVerifyLBWithTier(jig *e2eservice.TestJig, existingIP string, waitTimeout, checkTimeout time.Duration) string {
// If existingIP is "" this will wait for any ingress IP to show up. Otherwise // If existingIP is "" this will wait for any ingress IP to show up. Otherwise
// it will wait for the ingress IP to change to something different. // it will wait for the ingress IP to change to something different.
svc, err := jig.WaitForNewIngressIP(ns, svcName, existingIP, waitTimeout) svc, err := jig.WaitForNewIngressIP(existingIP, waitTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
svcPort := int(svc.Spec.Ports[0].Port) svcPort := int(svc.Spec.Ports[0].Port)

249
test/e2e/network/service.go
View File

@ -124,14 +124,14 @@ var _ = SIGDescribe("Services", func() {
framework.ConformanceIt("should serve a basic endpoint from pods ", func() { framework.ConformanceIt("should serve a basic endpoint from pods ", func() {
serviceName := "endpoint-test2" serviceName := "endpoint-test2"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
ginkgo.By("creating service " + serviceName + " in namespace " + ns) ginkgo.By("creating service " + serviceName + " in namespace " + ns)
defer func() { defer func() {
err := cs.CoreV1().Services(ns).Delete(serviceName, nil) err := cs.CoreV1().Services(ns).Delete(serviceName, nil)
framework.ExpectNoError(err, "failed to delete service: %s in namespace: %s", serviceName, ns) framework.ExpectNoError(err, "failed to delete service: %s in namespace: %s", serviceName, ns)
}() }()
_, err := jig.CreateTCPServiceWithPort(ns, nil, 80) _, err := jig.CreateTCPServiceWithPort(nil, 80)
framework.ExpectNoError(err) framework.ExpectNoError(err)
err = e2eendpoints.ValidateEndpointsPorts(cs, ns, serviceName, e2eendpoints.PortsByPodName{}) err = e2eendpoints.ValidateEndpointsPorts(cs, ns, serviceName, e2eendpoints.PortsByPodName{})
@ -178,7 +178,7 @@ var _ = SIGDescribe("Services", func() {
// repacking functionality is intentionally not tested here - it's better to test it in an integration test. // repacking functionality is intentionally not tested here - it's better to test it in an integration test.
serviceName := "multi-endpoint-test" serviceName := "multi-endpoint-test"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
defer func() { defer func() {
err := cs.CoreV1().Services(ns).Delete(serviceName, nil) err := cs.CoreV1().Services(ns).Delete(serviceName, nil)
@ -189,7 +189,7 @@ var _ = SIGDescribe("Services", func() {
svc2port := "svc2" svc2port := "svc2"
ginkgo.By("creating service " + serviceName + " in namespace " + ns) ginkgo.By("creating service " + serviceName + " in namespace " + ns)
_, err := jig.CreateTCPService(ns, func(service *v1.Service) { _, err := jig.CreateTCPService(func(service *v1.Service) {
service.Spec.Ports = []v1.ServicePort{ service.Spec.Ports = []v1.ServicePort{
{ {
Name: "portname1", Name: "portname1",
@ -273,9 +273,9 @@ var _ = SIGDescribe("Services", func() {
ns := f.Namespace.Name ns := f.Namespace.Name
ginkgo.By("creating a TCP service " + serviceName + " with type=ClusterIP in namespace " + ns) ginkgo.By("creating a TCP service " + serviceName + " with type=ClusterIP in namespace " + ns)
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
servicePort := 8080 servicePort := 8080
tcpService, err := jig.CreateTCPServiceWithPort(ns, nil, int32(servicePort)) tcpService, err := jig.CreateTCPServiceWithPort(nil, int32(servicePort))
framework.ExpectNoError(err) framework.ExpectNoError(err)
defer func() { defer func() {
framework.Logf("Cleaning up the sourceip test service") framework.Logf("Cleaning up the sourceip test service")
@ -344,9 +344,9 @@ var _ = SIGDescribe("Services", func() {
ns := f.Namespace.Name ns := f.Namespace.Name
ginkgo.By("creating a TCP service " + serviceName + " with type=ClusterIP in namespace " + ns) ginkgo.By("creating a TCP service " + serviceName + " with type=ClusterIP in namespace " + ns)
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
servicePort := 8080 servicePort := 8080
svc, err := jig.CreateTCPServiceWithPort(ns, nil, int32(servicePort)) svc, err := jig.CreateTCPServiceWithPort(nil, int32(servicePort))
framework.ExpectNoError(err) framework.ExpectNoError(err)
serviceIP := svc.Spec.ClusterIP serviceIP := svc.Spec.ClusterIP
framework.Logf("hairpin-test cluster ip: %s", serviceIP) framework.Logf("hairpin-test cluster ip: %s", serviceIP)
@ -364,7 +364,7 @@ var _ = SIGDescribe("Services", func() {
framework.ExpectNoError(err, "failed to validate endpoints for service %s in namespace: %s", serviceName, ns) framework.ExpectNoError(err, "failed to validate endpoints for service %s in namespace: %s", serviceName, ns)
ginkgo.By("Checking if the pod can reach itself") ginkgo.By("Checking if the pod can reach itself")
err = jig.CheckServiceReachability(ns, svc, pod) err = jig.CheckServiceReachability(svc, pod)
framework.ExpectNoError(err) framework.ExpectNoError(err)
}) })
@ -534,20 +534,20 @@ var _ = SIGDescribe("Services", func() {
serviceName := "nodeport-test" serviceName := "nodeport-test"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
ginkgo.By("creating service " + serviceName + " with type=NodePort in namespace " + ns) ginkgo.By("creating service " + serviceName + " with type=NodePort in namespace " + ns)
nodePortService, err := jig.CreateTCPService(ns, func(svc *v1.Service) { nodePortService, err := jig.CreateTCPService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeNodePort svc.Spec.Type = v1.ServiceTypeNodePort
svc.Spec.Ports = []v1.ServicePort{ svc.Spec.Ports = []v1.ServicePort{
{Port: 80, Name: "http", Protocol: v1.ProtocolTCP, TargetPort: intstr.FromInt(9376)}, {Port: 80, Name: "http", Protocol: v1.ProtocolTCP, TargetPort: intstr.FromInt(9376)},
} }
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
err = jig.CreateServicePods(cs, ns, 2) err = jig.CreateServicePods(2)
framework.ExpectNoError(err) framework.ExpectNoError(err)
execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil) execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil)
err = jig.CheckServiceReachability(ns, nodePortService, execPod) err = jig.CheckServiceReachability(nodePortService, execPod)
framework.ExpectNoError(err) framework.ExpectNoError(err)
}) })
@ -582,23 +582,20 @@ var _ = SIGDescribe("Services", func() {
ns2 := namespacePtr.Name // LB2 in ns2 on UDP ns2 := namespacePtr.Name // LB2 in ns2 on UDP
framework.Logf("namespace for UDP test: %s", ns2) framework.Logf("namespace for UDP test: %s", ns2)
jig := e2eservice.NewTestJig(cs, serviceName) nodeIP, err := e2enode.PickIP(cs) // for later
nodeIP, err := e2enode.PickIP(jig.Client) // for later framework.ExpectNoError(err)
if err != nil {
framework.Logf("Unexpected error occurred: %v", err)
}
// TODO: write a wrapper for ExpectNoErrorWithOffset()
framework.ExpectNoErrorWithOffset(0, err)
// Test TCP and UDP Services. Services with the same name in different // Test TCP and UDP Services. Services with the same name in different
// namespaces should get different node ports and load balancers. // namespaces should get different node ports and load balancers.
ginkgo.By("creating a TCP service " + serviceName + " with type=ClusterIP in namespace " + ns1) ginkgo.By("creating a TCP service " + serviceName + " with type=ClusterIP in namespace " + ns1)
tcpService, err := jig.CreateTCPService(ns1, nil) tcpJig := e2eservice.NewTestJig(cs, ns1, serviceName)
tcpService, err := tcpJig.CreateTCPService(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
ginkgo.By("creating a UDP service " + serviceName + " with type=ClusterIP in namespace " + ns2) ginkgo.By("creating a UDP service " + serviceName + " with type=ClusterIP in namespace " + ns2)
udpService, err := jig.CreateUDPService(ns2, nil) udpJig := e2eservice.NewTestJig(cs, ns2, serviceName)
udpService, err := udpJig.CreateUDPService(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
ginkgo.By("verifying that TCP and UDP use the same port") ginkgo.By("verifying that TCP and UDP use the same port")
@ -609,17 +606,17 @@ var _ = SIGDescribe("Services", func() {
framework.Logf("service port (TCP and UDP): %d", svcPort) framework.Logf("service port (TCP and UDP): %d", svcPort)
ginkgo.By("creating a pod to be part of the TCP service " + serviceName) ginkgo.By("creating a pod to be part of the TCP service " + serviceName)
_, err = jig.Run(ns1, nil) _, err = tcpJig.Run(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
ginkgo.By("creating a pod to be part of the UDP service " + serviceName) ginkgo.By("creating a pod to be part of the UDP service " + serviceName)
_, err = jig.Run(ns2, nil) _, err = udpJig.Run(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
// Change the services to NodePort. // Change the services to NodePort.
ginkgo.By("changing the TCP service to type=NodePort") ginkgo.By("changing the TCP service to type=NodePort")
tcpService, err = jig.UpdateService(ns1, tcpService.Name, func(s *v1.Service) { tcpService, err = tcpJig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeNodePort s.Spec.Type = v1.ServiceTypeNodePort
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -627,7 +624,7 @@ var _ = SIGDescribe("Services", func() {
framework.Logf("TCP node port: %d", tcpNodePort) framework.Logf("TCP node port: %d", tcpNodePort)
ginkgo.By("changing the UDP service to type=NodePort") ginkgo.By("changing the UDP service to type=NodePort")
udpService, err = jig.UpdateService(ns2, udpService.Name, func(s *v1.Service) { udpService, err = udpJig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeNodePort s.Spec.Type = v1.ServiceTypeNodePort
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -670,7 +667,7 @@ var _ = SIGDescribe("Services", func() {
} }
ginkgo.By("changing the TCP service to type=LoadBalancer") ginkgo.By("changing the TCP service to type=LoadBalancer")
tcpService, err = jig.UpdateService(ns1, tcpService.Name, func(s *v1.Service) { tcpService, err = tcpJig.UpdateService(func(s *v1.Service) {
s.Spec.LoadBalancerIP = requestedIP // will be "" if not applicable s.Spec.LoadBalancerIP = requestedIP // will be "" if not applicable
s.Spec.Type = v1.ServiceTypeLoadBalancer s.Spec.Type = v1.ServiceTypeLoadBalancer
}) })
@ -678,7 +675,7 @@ var _ = SIGDescribe("Services", func() {
if loadBalancerSupportsUDP { if loadBalancerSupportsUDP {
ginkgo.By("changing the UDP service to type=LoadBalancer") ginkgo.By("changing the UDP service to type=LoadBalancer")
udpService, err = jig.UpdateService(ns2, udpService.Name, func(s *v1.Service) { udpService, err = udpJig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeLoadBalancer s.Spec.Type = v1.ServiceTypeLoadBalancer
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -690,7 +687,7 @@ var _ = SIGDescribe("Services", func() {
ginkgo.By("waiting for the TCP service to have a load balancer") ginkgo.By("waiting for the TCP service to have a load balancer")
// Wait for the load balancer to be created asynchronously // Wait for the load balancer to be created asynchronously
tcpService, err = jig.WaitForLoadBalancer(ns1, tcpService.Name, loadBalancerCreateTimeout) tcpService, err = tcpJig.WaitForLoadBalancer(loadBalancerCreateTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
if int(tcpService.Spec.Ports[0].NodePort) != tcpNodePort { if int(tcpService.Spec.Ports[0].NodePort) != tcpNodePort {
framework.Failf("TCP Spec.Ports[0].NodePort changed (%d -> %d) when not expected", tcpNodePort, tcpService.Spec.Ports[0].NodePort) framework.Failf("TCP Spec.Ports[0].NodePort changed (%d -> %d) when not expected", tcpNodePort, tcpService.Spec.Ports[0].NodePort)
@ -723,7 +720,7 @@ var _ = SIGDescribe("Services", func() {
if loadBalancerSupportsUDP { if loadBalancerSupportsUDP {
ginkgo.By("waiting for the UDP service to have a load balancer") ginkgo.By("waiting for the UDP service to have a load balancer")
// 2nd one should be faster since they ran in parallel. // 2nd one should be faster since they ran in parallel.
udpService, err = jig.WaitForLoadBalancer(ns2, udpService.Name, loadBalancerCreateTimeout) udpService, err = udpJig.WaitForLoadBalancer(loadBalancerCreateTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
if int(udpService.Spec.Ports[0].NodePort) != udpNodePort { if int(udpService.Spec.Ports[0].NodePort) != udpNodePort {
framework.Failf("UDP Spec.Ports[0].NodePort changed (%d -> %d) when not expected", udpNodePort, udpService.Spec.Ports[0].NodePort) framework.Failf("UDP Spec.Ports[0].NodePort changed (%d -> %d) when not expected", udpNodePort, udpService.Spec.Ports[0].NodePort)
@ -754,7 +751,7 @@ var _ = SIGDescribe("Services", func() {
// Change the services' node ports. // Change the services' node ports.
ginkgo.By("changing the TCP service's NodePort") ginkgo.By("changing the TCP service's NodePort")
tcpService, err = jig.ChangeServiceNodePort(ns1, tcpService.Name, tcpNodePort) tcpService, err = tcpJig.ChangeServiceNodePort(tcpNodePort)
framework.ExpectNoError(err) framework.ExpectNoError(err)
tcpNodePortOld := tcpNodePort tcpNodePortOld := tcpNodePort
tcpNodePort = int(tcpService.Spec.Ports[0].NodePort) tcpNodePort = int(tcpService.Spec.Ports[0].NodePort)
@ -767,7 +764,7 @@ var _ = SIGDescribe("Services", func() {
framework.Logf("TCP node port: %d", tcpNodePort) framework.Logf("TCP node port: %d", tcpNodePort)
ginkgo.By("changing the UDP service's NodePort") ginkgo.By("changing the UDP service's NodePort")
udpService, err = jig.ChangeServiceNodePort(ns2, udpService.Name, udpNodePort) udpService, err = udpJig.ChangeServiceNodePort(udpNodePort)
framework.ExpectNoError(err) framework.ExpectNoError(err)
udpNodePortOld := udpNodePort udpNodePortOld := udpNodePort
udpNodePort = int(udpService.Spec.Ports[0].NodePort) udpNodePort = int(udpService.Spec.Ports[0].NodePort)
@ -802,7 +799,7 @@ var _ = SIGDescribe("Services", func() {
// Change the services' main ports. // Change the services' main ports.
ginkgo.By("changing the TCP service's port") ginkgo.By("changing the TCP service's port")
tcpService, err = jig.UpdateService(ns1, tcpService.Name, func(s *v1.Service) { tcpService, err = tcpJig.UpdateService(func(s *v1.Service) {
s.Spec.Ports[0].Port++ s.Spec.Ports[0].Port++
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -819,7 +816,7 @@ var _ = SIGDescribe("Services", func() {
} }
ginkgo.By("changing the UDP service's port") ginkgo.By("changing the UDP service's port")
udpService, err = jig.UpdateService(ns2, udpService.Name, func(s *v1.Service) { udpService, err = udpJig.UpdateService(func(s *v1.Service) {
s.Spec.Ports[0].Port++ s.Spec.Ports[0].Port++
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -850,9 +847,9 @@ var _ = SIGDescribe("Services", func() {
} }
ginkgo.By("Scaling the pods to 0") ginkgo.By("Scaling the pods to 0")
err = jig.Scale(ns1, 0) err = tcpJig.Scale(0)
framework.ExpectNoError(err) framework.ExpectNoError(err)
err = jig.Scale(ns2, 0) err = udpJig.Scale(0)
framework.ExpectNoError(err) framework.ExpectNoError(err)
ginkgo.By("looking for ICMP REJECT on the TCP service's NodePort") ginkgo.By("looking for ICMP REJECT on the TCP service's NodePort")
@ -870,9 +867,9 @@ var _ = SIGDescribe("Services", func() {
} }
ginkgo.By("Scaling the pods to 1") ginkgo.By("Scaling the pods to 1")
err = jig.Scale(ns1, 1) err = tcpJig.Scale(1)
framework.ExpectNoError(err) framework.ExpectNoError(err)
err = jig.Scale(ns2, 1) err = udpJig.Scale(1)
framework.ExpectNoError(err) framework.ExpectNoError(err)
ginkgo.By("hitting the TCP service's NodePort") ginkgo.By("hitting the TCP service's NodePort")
@ -892,24 +889,24 @@ var _ = SIGDescribe("Services", func() {
// Change the services back to ClusterIP. // Change the services back to ClusterIP.
ginkgo.By("changing TCP service back to type=ClusterIP") ginkgo.By("changing TCP service back to type=ClusterIP")
tcpService, err = jig.UpdateService(ns1, tcpService.Name, func(s *v1.Service) { tcpService, err = tcpJig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeClusterIP s.Spec.Type = v1.ServiceTypeClusterIP
s.Spec.Ports[0].NodePort = 0 s.Spec.Ports[0].NodePort = 0
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
// Wait for the load balancer to be destroyed asynchronously // Wait for the load balancer to be destroyed asynchronously
tcpService, err = jig.WaitForLoadBalancerDestroy(ns1, tcpService.Name, tcpIngressIP, svcPort, loadBalancerCreateTimeout) tcpService, err = tcpJig.WaitForLoadBalancerDestroy(tcpIngressIP, svcPort, loadBalancerCreateTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
ginkgo.By("changing UDP service back to type=ClusterIP") ginkgo.By("changing UDP service back to type=ClusterIP")
udpService, err = jig.UpdateService(ns2, udpService.Name, func(s *v1.Service) { udpService, err = udpJig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeClusterIP s.Spec.Type = v1.ServiceTypeClusterIP
s.Spec.Ports[0].NodePort = 0 s.Spec.Ports[0].NodePort = 0
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
if loadBalancerSupportsUDP { if loadBalancerSupportsUDP {
// Wait for the load balancer to be destroyed asynchronously // Wait for the load balancer to be destroyed asynchronously
udpService, err = jig.WaitForLoadBalancerDestroy(ns2, udpService.Name, udpIngressIP, svcPort, loadBalancerCreateTimeout) udpService, err = udpJig.WaitForLoadBalancerDestroy(udpIngressIP, svcPort, loadBalancerCreateTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
} }
@ -938,10 +935,10 @@ var _ = SIGDescribe("Services", func() {
ginkgo.It("should be able to update service type to NodePort listening on same port number but different protocols", func() { ginkgo.It("should be able to update service type to NodePort listening on same port number but different protocols", func() {
serviceName := "nodeport-update-service" serviceName := "nodeport-update-service"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
ginkgo.By("creating a TCP service " + serviceName + " with type=ClusterIP in namespace " + ns) ginkgo.By("creating a TCP service " + serviceName + " with type=ClusterIP in namespace " + ns)
tcpService, err := jig.CreateTCPService(ns, nil) tcpService, err := jig.CreateTCPService(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
defer func() { defer func() {
framework.Logf("Cleaning up the updating NodePorts test service") framework.Logf("Cleaning up the updating NodePorts test service")
@ -951,7 +948,7 @@ var _ = SIGDescribe("Services", func() {
framework.Logf("Service Port TCP: %v", tcpService.Spec.Ports[0].Port) framework.Logf("Service Port TCP: %v", tcpService.Spec.Ports[0].Port)
ginkgo.By("changing the TCP service to type=NodePort") ginkgo.By("changing the TCP service to type=NodePort")
nodePortService, err := jig.UpdateService(ns, tcpService.Name, func(s *v1.Service) { nodePortService, err := jig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeNodePort s.Spec.Type = v1.ServiceTypeNodePort
s.Spec.Ports = []v1.ServicePort{ s.Spec.Ports = []v1.ServicePort{
{ {
@ -964,14 +961,14 @@ var _ = SIGDescribe("Services", func() {
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
err = jig.CreateTCPUDPServicePods(cs, ns, 2) err = jig.CreateTCPUDPServicePods(2)
framework.ExpectNoError(err) framework.ExpectNoError(err)
execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil) execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil)
err = jig.CheckServiceReachability(ns, nodePortService, execPod) err = jig.CheckServiceReachability(nodePortService, execPod)
framework.ExpectNoError(err) framework.ExpectNoError(err)
ginkgo.By("Updating NodePort service to listen TCP and UDP based requests over same Port") ginkgo.By("Updating NodePort service to listen TCP and UDP based requests over same Port")
nodePortService, err = jig.UpdateService(ns, tcpService.Name, func(s *v1.Service) { nodePortService, err = jig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeNodePort s.Spec.Type = v1.ServiceTypeNodePort
s.Spec.Ports = []v1.ServicePort{ s.Spec.Ports = []v1.ServicePort{
{ {
@ -989,7 +986,7 @@ var _ = SIGDescribe("Services", func() {
} }
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
err = jig.CheckServiceReachability(ns, nodePortService, execPod) err = jig.CheckServiceReachability(nodePortService, execPod)
framework.ExpectNoError(err) framework.ExpectNoError(err)
nodePortCounts := len(nodePortService.Spec.Ports) nodePortCounts := len(nodePortService.Spec.Ports)
framework.ExpectEqual(nodePortCounts, 2, "updated service should have two Ports but found %d Ports", nodePortCounts) framework.ExpectEqual(nodePortCounts, 2, "updated service should have two Ports but found %d Ports", nodePortCounts)
@ -1010,10 +1007,10 @@ var _ = SIGDescribe("Services", func() {
framework.ConformanceIt("should be able to change the type from ExternalName to ClusterIP", func() { framework.ConformanceIt("should be able to change the type from ExternalName to ClusterIP", func() {
serviceName := "externalname-service" serviceName := "externalname-service"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
ginkgo.By("creating a service " + serviceName + " with the type=ExternalName in namespace " + ns) ginkgo.By("creating a service " + serviceName + " with the type=ExternalName in namespace " + ns)
externalNameService, err := jig.CreateExternalNameService(ns, nil) _, err := jig.CreateExternalNameService(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
defer func() { defer func() {
framework.Logf("Cleaning up the ExternalName to ClusterIP test service") framework.Logf("Cleaning up the ExternalName to ClusterIP test service")
@ -1022,7 +1019,7 @@ var _ = SIGDescribe("Services", func() {
}() }()
ginkgo.By("changing the ExternalName service to type=ClusterIP") ginkgo.By("changing the ExternalName service to type=ClusterIP")
clusterIPService, err := jig.UpdateService(ns, externalNameService.Name, func(s *v1.Service) { clusterIPService, err := jig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeClusterIP s.Spec.Type = v1.ServiceTypeClusterIP
s.Spec.ExternalName = "" s.Spec.ExternalName = ""
s.Spec.Ports = []v1.ServicePort{ s.Spec.Ports = []v1.ServicePort{
@ -1031,10 +1028,10 @@ var _ = SIGDescribe("Services", func() {
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
err = jig.CreateServicePods(cs, ns, 2) err = jig.CreateServicePods(2)
framework.ExpectNoError(err) framework.ExpectNoError(err)
execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil) execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil)
err = jig.CheckServiceReachability(ns, clusterIPService, execPod) err = jig.CheckServiceReachability(clusterIPService, execPod)
framework.ExpectNoError(err) framework.ExpectNoError(err)
}) })
@ -1049,10 +1046,10 @@ var _ = SIGDescribe("Services", func() {
framework.ConformanceIt("should be able to change the type from ExternalName to NodePort", func() { framework.ConformanceIt("should be able to change the type from ExternalName to NodePort", func() {
serviceName := "externalname-service" serviceName := "externalname-service"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
ginkgo.By("creating a service " + serviceName + " with the type=ExternalName in namespace " + ns) ginkgo.By("creating a service " + serviceName + " with the type=ExternalName in namespace " + ns)
externalNameService, err := jig.CreateExternalNameService(ns, nil) _, err := jig.CreateExternalNameService(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
defer func() { defer func() {
framework.Logf("Cleaning up the ExternalName to NodePort test service") framework.Logf("Cleaning up the ExternalName to NodePort test service")
@ -1061,7 +1058,7 @@ var _ = SIGDescribe("Services", func() {
}() }()
ginkgo.By("changing the ExternalName service to type=NodePort") ginkgo.By("changing the ExternalName service to type=NodePort")
nodePortService, err := jig.UpdateService(ns, externalNameService.Name, func(s *v1.Service) { nodePortService, err := jig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeNodePort s.Spec.Type = v1.ServiceTypeNodePort
s.Spec.ExternalName = "" s.Spec.ExternalName = ""
s.Spec.Ports = []v1.ServicePort{ s.Spec.Ports = []v1.ServicePort{
@ -1069,11 +1066,11 @@ var _ = SIGDescribe("Services", func() {
} }
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
err = jig.CreateServicePods(cs, ns, 2) err = jig.CreateServicePods(2)
framework.ExpectNoError(err) framework.ExpectNoError(err)
execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil) execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil)
err = jig.CheckServiceReachability(ns, nodePortService, execPod) err = jig.CheckServiceReachability(nodePortService, execPod)
framework.ExpectNoError(err) framework.ExpectNoError(err)
}) })
@ -1087,10 +1084,10 @@ var _ = SIGDescribe("Services", func() {
framework.ConformanceIt("should be able to change the type from ClusterIP to ExternalName", func() { framework.ConformanceIt("should be able to change the type from ClusterIP to ExternalName", func() {
serviceName := "clusterip-service" serviceName := "clusterip-service"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
ginkgo.By("creating a service " + serviceName + " with the type=ClusterIP in namespace " + ns) ginkgo.By("creating a service " + serviceName + " with the type=ClusterIP in namespace " + ns)
clusterIPService, err := jig.CreateTCPService(ns, nil) _, err := jig.CreateTCPService(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
defer func() { defer func() {
framework.Logf("Cleaning up the ClusterIP to ExternalName test service") framework.Logf("Cleaning up the ClusterIP to ExternalName test service")
@ -1106,14 +1103,14 @@ var _ = SIGDescribe("Services", func() {
}() }()
ginkgo.By("changing the ClusterIP service to type=ExternalName") ginkgo.By("changing the ClusterIP service to type=ExternalName")
externalNameService, err := jig.UpdateService(ns, clusterIPService.Name, func(s *v1.Service) { externalNameService, err := jig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeExternalName s.Spec.Type = v1.ServiceTypeExternalName
s.Spec.ExternalName = externalServiceFQDN s.Spec.ExternalName = externalServiceFQDN
s.Spec.ClusterIP = "" s.Spec.ClusterIP = ""
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil) execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil)
err = jig.CheckServiceReachability(ns, externalNameService, execPod) err = jig.CheckServiceReachability(externalNameService, execPod)
framework.ExpectNoError(err) framework.ExpectNoError(err)
}) })
@ -1127,10 +1124,10 @@ var _ = SIGDescribe("Services", func() {
framework.ConformanceIt("should be able to change the type from NodePort to ExternalName", func() { framework.ConformanceIt("should be able to change the type from NodePort to ExternalName", func() {
serviceName := "nodeport-service" serviceName := "nodeport-service"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
ginkgo.By("creating a service " + serviceName + " with the type=NodePort in namespace " + ns) ginkgo.By("creating a service " + serviceName + " with the type=NodePort in namespace " + ns)
nodePortService, err := jig.CreateTCPService(ns, func(svc *v1.Service) { _, err := jig.CreateTCPService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeNodePort svc.Spec.Type = v1.ServiceTypeNodePort
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -1148,7 +1145,7 @@ var _ = SIGDescribe("Services", func() {
}() }()
ginkgo.By("changing the NodePort service to type=ExternalName") ginkgo.By("changing the NodePort service to type=ExternalName")
externalNameService, err := jig.UpdateService(ns, nodePortService.Name, func(s *v1.Service) { externalNameService, err := jig.UpdateService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeExternalName s.Spec.Type = v1.ServiceTypeExternalName
s.Spec.ExternalName = externalServiceFQDN s.Spec.ExternalName = externalServiceFQDN
s.Spec.ClusterIP = "" s.Spec.ClusterIP = ""
@ -1156,7 +1153,7 @@ var _ = SIGDescribe("Services", func() {
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil) execPod := e2epod.CreateExecPodOrFail(cs, ns, "execpod", nil)
err = jig.CheckServiceReachability(ns, externalNameService, execPod) err = jig.CheckServiceReachability(externalNameService, execPod)
framework.ExpectNoError(err) framework.ExpectNoError(err)
}) })
@ -1507,7 +1504,7 @@ var _ = SIGDescribe("Services", func() {
namespace := f.Namespace.Name namespace := f.Namespace.Name
serviceName := "lb-sourcerange" serviceName := "lb-sourcerange"
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, namespace, serviceName)
ginkgo.By("Prepare allow source ips") ginkgo.By("Prepare allow source ips")
// prepare the exec pods // prepare the exec pods
@ -1518,7 +1515,7 @@ var _ = SIGDescribe("Services", func() {
ginkgo.By("creating a pod to be part of the service " + serviceName) ginkgo.By("creating a pod to be part of the service " + serviceName)
// This container is an nginx container listening on port 80 // This container is an nginx container listening on port 80
// See kubernetes/contrib/ingress/echoheaders/nginx.conf for content of response // See kubernetes/contrib/ingress/echoheaders/nginx.conf for content of response
_, err = jig.Run(namespace, nil) _, err = jig.Run(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
// Make sure acceptPod is running. There are certain chances that pod might be teminated due to unexpected reasons. // Make sure acceptPod is running. There are certain chances that pod might be teminated due to unexpected reasons.
acceptPod, err = cs.CoreV1().Pods(namespace).Get(acceptPod.Name, metav1.GetOptions{}) acceptPod, err = cs.CoreV1().Pods(namespace).Get(acceptPod.Name, metav1.GetOptions{})
@ -1527,7 +1524,7 @@ var _ = SIGDescribe("Services", func() {
framework.ExpectNotEqual(acceptPod.Status.PodIP, "") framework.ExpectNotEqual(acceptPod.Status.PodIP, "")
// Create loadbalancer service with source range from node[0] and podAccept // Create loadbalancer service with source range from node[0] and podAccept
svc, err := jig.CreateTCPService(namespace, func(svc *v1.Service) { svc, err := jig.CreateTCPService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.Type = v1.ServiceTypeLoadBalancer
svc.Spec.LoadBalancerSourceRanges = []string{acceptPod.Status.PodIP + "/32"} svc.Spec.LoadBalancerSourceRanges = []string{acceptPod.Status.PodIP + "/32"}
}) })
@ -1538,7 +1535,7 @@ var _ = SIGDescribe("Services", func() {
e2eservice.WaitForServiceDeletedWithFinalizer(cs, svc.Namespace, svc.Name) e2eservice.WaitForServiceDeletedWithFinalizer(cs, svc.Namespace, svc.Name)
}() }()
svc, err = jig.WaitForLoadBalancer(namespace, serviceName, loadBalancerCreateTimeout) svc, err = jig.WaitForLoadBalancer(loadBalancerCreateTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
// timeout when we haven't just created the load balancer // timeout when we haven't just created the load balancer
@ -1558,7 +1555,7 @@ var _ = SIGDescribe("Services", func() {
framework.ExpectNotEqual(acceptPod.Status.PodIP, "") framework.ExpectNotEqual(acceptPod.Status.PodIP, "")
ginkgo.By("Update service LoadBalancerSourceRange and check reachability") ginkgo.By("Update service LoadBalancerSourceRange and check reachability")
_, err = jig.UpdateService(svc.Namespace, svc.Name, func(svc *v1.Service) { _, err = jig.UpdateService(func(svc *v1.Service) {
// only allow access from dropPod // only allow access from dropPod
svc.Spec.LoadBalancerSourceRanges = []string{dropPod.Status.PodIP + "/32"} svc.Spec.LoadBalancerSourceRanges = []string{dropPod.Status.PodIP + "/32"}
}) })
@ -1567,7 +1564,7 @@ var _ = SIGDescribe("Services", func() {
framework.CheckReachabilityFromPod(true, normalReachabilityTimeout, namespace, dropPod.Name, svcIP) framework.CheckReachabilityFromPod(true, normalReachabilityTimeout, namespace, dropPod.Name, svcIP)
ginkgo.By("Delete LoadBalancerSourceRange field and check reachability") ginkgo.By("Delete LoadBalancerSourceRange field and check reachability")
_, err = jig.UpdateService(svc.Namespace, svc.Name, func(svc *v1.Service) { _, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.LoadBalancerSourceRanges = nil svc.Spec.LoadBalancerSourceRanges = nil
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -1590,10 +1587,10 @@ var _ = SIGDescribe("Services", func() {
namespace := f.Namespace.Name namespace := f.Namespace.Name
serviceName := "lb-internal" serviceName := "lb-internal"
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, namespace, serviceName)
ginkgo.By("creating pod to be part of service " + serviceName) ginkgo.By("creating pod to be part of service " + serviceName)
_, err = jig.Run(namespace, nil) _, err = jig.Run(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
enableILB, disableILB := e2eservice.EnableAndDisableInternalLB() enableILB, disableILB := e2eservice.EnableAndDisableInternalLB()
@ -1605,7 +1602,7 @@ var _ = SIGDescribe("Services", func() {
} }
ginkgo.By("creating a service with type LoadBalancer and cloud specific Internal-LB annotation enabled") ginkgo.By("creating a service with type LoadBalancer and cloud specific Internal-LB annotation enabled")
svc, err := jig.CreateTCPService(namespace, func(svc *v1.Service) { svc, err := jig.CreateTCPService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.Type = v1.ServiceTypeLoadBalancer
enableILB(svc) enableILB(svc)
}) })
@ -1616,7 +1613,7 @@ var _ = SIGDescribe("Services", func() {
e2eservice.WaitForServiceDeletedWithFinalizer(cs, svc.Namespace, svc.Name) e2eservice.WaitForServiceDeletedWithFinalizer(cs, svc.Namespace, svc.Name)
}() }()
svc, err = jig.WaitForLoadBalancer(namespace, serviceName, createTimeout) svc, err = jig.WaitForLoadBalancer(createTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
lbIngress := &svc.Status.LoadBalancer.Ingress[0] lbIngress := &svc.Status.LoadBalancer.Ingress[0]
svcPort := int(svc.Spec.Ports[0].Port) svcPort := int(svc.Spec.Ports[0].Port)
@ -1651,13 +1648,13 @@ var _ = SIGDescribe("Services", func() {
} }
ginkgo.By("switching to external type LoadBalancer") ginkgo.By("switching to external type LoadBalancer")
svc, err = jig.UpdateService(namespace, serviceName, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
disableILB(svc) disableILB(svc)
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
framework.Logf("Waiting up to %v for service %q to have an external LoadBalancer", createTimeout, serviceName) framework.Logf("Waiting up to %v for service %q to have an external LoadBalancer", createTimeout, serviceName)
if pollErr := wait.PollImmediate(pollInterval, createTimeout, func() (bool, error) { if pollErr := wait.PollImmediate(pollInterval, createTimeout, func() (bool, error) {
svc, err := jig.Client.CoreV1().Services(namespace).Get(serviceName, metav1.GetOptions{}) svc, err := cs.CoreV1().Services(namespace).Get(serviceName, metav1.GetOptions{})
if err != nil { if err != nil {
return false, err return false, err
} }
@ -1679,14 +1676,14 @@ var _ = SIGDescribe("Services", func() {
if framework.ProviderIs("azure") { if framework.ProviderIs("azure") {
ginkgo.By("switching back to interal type LoadBalancer, with static IP specified.") ginkgo.By("switching back to interal type LoadBalancer, with static IP specified.")
internalStaticIP := "10.240.11.11" internalStaticIP := "10.240.11.11"
svc, err = jig.UpdateService(namespace, serviceName, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.LoadBalancerIP = internalStaticIP svc.Spec.LoadBalancerIP = internalStaticIP
enableILB(svc) enableILB(svc)
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
framework.Logf("Waiting up to %v for service %q to have an internal LoadBalancer", createTimeout, serviceName) framework.Logf("Waiting up to %v for service %q to have an internal LoadBalancer", createTimeout, serviceName)
if pollErr := wait.PollImmediate(pollInterval, createTimeout, func() (bool, error) { if pollErr := wait.PollImmediate(pollInterval, createTimeout, func() (bool, error) {
svc, err := jig.Client.CoreV1().Services(namespace).Get(serviceName, metav1.GetOptions{}) svc, err := cs.CoreV1().Services(namespace).Get(serviceName, metav1.GetOptions{})
if err != nil { if err != nil {
return false, err return false, err
} }
@ -1721,11 +1718,11 @@ var _ = SIGDescribe("Services", func() {
namespace := f.Namespace.Name namespace := f.Namespace.Name
serviceName := "lb-hc-int" serviceName := "lb-hc-int"
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, namespace, serviceName)
ginkgo.By("create load balancer service") ginkgo.By("create load balancer service")
// Create loadbalancer service with source range from node[0] and podAccept // Create loadbalancer service with source range from node[0] and podAccept
svc, err := jig.CreateTCPService(namespace, func(svc *v1.Service) { svc, err := jig.CreateTCPService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.Type = v1.ServiceTypeLoadBalancer
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -1735,7 +1732,7 @@ var _ = SIGDescribe("Services", func() {
e2eservice.WaitForServiceDeletedWithFinalizer(cs, svc.Namespace, svc.Name) e2eservice.WaitForServiceDeletedWithFinalizer(cs, svc.Namespace, svc.Name)
}() }()
svc, err = jig.WaitForLoadBalancer(namespace, serviceName, e2eservice.LoadBalancerCreateTimeoutDefault) svc, err = jig.WaitForLoadBalancer(e2eservice.LoadBalancerCreateTimeoutDefault)
framework.ExpectNoError(err) framework.ExpectNoError(err)
hcName := gcecloud.MakeNodesHealthCheckName(clusterID) hcName := gcecloud.MakeNodesHealthCheckName(clusterID)
@ -1876,7 +1873,7 @@ var _ = SIGDescribe("Services", func() {
podToggledNames, svcToggledIP, err := e2eservice.StartServeHostnameService(cs, svcToggled, ns, numPods) podToggledNames, svcToggledIP, err := e2eservice.StartServeHostnameService(cs, svcToggled, ns, numPods)
framework.ExpectNoError(err, "failed to create replication controller with service: %s in the namespace: %s", svcToggledIP, ns) framework.ExpectNoError(err, "failed to create replication controller with service: %s in the namespace: %s", svcToggledIP, ns)
jig := e2eservice.NewTestJig(cs, svcToggled.ObjectMeta.Name) jig := e2eservice.NewTestJig(cs, ns, svcToggled.ObjectMeta.Name)
hosts, err := e2essh.NodeSSHHosts(cs) hosts, err := e2essh.NodeSSHHosts(cs)
framework.ExpectNoError(err, "failed to find external/internal IPs for every node") framework.ExpectNoError(err, "failed to find external/internal IPs for every node")
@ -1892,7 +1889,7 @@ var _ = SIGDescribe("Services", func() {
framework.ExpectNoError(e2eservice.VerifyServeHostnameServiceDown(cs, host, svcDisabledIP, servicePort)) framework.ExpectNoError(e2eservice.VerifyServeHostnameServiceDown(cs, host, svcDisabledIP, servicePort))
ginkgo.By("adding service-proxy-name label") ginkgo.By("adding service-proxy-name label")
_, err = jig.UpdateService(ns, svcToggled.ObjectMeta.Name, func(svc *v1.Service) { _, err = jig.UpdateService(func(svc *v1.Service) {
svc.ObjectMeta.Labels = serviceProxyNameLabels svc.ObjectMeta.Labels = serviceProxyNameLabels
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -1901,7 +1898,7 @@ var _ = SIGDescribe("Services", func() {
framework.ExpectNoError(e2eservice.VerifyServeHostnameServiceDown(cs, host, svcToggledIP, servicePort)) framework.ExpectNoError(e2eservice.VerifyServeHostnameServiceDown(cs, host, svcToggledIP, servicePort))
ginkgo.By("removing service-proxy-name annotation") ginkgo.By("removing service-proxy-name annotation")
_, err = jig.UpdateService(ns, svcToggled.ObjectMeta.Name, func(svc *v1.Service) { _, err = jig.UpdateService(func(svc *v1.Service) {
svc.ObjectMeta.Labels = nil svc.ObjectMeta.Labels = nil
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -1940,7 +1937,7 @@ var _ = SIGDescribe("Services", func() {
podHeadlessToggledNames, svcHeadlessToggledIP, err := e2eservice.StartServeHostnameService(cs, svcHeadlessToggled, ns, numPods) podHeadlessToggledNames, svcHeadlessToggledIP, err := e2eservice.StartServeHostnameService(cs, svcHeadlessToggled, ns, numPods)
framework.ExpectNoError(err, "failed to create replication controller with service: %s in the namespace: %s", svcHeadlessToggledIP, ns) framework.ExpectNoError(err, "failed to create replication controller with service: %s in the namespace: %s", svcHeadlessToggledIP, ns)
jig := e2eservice.NewTestJig(cs, svcHeadlessToggled.ObjectMeta.Name) jig := e2eservice.NewTestJig(cs, ns, svcHeadlessToggled.ObjectMeta.Name)
hosts, err := e2essh.NodeSSHHosts(cs) hosts, err := e2essh.NodeSSHHosts(cs)
framework.ExpectNoError(err, "failed to find external/internal IPs for every node") framework.ExpectNoError(err, "failed to find external/internal IPs for every node")
@ -1956,7 +1953,7 @@ var _ = SIGDescribe("Services", func() {
framework.ExpectNoError(e2eservice.VerifyServeHostnameServiceDown(cs, host, svcHeadlessIP, servicePort)) framework.ExpectNoError(e2eservice.VerifyServeHostnameServiceDown(cs, host, svcHeadlessIP, servicePort))
ginkgo.By("adding service.kubernetes.io/headless label") ginkgo.By("adding service.kubernetes.io/headless label")
_, err = jig.UpdateService(ns, svcHeadlessToggled.ObjectMeta.Name, func(svc *v1.Service) { _, err = jig.UpdateService(func(svc *v1.Service) {
svc.ObjectMeta.Labels = serviceHeadlessLabels svc.ObjectMeta.Labels = serviceHeadlessLabels
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -1965,7 +1962,7 @@ var _ = SIGDescribe("Services", func() {
framework.ExpectNoError(e2eservice.VerifyServeHostnameServiceDown(cs, host, svcHeadlessToggledIP, servicePort)) framework.ExpectNoError(e2eservice.VerifyServeHostnameServiceDown(cs, host, svcHeadlessToggledIP, servicePort))
ginkgo.By("removing service.kubernetes.io/headless annotation") ginkgo.By("removing service.kubernetes.io/headless annotation")
_, err = jig.UpdateService(ns, svcHeadlessToggled.ObjectMeta.Name, func(svc *v1.Service) { _, err = jig.UpdateService(func(svc *v1.Service) {
svc.ObjectMeta.Labels = nil svc.ObjectMeta.Labels = nil
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -1980,13 +1977,13 @@ var _ = SIGDescribe("Services", func() {
ginkgo.It("should be rejected when no endpoints exist", func() { ginkgo.It("should be rejected when no endpoints exist", func() {
namespace := f.Namespace.Name namespace := f.Namespace.Name
serviceName := "no-pods" serviceName := "no-pods"
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, namespace, serviceName)
nodes, err := e2enode.GetBoundedReadySchedulableNodes(cs, e2eservice.MaxNodesForEndpointsTests) nodes, err := e2enode.GetBoundedReadySchedulableNodes(cs, e2eservice.MaxNodesForEndpointsTests)
framework.ExpectNoError(err) framework.ExpectNoError(err)
port := 80 port := 80
ginkgo.By("creating a service with no endpoints") ginkgo.By("creating a service with no endpoints")
_, err = jig.CreateTCPServiceWithPort(namespace, nil, int32(port)) _, err = jig.CreateTCPServiceWithPort(nil, int32(port))
framework.ExpectNoError(err) framework.ExpectNoError(err)
nodeName := nodes.Items[0].Name nodeName := nodes.Items[0].Name
@ -2027,10 +2024,10 @@ var _ = SIGDescribe("Services", func() {
// 3. Update service to type=LoadBalancer. Finalizer should be added. // 3. Update service to type=LoadBalancer. Finalizer should be added.
// 4. Delete service with type=LoadBalancer. Finalizer should be removed. // 4. Delete service with type=LoadBalancer. Finalizer should be removed.
ginkgo.It("should handle load balancer cleanup finalizer for service [Slow]", func() { ginkgo.It("should handle load balancer cleanup finalizer for service [Slow]", func() {
jig := e2eservice.NewTestJig(cs, "lb-finalizer") jig := e2eservice.NewTestJig(cs, f.Namespace.Name, "lb-finalizer")
ginkgo.By("Create load balancer service") ginkgo.By("Create load balancer service")
svc, err := jig.CreateTCPService(f.Namespace.Name, func(svc *v1.Service) { svc, err := jig.CreateTCPService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.Type = v1.ServiceTypeLoadBalancer
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -2041,19 +2038,19 @@ var _ = SIGDescribe("Services", func() {
}() }()
ginkgo.By("Wait for load balancer to serve traffic") ginkgo.By("Wait for load balancer to serve traffic")
svc, err = jig.WaitForLoadBalancer(svc.Namespace, svc.Name, e2eservice.GetServiceLoadBalancerCreationTimeout(cs)) svc, err = jig.WaitForLoadBalancer(e2eservice.GetServiceLoadBalancerCreationTimeout(cs))
framework.ExpectNoError(err) framework.ExpectNoError(err)
ginkgo.By("Check if finalizer presents on service with type=LoadBalancer") ginkgo.By("Check if finalizer presents on service with type=LoadBalancer")
e2eservice.WaitForServiceUpdatedWithFinalizer(cs, svc.Namespace, svc.Name, true) e2eservice.WaitForServiceUpdatedWithFinalizer(cs, svc.Namespace, svc.Name, true)
ginkgo.By("Check if finalizer is removed on service after changed to type=ClusterIP") ginkgo.By("Check if finalizer is removed on service after changed to type=ClusterIP")
err = jig.ChangeServiceType(svc.Namespace, svc.Name, v1.ServiceTypeClusterIP, e2eservice.GetServiceLoadBalancerCreationTimeout(cs)) err = jig.ChangeServiceType(v1.ServiceTypeClusterIP, e2eservice.GetServiceLoadBalancerCreationTimeout(cs))
framework.ExpectNoError(err) framework.ExpectNoError(err)
e2eservice.WaitForServiceUpdatedWithFinalizer(cs, svc.Namespace, svc.Name, false) e2eservice.WaitForServiceUpdatedWithFinalizer(cs, svc.Namespace, svc.Name, false)
ginkgo.By("Check if finalizer is added back to service after changed to type=LoadBalancer") ginkgo.By("Check if finalizer is added back to service after changed to type=LoadBalancer")
err = jig.ChangeServiceType(svc.Namespace, svc.Name, v1.ServiceTypeLoadBalancer, e2eservice.GetServiceLoadBalancerCreationTimeout(cs)) err = jig.ChangeServiceType(v1.ServiceTypeLoadBalancer, e2eservice.GetServiceLoadBalancerCreationTimeout(cs))
framework.ExpectNoError(err) framework.ExpectNoError(err)
e2eservice.WaitForServiceUpdatedWithFinalizer(cs, svc.Namespace, svc.Name, true) e2eservice.WaitForServiceUpdatedWithFinalizer(cs, svc.Namespace, svc.Name, true)
}) })
@ -2094,9 +2091,9 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
ginkgo.It("should work for type=LoadBalancer", func() { ginkgo.It("should work for type=LoadBalancer", func() {
namespace := f.Namespace.Name namespace := f.Namespace.Name
serviceName := "external-local-lb" serviceName := "external-local-lb"
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, namespace, serviceName)
svc, err := jig.CreateOnlyLocalLoadBalancerService(namespace, serviceName, loadBalancerCreateTimeout, true, nil) svc, err := jig.CreateOnlyLocalLoadBalancerService(loadBalancerCreateTimeout, true, nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
serviceLBNames = append(serviceLBNames, cloudprovider.DefaultLoadBalancerName(svc)) serviceLBNames = append(serviceLBNames, cloudprovider.DefaultLoadBalancerName(svc))
healthCheckNodePort := int(svc.Spec.HealthCheckNodePort) healthCheckNodePort := int(svc.Spec.HealthCheckNodePort)
@ -2104,12 +2101,12 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
framework.Failf("Service HealthCheck NodePort was not allocated") framework.Failf("Service HealthCheck NodePort was not allocated")
} }
defer func() { defer func() {
err = jig.ChangeServiceType(svc.Namespace, svc.Name, v1.ServiceTypeClusterIP, loadBalancerCreateTimeout) err = jig.ChangeServiceType(v1.ServiceTypeClusterIP, loadBalancerCreateTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
// Make sure we didn't leak the health check node port. // Make sure we didn't leak the health check node port.
threshold := 2 threshold := 2
nodes, err := jig.GetEndpointNodes(svc) nodes, err := jig.GetEndpointNodes()
framework.ExpectNoError(err) framework.ExpectNoError(err)
for _, ips := range nodes { for _, ips := range nodes {
err := e2eservice.TestHTTPHealthCheckNodePort(ips[0], healthCheckNodePort, "/healthz", e2eservice.KubeProxyEndpointLagTimeout, false, threshold) err := e2eservice.TestHTTPHealthCheckNodePort(ips[0], healthCheckNodePort, "/healthz", e2eservice.KubeProxyEndpointLagTimeout, false, threshold)
@ -2136,9 +2133,9 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
ginkgo.It("should work for type=NodePort", func() { ginkgo.It("should work for type=NodePort", func() {
namespace := f.Namespace.Name namespace := f.Namespace.Name
serviceName := "external-local-nodeport" serviceName := "external-local-nodeport"
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, namespace, serviceName)
svc, err := jig.CreateOnlyLocalNodePortService(namespace, serviceName, true) svc, err := jig.CreateOnlyLocalNodePortService(true)
framework.ExpectNoError(err) framework.ExpectNoError(err)
defer func() { defer func() {
err := cs.CoreV1().Services(svc.Namespace).Delete(svc.Name, nil) err := cs.CoreV1().Services(svc.Namespace).Delete(svc.Name, nil)
@ -2146,7 +2143,7 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
}() }()
tcpNodePort := int(svc.Spec.Ports[0].NodePort) tcpNodePort := int(svc.Spec.Ports[0].NodePort)
endpointsNodeMap, err := jig.GetEndpointNodes(svc) endpointsNodeMap, err := jig.GetEndpointNodes()
framework.ExpectNoError(err) framework.ExpectNoError(err)
path := "/clientip" path := "/clientip"
@ -2165,11 +2162,11 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
ginkgo.It("should only target nodes with endpoints", func() { ginkgo.It("should only target nodes with endpoints", func() {
namespace := f.Namespace.Name namespace := f.Namespace.Name
serviceName := "external-local-nodes" serviceName := "external-local-nodes"
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, namespace, serviceName)
nodes, err := e2enode.GetBoundedReadySchedulableNodes(cs, e2eservice.MaxNodesForEndpointsTests) nodes, err := e2enode.GetBoundedReadySchedulableNodes(cs, e2eservice.MaxNodesForEndpointsTests)
framework.ExpectNoError(err) framework.ExpectNoError(err)
svc, err := jig.CreateOnlyLocalLoadBalancerService(namespace, serviceName, loadBalancerCreateTimeout, false, svc, err := jig.CreateOnlyLocalLoadBalancerService(loadBalancerCreateTimeout, false,
func(svc *v1.Service) { func(svc *v1.Service) {
// Change service port to avoid collision with opened hostPorts // Change service port to avoid collision with opened hostPorts
// in other tests that run in parallel. // in other tests that run in parallel.
@ -2182,7 +2179,7 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
framework.ExpectNoError(err) framework.ExpectNoError(err)
serviceLBNames = append(serviceLBNames, cloudprovider.DefaultLoadBalancerName(svc)) serviceLBNames = append(serviceLBNames, cloudprovider.DefaultLoadBalancerName(svc))
defer func() { defer func() {
err = jig.ChangeServiceType(svc.Namespace, svc.Name, v1.ServiceTypeClusterIP, loadBalancerCreateTimeout) err = jig.ChangeServiceType(v1.ServiceTypeClusterIP, loadBalancerCreateTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
err := cs.CoreV1().Services(svc.Namespace).Delete(svc.Name, nil) err := cs.CoreV1().Services(svc.Namespace).Delete(svc.Name, nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -2204,7 +2201,7 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
endpointNodeName := nodes.Items[i].Name endpointNodeName := nodes.Items[i].Name
ginkgo.By("creating a pod to be part of the service " + serviceName + " on node " + endpointNodeName) ginkgo.By("creating a pod to be part of the service " + serviceName + " on node " + endpointNodeName)
_, err = jig.Run(namespace, func(rc *v1.ReplicationController) { _, err = jig.Run(func(rc *v1.ReplicationController) {
rc.Name = serviceName rc.Name = serviceName
if endpointNodeName != "" { if endpointNodeName != "" {
rc.Spec.Template.Spec.NodeName = endpointNodeName rc.Spec.Template.Spec.NodeName = endpointNodeName
@ -2213,7 +2210,7 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
framework.ExpectNoError(err) framework.ExpectNoError(err)
ginkgo.By(fmt.Sprintf("waiting for service endpoint on node %v", endpointNodeName)) ginkgo.By(fmt.Sprintf("waiting for service endpoint on node %v", endpointNodeName))
err = jig.WaitForEndpointOnNode(namespace, serviceName, endpointNodeName) err = jig.WaitForEndpointOnNode(endpointNodeName)
framework.ExpectNoError(err) framework.ExpectNoError(err)
// HealthCheck should pass only on the node where num(endpoints) > 0 // HealthCheck should pass only on the node where num(endpoints) > 0
@ -2237,13 +2234,13 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
var err error var err error
namespace := f.Namespace.Name namespace := f.Namespace.Name
serviceName := "external-local-pods" serviceName := "external-local-pods"
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, namespace, serviceName)
svc, err := jig.CreateOnlyLocalLoadBalancerService(namespace, serviceName, loadBalancerCreateTimeout, true, nil) svc, err := jig.CreateOnlyLocalLoadBalancerService(loadBalancerCreateTimeout, true, nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
serviceLBNames = append(serviceLBNames, cloudprovider.DefaultLoadBalancerName(svc)) serviceLBNames = append(serviceLBNames, cloudprovider.DefaultLoadBalancerName(svc))
defer func() { defer func() {
err = jig.ChangeServiceType(svc.Namespace, svc.Name, v1.ServiceTypeClusterIP, loadBalancerCreateTimeout) err = jig.ChangeServiceType(v1.ServiceTypeClusterIP, loadBalancerCreateTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
err := cs.CoreV1().Services(svc.Namespace).Delete(svc.Name, nil) err := cs.CoreV1().Services(svc.Namespace).Delete(svc.Name, nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -2294,7 +2291,7 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
ginkgo.It("should handle updates to ExternalTrafficPolicy field", func() { ginkgo.It("should handle updates to ExternalTrafficPolicy field", func() {
namespace := f.Namespace.Name namespace := f.Namespace.Name
serviceName := "external-local-update" serviceName := "external-local-update"
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, namespace, serviceName)
nodes, err := e2enode.GetBoundedReadySchedulableNodes(cs, e2eservice.MaxNodesForEndpointsTests) nodes, err := e2enode.GetBoundedReadySchedulableNodes(cs, e2eservice.MaxNodesForEndpointsTests)
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -2302,11 +2299,11 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
framework.Failf("Need at least 2 nodes to verify source ip from a node without endpoint") framework.Failf("Need at least 2 nodes to verify source ip from a node without endpoint")
} }
svc, err := jig.CreateOnlyLocalLoadBalancerService(namespace, serviceName, loadBalancerCreateTimeout, true, nil) svc, err := jig.CreateOnlyLocalLoadBalancerService(loadBalancerCreateTimeout, true, nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
serviceLBNames = append(serviceLBNames, cloudprovider.DefaultLoadBalancerName(svc)) serviceLBNames = append(serviceLBNames, cloudprovider.DefaultLoadBalancerName(svc))
defer func() { defer func() {
err = jig.ChangeServiceType(svc.Namespace, svc.Name, v1.ServiceTypeClusterIP, loadBalancerCreateTimeout) err = jig.ChangeServiceType(v1.ServiceTypeClusterIP, loadBalancerCreateTimeout)
framework.ExpectNoError(err) framework.ExpectNoError(err)
err := cs.CoreV1().Services(svc.Namespace).Delete(svc.Name, nil) err := cs.CoreV1().Services(svc.Namespace).Delete(svc.Name, nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -2316,7 +2313,7 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
healthCheckNodePort := int(svc.Spec.HealthCheckNodePort) healthCheckNodePort := int(svc.Spec.HealthCheckNodePort)
ginkgo.By("turning ESIPP off") ginkgo.By("turning ESIPP off")
svc, err = jig.UpdateService(svc.Namespace, svc.Name, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeCluster svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeCluster
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -2324,7 +2321,7 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
framework.Failf("Service HealthCheck NodePort still present") framework.Failf("Service HealthCheck NodePort still present")
} }
endpointNodeMap, err := jig.GetEndpointNodes(svc) endpointNodeMap, err := jig.GetEndpointNodes()
framework.ExpectNoError(err) framework.ExpectNoError(err)
noEndpointNodeMap := map[string][]string{} noEndpointNodeMap := map[string][]string{}
for _, n := range nodes.Items { for _, n := range nodes.Items {
@ -2385,7 +2382,7 @@ var _ = SIGDescribe("ESIPP [Slow] [DisabledForLargeClusters]", func() {
// creation will fail. // creation will fail.
ginkgo.By("setting ExternalTraffic field back to OnlyLocal") ginkgo.By("setting ExternalTraffic field back to OnlyLocal")
svc, err = jig.UpdateService(svc.Namespace, svc.Name, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal
// Request the same healthCheckNodePort as before, to test the user-requested allocation path // Request the same healthCheckNodePort as before, to test the user-requested allocation path
svc.Spec.HealthCheckNodePort = int32(healthCheckNodePort) svc.Spec.HealthCheckNodePort = int32(healthCheckNodePort)
@ -2462,7 +2459,7 @@ func execAffinityTestForNonLBServiceWithOptionalTransition(f *framework.Framewor
defer func() { defer func() {
e2eservice.StopServeHostnameService(cs, ns, serviceName) e2eservice.StopServeHostnameService(cs, ns, serviceName)
}() }()
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
svc, err = jig.Client.CoreV1().Services(ns).Get(serviceName, metav1.GetOptions{}) svc, err = jig.Client.CoreV1().Services(ns).Get(serviceName, metav1.GetOptions{})
framework.ExpectNoError(err, "failed to fetch service: %s in namespace: %s", serviceName, ns) framework.ExpectNoError(err, "failed to fetch service: %s in namespace: %s", serviceName, ns)
var svcIP string var svcIP string
@ -2483,19 +2480,19 @@ func execAffinityTestForNonLBServiceWithOptionalTransition(f *framework.Framewor
err := cs.CoreV1().Pods(ns).Delete(execPod.Name, nil) err := cs.CoreV1().Pods(ns).Delete(execPod.Name, nil)
framework.ExpectNoError(err, "failed to delete pod: %s in namespace: %s", execPod.Name, ns) framework.ExpectNoError(err, "failed to delete pod: %s in namespace: %s", execPod.Name, ns)
}() }()
err = jig.CheckServiceReachability(ns, svc, execPod) err = jig.CheckServiceReachability(svc, execPod)
framework.ExpectNoError(err) framework.ExpectNoError(err)
if !isTransitionTest { if !isTransitionTest {
gomega.Expect(e2eservice.CheckAffinity(execPod, svcIP, servicePort, true)).To(gomega.BeTrue()) gomega.Expect(e2eservice.CheckAffinity(execPod, svcIP, servicePort, true)).To(gomega.BeTrue())
} }
if isTransitionTest { if isTransitionTest {
svc, err = jig.UpdateService(svc.Namespace, svc.Name, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.SessionAffinity = v1.ServiceAffinityNone svc.Spec.SessionAffinity = v1.ServiceAffinityNone
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
gomega.Expect(e2eservice.CheckAffinity(execPod, svcIP, servicePort, false)).To(gomega.BeTrue()) gomega.Expect(e2eservice.CheckAffinity(execPod, svcIP, servicePort, false)).To(gomega.BeTrue())
svc, err = jig.UpdateService(svc.Namespace, svc.Name, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.SessionAffinity = v1.ServiceAffinityClientIP svc.Spec.SessionAffinity = v1.ServiceAffinityClientIP
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -2521,9 +2518,9 @@ func execAffinityTestForLBServiceWithOptionalTransition(f *framework.Framework,
svc.Spec.SessionAffinity = v1.ServiceAffinityClientIP svc.Spec.SessionAffinity = v1.ServiceAffinityClientIP
_, _, err := e2eservice.StartServeHostnameService(cs, svc, ns, numPods) _, _, err := e2eservice.StartServeHostnameService(cs, svc, ns, numPods)
framework.ExpectNoError(err, "failed to create replication controller with service in the namespace: %s", ns) framework.ExpectNoError(err, "failed to create replication controller with service in the namespace: %s", ns)
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
ginkgo.By("waiting for loadbalancer for service " + ns + "/" + serviceName) ginkgo.By("waiting for loadbalancer for service " + ns + "/" + serviceName)
svc, err = jig.WaitForLoadBalancer(ns, serviceName, e2eservice.LoadBalancerCreateTimeoutDefault) svc, err = jig.WaitForLoadBalancer(e2eservice.LoadBalancerCreateTimeoutDefault)
framework.ExpectNoError(err) framework.ExpectNoError(err)
defer func() { defer func() {
podNodePairs, err := e2enode.PodNodePairs(cs, ns) podNodePairs, err := e2enode.PodNodePairs(cs, ns)
@ -2540,12 +2537,12 @@ func execAffinityTestForLBServiceWithOptionalTransition(f *framework.Framework,
gomega.Expect(e2eservice.CheckAffinity(nil, ingressIP, port, true)).To(gomega.BeTrue()) gomega.Expect(e2eservice.CheckAffinity(nil, ingressIP, port, true)).To(gomega.BeTrue())
} }
if isTransitionTest { if isTransitionTest {
svc, err = jig.UpdateService(svc.Namespace, svc.Name, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.SessionAffinity = v1.ServiceAffinityNone svc.Spec.SessionAffinity = v1.ServiceAffinityNone
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
gomega.Expect(e2eservice.CheckAffinity(nil, ingressIP, port, false)).To(gomega.BeTrue()) gomega.Expect(e2eservice.CheckAffinity(nil, ingressIP, port, false)).To(gomega.BeTrue())
svc, err = jig.UpdateService(svc.Namespace, svc.Name, func(svc *v1.Service) { svc, err = jig.UpdateService(func(svc *v1.Service) {
svc.Spec.SessionAffinity = v1.ServiceAffinityClientIP svc.Spec.SessionAffinity = v1.ServiceAffinityClientIP
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)

10
test/e2e/upgrades/services.go
View File

@ -43,16 +43,16 @@ func shouldTestPDBs() bool { return framework.ProviderIs("gce", "gke") }
// Setup creates a service with a load balancer and makes sure it's reachable. // Setup creates a service with a load balancer and makes sure it's reachable.
func (t *ServiceUpgradeTest) Setup(f *framework.Framework) { func (t *ServiceUpgradeTest) Setup(f *framework.Framework) {
serviceName := "service-test" serviceName := "service-test"
jig := e2eservice.NewTestJig(f.ClientSet, serviceName) jig := e2eservice.NewTestJig(f.ClientSet, f.Namespace.Name, serviceName)
ns := f.Namespace ns := f.Namespace
ginkgo.By("creating a TCP service " + serviceName + " with type=LoadBalancer in namespace " + ns.Name) ginkgo.By("creating a TCP service " + serviceName + " with type=LoadBalancer in namespace " + ns.Name)
tcpService, err := jig.CreateTCPService(ns.Name, func(s *v1.Service) { tcpService, err := jig.CreateTCPService(func(s *v1.Service) {
s.Spec.Type = v1.ServiceTypeLoadBalancer s.Spec.Type = v1.ServiceTypeLoadBalancer
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
tcpService, err = jig.WaitForLoadBalancer(ns.Name, tcpService.Name, e2eservice.LoadBalancerCreateTimeoutDefault) tcpService, err = jig.WaitForLoadBalancer(e2eservice.LoadBalancerCreateTimeoutDefault)
framework.ExpectNoError(err) framework.ExpectNoError(err)
// Get info to hit it with // Get info to hit it with
@ -60,12 +60,12 @@ func (t *ServiceUpgradeTest) Setup(f *framework.Framework) {
svcPort := int(tcpService.Spec.Ports[0].Port) svcPort := int(tcpService.Spec.Ports[0].Port)
ginkgo.By("creating pod to be part of service " + serviceName) ginkgo.By("creating pod to be part of service " + serviceName)
rc, err := jig.Run(ns.Name, jig.AddRCAntiAffinity) rc, err := jig.Run(jig.AddRCAntiAffinity)
framework.ExpectNoError(err) framework.ExpectNoError(err)
if shouldTestPDBs() { if shouldTestPDBs() {
ginkgo.By("creating a PodDisruptionBudget to cover the ReplicationController") ginkgo.By("creating a PodDisruptionBudget to cover the ReplicationController")
_, err = jig.CreatePDB(ns.Name, rc) _, err = jig.CreatePDB(rc)
framework.ExpectNoError(err) framework.ExpectNoError(err)
} }

6
test/e2e/windows/service.go
View File

@ -42,12 +42,12 @@ var _ = SIGDescribe("Services", func() {
serviceName := "nodeport-test" serviceName := "nodeport-test"
ns := f.Namespace.Name ns := f.Namespace.Name
jig := e2eservice.NewTestJig(cs, serviceName) jig := e2eservice.NewTestJig(cs, ns, serviceName)
nodeIP, err := e2enode.PickIP(jig.Client) nodeIP, err := e2enode.PickIP(jig.Client)
framework.ExpectNoError(err) framework.ExpectNoError(err)
ginkgo.By("creating service " + serviceName + " with type=NodePort in namespace " + ns) ginkgo.By("creating service " + serviceName + " with type=NodePort in namespace " + ns)
svc, err := jig.CreateTCPService(ns, func(svc *v1.Service) { svc, err := jig.CreateTCPService(func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeNodePort svc.Spec.Type = v1.ServiceTypeNodePort
}) })
framework.ExpectNoError(err) framework.ExpectNoError(err)
@ -55,7 +55,7 @@ var _ = SIGDescribe("Services", func() {
nodePort := int(svc.Spec.Ports[0].NodePort) nodePort := int(svc.Spec.Ports[0].NodePort)
ginkgo.By("creating Pod to be part of service " + serviceName) ginkgo.By("creating Pod to be part of service " + serviceName)
_, err = jig.Run(ns, nil) _, err = jig.Run(nil)
framework.ExpectNoError(err) framework.ExpectNoError(err)
//using hybrid_network methods //using hybrid_network methods