Add a test that validates ingress routes

Create a new test harness to simplify sending URL requests to running
routers.

Author: smarterclayton

Diff for: test/extended/router/metrics.go

@@ -110,8 +110,8 @@ var _ = g.Describe("[Conformance][Area:Networking][Feature:Router]", func() {
 			o.Expect(err).NotTo(o.HaveOccurred())
 
 			g.By("checking for the expected metrics")
-			routeLabels := labels{"backend": "http", "namespace": ns, "route": "weightedroute"}
-			serverLabels := labels{"namespace": ns, "route": "weightedroute"}
+			routeLabels := promLabels{"backend": "http", "namespace": ns, "route": "weightedroute"}
+			serverLabels := promLabels{"namespace": ns, "route": "weightedroute"}
 			var metrics map[string]*dto.MetricFamily
 			times := 10
 			p := expfmt.TextParser{}
@@ -222,10 +222,10 @@ var _ = g.Describe("[Conformance][Area:Networking][Feature:Router]", func() {
 	})
 })
 
-type labels map[string]string
+type promLabels map[string]string
 
-func (l labels) With(name, value string) labels {
-	n := make(labels)
+func (l promLabels) With(name, value string) promLabels {
+	n := make(promLabels)
 	for k, v := range l {
 		n[k] = v
 	}
@@ -242,48 +242,48 @@ func findEnvVar(vars []kapi.EnvVar, key string) string {
 	return ""
 }
 
-func findMetricsWithLabels(f *dto.MetricFamily, labels map[string]string) []*dto.Metric {
+func findMetricsWithLabels(f *dto.MetricFamily, promLabels map[string]string) []*dto.Metric {
 	var result []*dto.Metric
 	if f == nil {
 		return result
 	}
 	for _, m := range f.Metric {
 		matched := map[string]struct{}{}
 		for _, l := range m.Label {
-			if expect, ok := labels[l.GetName()]; ok {
+			if expect, ok := promLabels[l.GetName()]; ok {
 				if expect != l.GetValue() {
 					break
 				}
 				matched[l.GetName()] = struct{}{}
 			}
 		}
-		if len(matched) != len(labels) {
+		if len(matched) != len(promLabels) {
 			continue
 		}
 		result = append(result, m)
 	}
 	return result
 }
 
-func findCountersWithLabels(f *dto.MetricFamily, labels map[string]string) []float64 {
+func findCountersWithLabels(f *dto.MetricFamily, promLabels map[string]string) []float64 {
 	var result []float64
-	for _, m := range findMetricsWithLabels(f, labels) {
+	for _, m := range findMetricsWithLabels(f, promLabels) {
 		result = append(result, m.Counter.GetValue())
 	}
 	return result
 }
 
-func findGaugesWithLabels(f *dto.MetricFamily, labels map[string]string) []float64 {
+func findGaugesWithLabels(f *dto.MetricFamily, promLabels map[string]string) []float64 {
 	var result []float64
-	for _, m := range findMetricsWithLabels(f, labels) {
+	for _, m := range findMetricsWithLabels(f, promLabels) {
 		result = append(result, m.Gauge.GetValue())
 	}
 	return result
 }
 
-func findMetricLabels(f *dto.MetricFamily, labels map[string]string, match string) []string {
+func findMetricLabels(f *dto.MetricFamily, promLabels map[string]string, match string) []string {
 	var result []string
-	for _, m := range findMetricsWithLabels(f, labels) {
+	for _, m := range findMetricsWithLabels(f, promLabels) {
 		for _, l := range m.Label {
 			if l.GetName() == match {
 				result = append(result, l.GetValue())

Diff for: test/extended/router/router.go

@@ -0,0 +1,111 @@
+package images
+
+import (
+	"net/http"
+	"time"
+
+	g "github.com/onsi/ginkgo"
+	o "github.com/onsi/gomega"
+
+	kapierrs "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/util/wait"
+
+	routev1 "github.com/openshift/api/route/v1"
+	routeclientset "github.com/openshift/client-go/route/clientset/versioned"
+	exutil "github.com/openshift/origin/test/extended/util"
+	"github.com/openshift/origin/test/extended/util/url"
+)
+
+var _ = g.Describe("[Conformance][Area:Networking][Feature:Router]", func() {
+	defer g.GinkgoRecover()
+	var (
+		host, ns string
+		oc       *exutil.CLI
+
+		configPath = exutil.FixturePath("testdata", "ingress.yaml")
+	)
+
+	// this hook must be registered before the framework namespace teardown
+	// hook
+	g.AfterEach(func() {
+		if g.CurrentGinkgoTestDescription().Failed {
+			exutil.DumpPodLogsStartingWithInNamespace("router", "default", oc.AsAdmin())
+			selector, err := labels.Parse("router=router")
+			if err != nil {
+				panic(err)
+			}
+			exutil.DumpPodsCommand(oc.AdminKubeClient(), "default", selector, "cat /var/lib/haproxy/router/routes.json /var/lib//var/lib/haproxy/conf/haproxy.config")
+		}
+	})
+
+	oc = exutil.NewCLI("router-stress", exutil.KubeConfigPath())
+
+	g.BeforeEach(func() {
+		_, err := oc.AdminAppsClient().Apps().DeploymentConfigs("default").Get("router", metav1.GetOptions{})
+		if kapierrs.IsNotFound(err) {
+			g.Skip("no router installed on the cluster")
+			return
+		}
+		o.Expect(err).NotTo(o.HaveOccurred())
+
+		// wait for the router endpoints to show up
+		err = wait.PollImmediate(2*time.Second, 120*time.Second, func() (bool, error) {
+			epts, err := oc.AdminKubeClient().CoreV1().Endpoints("default").Get("router", metav1.GetOptions{})
+			o.Expect(err).NotTo(o.HaveOccurred())
+			if len(epts.Subsets) == 0 || len(epts.Subsets[0].Addresses) == 0 {
+				return false, nil
+			}
+			host = epts.Subsets[0].Addresses[0].IP
+			return true, nil
+		})
+		o.Expect(err).NotTo(o.HaveOccurred())
+
+		ns = oc.KubeFramework().Namespace.Name
+	})
+
+	g.Describe("The HAProxy router", func() {
+		g.It("should respond with 503 to unrecognized hosts", func() {
+			t := url.NewTester(oc.AdminKubeClient(), ns)
+			defer t.Close()
+			t.Within(
+				time.Minute,
+				url.Expect("GET", "https://www.google.com").Through(host).SkipTLSVerification().HasStatusCode(503),
+				url.Expect("GET", "http://www.google.com").Through(host).HasStatusCode(503),
+			)
+		})
+
+		g.It("should serve routes that were created from an ingress", func() {
+			g.By("deploying an ingress rule")
+			err := oc.Run("create").Args("-f", configPath).Execute()
+			o.Expect(err).NotTo(o.HaveOccurred())
+
+			g.By("waiting for the ingress rule to be converted to routes")
+			client := routeclientset.NewForConfigOrDie(oc.AdminConfig())
+			var r []routev1.Route
+			err = wait.Poll(time.Second, time.Minute, func() (bool, error) {
+				routes, err := client.Route().Routes(ns).List(metav1.ListOptions{})
+				if err != nil {
+					return false, err
+				}
+				r = routes.Items
+				return len(routes.Items) == 4, nil
+			})
+			o.Expect(err).NotTo(o.HaveOccurred())
+
+			g.By("verifying the router reports the correct behavior")
+			t := url.NewTester(oc.AdminKubeClient(), ns)
+			defer t.Close()
+			t.Within(
+				3*time.Minute,
+				url.Expect("GET", "http://1.ingress-test.com/test").Through(host).HasStatusCode(200),
+				url.Expect("GET", "http://1.ingress-test.com/other/deep").Through(host).HasStatusCode(200),
+				url.Expect("GET", "http://1.ingress-test.com/").Through(host).HasStatusCode(503),
+				url.Expect("GET", "http://2.ingress-test.com/").Through(host).HasStatusCode(200),
+				url.Expect("GET", "https://3.ingress-test.com/").Through(host).SkipTLSVerification().HasStatusCode(200),
+				url.Expect("GET", "http://3.ingress-test.com/").Through(host).RedirectsTo("https://3.ingress-test.com/", http.StatusFound),
+			)
+		})
+	})
+})