vendor updates

vendor/k8s.io/kubernetes/test/e2e/upgrades/BUILD

@@ -29,9 +29,11 @@ go_library(
         "//test/e2e/common:go_default_library",
         "//test/e2e/framework:go_default_library",
         "//test/utils/image:go_default_library",
+        "//vendor/github.com/davecgh/go-spew/spew:go_default_library",
         "//vendor/github.com/onsi/ginkgo:go_default_library",
         "//vendor/github.com/onsi/gomega:go_default_library",
         "//vendor/github.com/onsi/gomega/gstruct:go_default_library",
+        "//vendor/google.golang.org/api/compute/v1:go_default_library",
         "//vendor/k8s.io/api/autoscaling/v1:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
         "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",

vendor/k8s.io/kubernetes/test/e2e/upgrades/apps/BUILD

@@ -24,7 +24,7 @@ go_library(
         "//test/utils/image:go_default_library",
         "//vendor/github.com/onsi/ginkgo:go_default_library",
         "//vendor/github.com/onsi/gomega:go_default_library",
-        "//vendor/k8s.io/api/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/api/apps/v1:go_default_library",
         "//vendor/k8s.io/api/batch/v1:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
         "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",

vendor/k8s.io/kubernetes/test/e2e/upgrades/apps/daemonsets.go

@@ -119,7 +119,7 @@ func (t *DaemonSetUpgradeTest) validateRunningDaemonSet(f *framework.Framework)
 }
 
 func checkRunningOnAllNodes(f *framework.Framework, namespace string, selector map[string]string) (bool, error) {
-	nodeList, err := f.ClientSet.Core().Nodes().List(metav1.ListOptions{})
+	nodeList, err := f.ClientSet.CoreV1().Nodes().List(metav1.ListOptions{})
 	if err != nil {
 		return false, err
 	}
@@ -139,7 +139,7 @@ func checkRunningOnAllNodes(f *framework.Framework, namespace string, selector m
 func checkDaemonPodOnNodes(f *framework.Framework, namespace string, labelSet map[string]string, nodeNames []string) (bool, error) {
 	selector := labels.Set(labelSet).AsSelector()
 	options := metav1.ListOptions{LabelSelector: selector.String()}
-	podList, err := f.ClientSet.Core().Pods(namespace).List(options)
+	podList, err := f.ClientSet.CoreV1().Pods(namespace).List(options)
 	if err != nil {
 		return false, err
 	}

vendor/k8s.io/kubernetes/test/e2e/upgrades/apps/replicasets.go

@@ -54,7 +54,7 @@ func (r *ReplicaSetUpgradeTest) Setup(f *framework.Framework) {
 
 	By(fmt.Sprintf("Creating replicaset %s in namespace %s", rsName, ns))
 	replicaSet := framework.NewReplicaSet(rsName, ns, 1, map[string]string{"test": "upgrade"}, "nginx", nginxImage)
-	rs, err := c.Extensions().ReplicaSets(ns).Create(replicaSet)
+	rs, err := c.ExtensionsV1beta1().ReplicaSets(ns).Create(replicaSet)
 	framework.ExpectNoError(err)
 
 	By(fmt.Sprintf("Waiting for replicaset %s to have all of its replicas ready", rsName))
@@ -67,7 +67,7 @@ func (r *ReplicaSetUpgradeTest) Setup(f *framework.Framework) {
 func (r *ReplicaSetUpgradeTest) Test(f *framework.Framework, done <-chan struct{}, upgrade upgrades.UpgradeType) {
 	c := f.ClientSet
 	ns := f.Namespace.Name
-	rsClient := c.Extensions().ReplicaSets(ns)
+	rsClient := c.ExtensionsV1beta1().ReplicaSets(ns)
 
 	// Block until upgrade is done
 	By(fmt.Sprintf("Waiting for upgrade to finish before checking replicaset %s", rsName))

vendor/k8s.io/kubernetes/test/e2e/upgrades/apps/statefulset.go

@@ -20,7 +20,7 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
-	apps "k8s.io/api/apps/v1beta1"
+	apps "k8s.io/api/apps/v1"
 	"k8s.io/api/core/v1"
 	"k8s.io/kubernetes/pkg/util/version"
 
@@ -66,12 +66,12 @@ func (t *StatefulSetUpgradeTest) Setup(f *framework.Framework) {
 	t.tester.PauseNewPods(t.set)
 
 	By("Creating service " + headlessSvcName + " in namespace " + ns)
-	_, err := f.ClientSet.Core().Services(ns).Create(t.service)
+	_, err := f.ClientSet.CoreV1().Services(ns).Create(t.service)
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Creating statefulset " + ssName + " in namespace " + ns)
 	*(t.set.Spec.Replicas) = 3
-	_, err = f.ClientSet.AppsV1beta1().StatefulSets(ns).Create(t.set)
+	_, err = f.ClientSet.AppsV1().StatefulSets(ns).Create(t.set)
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Saturating stateful set " + t.set.Name)

vendor/k8s.io/kubernetes/test/e2e/upgrades/ingress.go

@@ -17,29 +17,56 @@ limitations under the License.
 package upgrades
 
 import (
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"path/filepath"
+	"reflect"
 
+	"github.com/davecgh/go-spew/spew"
 	. "github.com/onsi/ginkgo"
 
+	compute "google.golang.org/api/compute/v1"
+	extensions "k8s.io/api/extensions/v1beta1"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/kubernetes/test/e2e/framework"
 )
 
+// Dependent on "static-ip-2" manifests
+const path = "foo"
+const host = "ingress.test.com"
+
 // IngressUpgradeTest adapts the Ingress e2e for upgrade testing
 type IngressUpgradeTest struct {
 	gceController *framework.GCEIngressController
+	// holds GCP resources pre-upgrade
+	resourceStore *GCPResourceStore
 	jig           *framework.IngressTestJig
 	httpClient    *http.Client
 	ip            string
 	ipName        string
 }
 
+// GCPResourceStore keeps track of the GCP resources spun up by an ingress.
+// Note: Fields are exported so that we can utilize reflection.
+type GCPResourceStore struct {
+	Fw      *compute.Firewall
+	FwdList []*compute.ForwardingRule
+	UmList  []*compute.UrlMap
+	TpList  []*compute.TargetHttpProxy
+	TpsList []*compute.TargetHttpsProxy
+	SslList []*compute.SslCertificate
+	BeList  []*compute.BackendService
+	Ip      *compute.Address
+	IgList  []*compute.InstanceGroup
+}
+
 func (IngressUpgradeTest) Name() string { return "ingress-upgrade" }
 
 // Setup creates a GLBC, allocates an ip, and an ingress resource,
 // then waits for a successful connectivity check to the ip.
+// Also keeps track of all load balancer resources for cross-checking
+// during an IngressUpgrade.
 func (t *IngressUpgradeTest) Setup(f *framework.Framework) {
 	framework.SkipUnlessProviderIs("gce", "gke")
 
@@ -54,7 +81,7 @@ func (t *IngressUpgradeTest) Setup(f *framework.Framework) {
 		Client: jig.Client,
 		Cloud:  framework.TestContext.CloudConfig,
 	}
-	gceController.Init()
+	framework.ExpectNoError(gceController.Init())
 
 	t.gceController = gceController
 	t.jig = jig
@@ -66,13 +93,18 @@ func (t *IngressUpgradeTest) Setup(f *framework.Framework) {
 
 	// Create a working basic Ingress
 	By(fmt.Sprintf("allocated static ip %v: %v through the GCE cloud provider", t.ipName, t.ip))
-	jig.CreateIngress(filepath.Join(framework.IngressManifestPath, "static-ip"), ns.Name, map[string]string{
-		"kubernetes.io/ingress.global-static-ip-name": t.ipName,
-		"kubernetes.io/ingress.allow-http":            "false",
+	jig.CreateIngress(filepath.Join(framework.IngressManifestPath, "static-ip-2"), ns.Name, map[string]string{
+		framework.IngressStaticIPKey:  t.ipName,
+		framework.IngressAllowHTTPKey: "false",
 	}, map[string]string{})
+	t.jig.AddHTTPS("tls-secret", "ingress.test.com")
 
 	By("waiting for Ingress to come up with ip: " + t.ip)
-	framework.ExpectNoError(framework.PollURL(fmt.Sprintf("https://%v/", t.ip), "", framework.LoadBalancerPollTimeout, jig.PollInterval, t.httpClient, false))
+	framework.ExpectNoError(framework.PollURL(fmt.Sprintf("https://%v/%v", t.ip, path), host, framework.LoadBalancerPollTimeout, t.jig.PollInterval, t.httpClient, false))
+
+	By("keeping track of GCP resources created by Ingress")
+	t.resourceStore = &GCPResourceStore{}
+	t.populateGCPResourceStore(t.resourceStore)
 }
 
 // Test waits for the upgrade to complete, and then verifies
@@ -85,6 +117,8 @@ func (t *IngressUpgradeTest) Test(f *framework.Framework, done <-chan struct{},
 		// while it's down will leak cloud resources, because the ingress
 		// controller doesn't checkpoint to disk.
 		t.verify(f, done, true)
+	case IngressUpgrade:
+		t.verify(f, done, true)
 	default:
 		// Currently ingress gets disrupted across node upgrade, because endpoints
 		// get killed and we don't have any guarantees that 2 nodes don't overlap
@@ -99,6 +133,7 @@ func (t *IngressUpgradeTest) Teardown(f *framework.Framework) {
 	if CurrentGinkgoTestDescription().Failed {
 		framework.DescribeIng(t.gceController.Ns)
 	}
+
 	if t.jig.Ingress != nil {
 		By("Deleting ingress")
 		t.jig.TryDeleteIngress()
@@ -107,19 +142,94 @@ func (t *IngressUpgradeTest) Teardown(f *framework.Framework) {
 	}
 
 	By("Cleaning up cloud resources")
-	framework.CleanupGCEIngressController(t.gceController)
+	framework.ExpectNoError(t.gceController.CleanupGCEIngressController())
 }
 
 func (t *IngressUpgradeTest) verify(f *framework.Framework, done <-chan struct{}, testDuringDisruption bool) {
 	if testDuringDisruption {
 		By("continuously hitting the Ingress IP")
 		wait.Until(func() {
-			framework.ExpectNoError(framework.PollURL(fmt.Sprintf("https://%v/", t.ip), "", framework.LoadBalancerPollTimeout, t.jig.PollInterval, t.httpClient, false))
+			framework.ExpectNoError(framework.PollURL(fmt.Sprintf("https://%v/%v", t.ip, path), host, framework.LoadBalancerPollTimeout, t.jig.PollInterval, t.httpClient, false))
 		}, t.jig.PollInterval, done)
 	} else {
 		By("waiting for upgrade to finish without checking if Ingress remains up")
 		<-done
 	}
 	By("hitting the Ingress IP " + t.ip)
-	framework.ExpectNoError(framework.PollURL(fmt.Sprintf("https://%v/", t.ip), "", framework.LoadBalancerPollTimeout, t.jig.PollInterval, t.httpClient, false))
+	framework.ExpectNoError(framework.PollURL(fmt.Sprintf("https://%v/%v", t.ip, path), host, framework.LoadBalancerPollTimeout, t.jig.PollInterval, t.httpClient, false))
+
+	// We want to manually trigger a sync because then we can easily verify
+	// a correct sync completed after update.
+	By("updating ingress spec to manually trigger a sync")
+	t.jig.Update(func(ing *extensions.Ingress) {
+		ing.Spec.Rules[0].IngressRuleValue.HTTP.Paths = append(
+			ing.Spec.Rules[0].IngressRuleValue.HTTP.Paths,
+			extensions.HTTPIngressPath{
+				Path: "/test",
+				// Note: Dependant on using "static-ip-2" manifest.
+				Backend: ing.Spec.Rules[0].IngressRuleValue.HTTP.Paths[0].Backend,
+			})
+	})
+	// WaitForIngress() tests that all paths are pinged, which is how we know
+	// everything is synced with the cloud.
+	t.jig.WaitForIngress(false)
+	By("comparing GCP resources post-upgrade")
+	postUpgradeResourceStore := &GCPResourceStore{}
+	t.populateGCPResourceStore(postUpgradeResourceStore)
+
+	// Ignore certain fields in compute.Firewall that we know will change
+	// due to the upgrade/downgrade.
+	// TODO(rramkumar): Remove this once glbc 0.9.8 is released.
+	t.resourceStore.Fw.Allowed = nil
+	t.resourceStore.Fw.SourceRanges = nil
+	postUpgradeResourceStore.Fw.Allowed = nil
+	postUpgradeResourceStore.Fw.SourceRanges = nil
+
+	framework.ExpectNoError(compareGCPResourceStores(t.resourceStore, postUpgradeResourceStore, func(v1 reflect.Value, v2 reflect.Value) error {
+		i1 := v1.Interface()
+		i2 := v2.Interface()
+		// Skip verifying the UrlMap since we did that via WaitForIngress()
+		if !reflect.DeepEqual(i1, i2) && (v1.Type() != reflect.TypeOf([]*compute.UrlMap{})) {
+			return spew.Errorf("resources after ingress upgrade were different:\n Pre-Upgrade: %#v\n Post-Upgrade: %#v", i1, i2)
+		}
+		return nil
+	}))
+}
+
+func (t *IngressUpgradeTest) populateGCPResourceStore(resourceStore *GCPResourceStore) {
+	cont := t.gceController
+	resourceStore.Fw = cont.GetFirewallRule()
+	resourceStore.FwdList = cont.ListGlobalForwardingRules()
+	resourceStore.UmList = cont.ListUrlMaps()
+	resourceStore.TpList = cont.ListTargetHttpProxies()
+	resourceStore.TpsList = cont.ListTargetHttpsProxies()
+	resourceStore.SslList = cont.ListSslCertificates()
+	resourceStore.BeList = cont.ListGlobalBackendServices()
+	resourceStore.Ip = cont.GetGlobalAddress(t.ipName)
+	resourceStore.IgList = cont.ListInstanceGroups()
+}
+
+func compareGCPResourceStores(rs1 *GCPResourceStore, rs2 *GCPResourceStore, compare func(v1 reflect.Value, v2 reflect.Value) error) error {
+	// Before we do a comparison, remove the ServerResponse field from the
+	// Compute API structs. This is needed because two objects could be the same
+	// but their ServerResponse will be different if they were populated through
+	// separate API calls.
+	rs1Json, _ := json.Marshal(rs1)
+	rs2Json, _ := json.Marshal(rs2)
+	rs1New := &GCPResourceStore{}
+	rs2New := &GCPResourceStore{}
+	json.Unmarshal(rs1Json, rs1New)
+	json.Unmarshal(rs2Json, rs2New)
+
+	// Iterate through struct fields and perform equality checks on the fields.
+	// We do this rather than performing a deep equal on the struct itself because
+	// it is easier to log which field, if any, is not the same.
+	rs1V := reflect.ValueOf(*rs1New)
+	rs2V := reflect.ValueOf(*rs2New)
+	for i := 0; i < rs1V.NumField(); i++ {
+		if err := compare(rs1V.Field(i), rs2V.Field(i)); err != nil {
+			return err
+		}
+	}
+	return nil
 }

vendor/k8s.io/kubernetes/test/e2e/upgrades/kube_proxy_migration.go

@@ -216,5 +216,5 @@ func getKubeProxyStaticPods(c clientset.Interface) (*v1.PodList, error) {
 func getKubeProxyDaemonSet(c clientset.Interface) (*extensions.DaemonSetList, error) {
 	label := labels.SelectorFromSet(labels.Set(map[string]string{clusterAddonLabelKey: kubeProxyLabelName}))
 	listOpts := metav1.ListOptions{LabelSelector: label.String()}
-	return c.Extensions().DaemonSets(metav1.NamespaceSystem).List(listOpts)
+	return c.ExtensionsV1beta1().DaemonSets(metav1.NamespaceSystem).List(listOpts)
 }

vendor/k8s.io/kubernetes/test/e2e/upgrades/upgrade.go

@@ -40,6 +40,9 @@ const (
 	// EtcdUpgrade indicates that only etcd is being upgraded (or migrated
 	// between storage versions).
 	EtcdUpgrade
+
+	// IngressUpgrade indicates that only ingress is being upgraded.
+	IngressUpgrade
 )
 
 // Test is an interface for upgrade tests.