Test GCE ILB functionality

test/e2e/framework/service_util.go

@@ -39,6 +39,8 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/client/retry"
+	azurecloud "k8s.io/kubernetes/pkg/cloudprovider/providers/azure"
+	gcecloud "k8s.io/kubernetes/pkg/cloudprovider/providers/gce"
 	testutils "k8s.io/kubernetes/test/utils"
 
 	. "github.com/onsi/ginkgo"
@@ -1389,3 +1391,29 @@ func CreateServiceSpec(serviceName, externalName string, isHeadless bool, select
 	}
 	return headlessService
 }
+
+// EnableAndDisableInternalLB returns two functions for enabling and disabling the internal load balancer
+// setting for the supported cloud providers: GCE/GKE and Azure
+func EnableAndDisableInternalLB() (enable func(svc *v1.Service), disable func(svc *v1.Service)) {
+	enable = func(svc *v1.Service) {}
+	disable = func(svc *v1.Service) {}
+
+	switch TestContext.Provider {
+	case "gce", "gke":
+		enable = func(svc *v1.Service) {
+			svc.ObjectMeta.Annotations = map[string]string{gcecloud.ServiceAnnotationLoadBalancerType: string(gcecloud.LBTypeInternal)}
+		}
+		disable = func(svc *v1.Service) {
+			delete(svc.ObjectMeta.Annotations, gcecloud.ServiceAnnotationLoadBalancerType)
+		}
+	case "azure":
+		enable = func(svc *v1.Service) {
+			svc.ObjectMeta.Annotations = map[string]string{azurecloud.ServiceAnnotationLoadBalancerInternal: "true"}
+		}
+		disable = func(svc *v1.Service) {
+			svc.ObjectMeta.Annotations = map[string]string{azurecloud.ServiceAnnotationLoadBalancerInternal: "false"}
+		}
+	}
+
+	return
+}

test/e2e/network/service.go

@@ -1337,29 +1337,31 @@ var _ = framework.KubeDescribe("Services", func() {
 		framework.CheckReachabilityFromPod(true, normalReachabilityTimeout, namespace, dropPodName, svcIP)
 	})
 
-	It("should be able to create an internal type load balancer on Azure [Slow]", func() {
+	It("should be able to create an internal type load balancer [Slow]", func() {
-		framework.SkipUnlessProviderIs("azure")
+		framework.SkipUnlessProviderIs("azure", "gke", "gce")
 
 		createTimeout := framework.LoadBalancerCreateTimeoutDefault
 		pollInterval := framework.Poll * 10
 
-		serviceAnnotationLoadBalancerInternal := "service.beta.kubernetes.io/azure-load-balancer-internal"
 		namespace := f.Namespace.Name
 		serviceName := "lb-internal"
 		jig := framework.NewServiceTestJig(cs, serviceName)
 
+		By("creating pod to be part of service " + serviceName)
+		jig.RunOrFail(namespace, nil)
+
+		enableILB, disableILB := framework.EnableAndDisableInternalLB()
+
 		isInternalEndpoint := func(lbIngress *v1.LoadBalancerIngress) bool {
 			ingressEndpoint := framework.GetIngressPoint(lbIngress)
 			// Needs update for providers using hostname as endpoint.
 			return strings.HasPrefix(ingressEndpoint, "10.")
 		}
 
-		By("creating a service with type LoadBalancer and LoadBalancerInternal annotation set to true")
+		By("creating a service with type LoadBalancer and cloud specific Internal-LB annotation enabled")
 		svc := jig.CreateTCPServiceOrFail(namespace, func(svc *v1.Service) {
 			svc.Spec.Type = v1.ServiceTypeLoadBalancer
-			svc.ObjectMeta.Annotations = map[string]string{
+			enableILB(svc)
-				serviceAnnotationLoadBalancerInternal: "true",
-			}
 		})
 		svc = jig.WaitForLoadBalancerOrFail(namespace, serviceName, createTimeout)
 		jig.SanityCheckService(svc, v1.ServiceTypeLoadBalancer)
@@ -1367,9 +1369,9 @@ var _ = framework.KubeDescribe("Services", func() {
 		// should have an internal IP.
 		Expect(isInternalEndpoint(lbIngress)).To(BeTrue())
 
-		By("switiching to external type LoadBalancer")
+		By("switching to external type LoadBalancer")
 		svc = jig.UpdateServiceOrFail(namespace, serviceName, func(svc *v1.Service) {
-			svc.ObjectMeta.Annotations[serviceAnnotationLoadBalancerInternal] = "false"
+			disableILB(svc)
 		})
 		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) {
@@ -1386,26 +1388,33 @@ var _ = framework.KubeDescribe("Services", func() {
 		jig.SanityCheckService(svc, v1.ServiceTypeLoadBalancer)
 		Expect(isInternalEndpoint(lbIngress)).To(BeFalse())
 
-		By("switiching back to interal type LoadBalancer, with static IP specified.")
+		// GCE cannot test a specific IP because the test may not own it. This cloud specific condition
-		internalStaticIP := "10.240.11.11"
+		// will be removed when GCP supports similar functionality.
-		svc = jig.UpdateServiceOrFail(namespace, serviceName, func(svc *v1.Service) {
+		if framework.ProviderIs("azure") {
-			svc.Spec.LoadBalancerIP = internalStaticIP
+			By("switching back to interal type LoadBalancer, with static IP specified.")
-			svc.ObjectMeta.Annotations[serviceAnnotationLoadBalancerInternal] = "true"
+			internalStaticIP := "10.240.11.11"
-		})
+			svc = jig.UpdateServiceOrFail(namespace, serviceName, func(svc *v1.Service) {
-		framework.Logf("Waiting up to %v for service %q to have an internal LoadBalancer", createTimeout, serviceName)
+				svc.Spec.LoadBalancerIP = internalStaticIP
-		if pollErr := wait.PollImmediate(pollInterval, createTimeout, func() (bool, error) {
+				enableILB(svc)
-			svc, err := jig.Client.Core().Services(namespace).Get(serviceName, metav1.GetOptions{})
+			})
-			if err != nil {
+			framework.Logf("Waiting up to %v for service %q to have an internal LoadBalancer", createTimeout, serviceName)
-				return false, err
+			if pollErr := wait.PollImmediate(pollInterval, createTimeout, func() (bool, error) {
+				svc, err := jig.Client.Core().Services(namespace).Get(serviceName, metav1.GetOptions{})
+				if err != nil {
+					return false, err
+				}
+				lbIngress = &svc.Status.LoadBalancer.Ingress[0]
+				return isInternalEndpoint(lbIngress), nil
+			}); pollErr != nil {
+				framework.Failf("Loadbalancer IP not changed to internal.")
 			}
-			lbIngress = &svc.Status.LoadBalancer.Ingress[0]
+			// should have the given static internal IP.
-			return isInternalEndpoint(lbIngress), nil
+			jig.SanityCheckService(svc, v1.ServiceTypeLoadBalancer)
-		}); pollErr != nil {
+			Expect(framework.GetIngressPoint(lbIngress)).To(Equal(internalStaticIP))
-			framework.Failf("Loadbalancer IP not changed to internal.")
 		}
-		// should have the given static internal IP.
+
-		jig.SanityCheckService(svc, v1.ServiceTypeLoadBalancer)
+		By("switching to ClusterIP type to destroy loadbalancer")
-		Expect(framework.GetIngressPoint(lbIngress)).To(Equal(internalStaticIP))
+		jig.ChangeServiceType(svc.Namespace, svc.Name, v1.ServiceTypeClusterIP, createTimeout)
 	})
 })