GitList

Browse code

Have routers take ownership of routes

When a router sees a route, it should make a decision about the name it
wishes to assign to that route (based on its override-hostname or own
settings) and then write the decision back to the route status with an
effective host value (so clients can see what the actual route value
is). If multiple routers attempt to make conflicting writes, have them
remember the conflict so as to avoid battles as they race to the new
value. Errors due to route uniqueness are also written back to the
status.

Each route has an array of RouteIngress structs, which contain an array
of conditions, the routerName (passed via --name to the router), and the
effective host.

Add printers and describers, make ingress empty be a special case.

Clayton Coleman authored on 2015/09/09 05:49:34
Showing 26 changed files

api/swagger-spec/oapi-v1.json index 879cd02..4e5d3b3 100644
contrib/completions/bash/openshift index 72ac50a..fdc1e55 100644
hack/api-description-whitelist.txt index 8a921cc..bbae2da 100644
pkg/api/deep_copy_generated.go index 7524663..008a307 100644
pkg/api/v1/conversion_generated.go index 1d72187..66c0c3f 100644
pkg/api/v1/deep_copy_generated.go index f5f8daa..3d08938 100644
pkg/api/v1beta3/conversion_generated.go index fb2bde3..4737410 100644
pkg/api/v1beta3/deep_copy_generated.go index f448ec2..6fd108a 100644
pkg/client/routes.go index 0f14a18..454a6f3 100644
pkg/client/testclient/fake.go index 836a32e..507622f 100644
pkg/client/testclient/fake_routes.go index 3823a23..c2ba26b 100644
pkg/cmd/cli/describe/describer.go index f73d0d6..b9f7936 100644
pkg/cmd/cli/describe/printer.go index e9a7818..b38cb9c 100644
pkg/cmd/infra/router/f5.go index c798106..491640a 100644
pkg/cmd/infra/router/template.go index a4b3b90..c4587b7 100644
pkg/cmd/server/bootstrappolicy/policy.go index fbd1624..0bd8bc3 100644
pkg/route/api/types.go index cacf392..2e9bcb8 100644
pkg/route/api/v1/types.go index d5d7d0c..626c3b9 100644
pkg/route/api/v1beta3/types.go index d10c109..8dc1929 100644
pkg/route/registry/route/etcd/etcd.go index af89381..2d969ed 100644
pkg/router/controller/status.go index 0000000..13b1f50
pkg/router/controller/status_test.go index 0000000..ececef0
pkg/router/controller/unique_host.go index f6e4356..3b316e1 100644
plugins/router/template/plugin_test.go index f72447c..8d0484c 100644
test/fixtures/bootstrappolicy/bootstrap_cluster_roles.yaml index 59e49a8..3cf449e 100644
test/integration/router/router_http_server.go index b797ca2..732521f 100644

@@ -21971,7 +21971,67 @@
                         },
                         "v1.RouteStatus": {
                          "id": "v1.RouteStatus",
                     -    "properties": {}
                     +    "required": [
                     +     "ingress"
                     +    ],
                     +    "properties": {
                     +     "ingress": {
                     +      "type": "array",
                     +      "items": {
                     +       "$ref": "v1.RouteIngress"
                     +      },
                     +      "description": "traffic reaches this route via these ingress paths"
                     +     }
                     +    }
                     +   },
                     +   "v1.RouteIngress": {
                     +    "id": "v1.RouteIngress",
                     +    "properties": {
                     +     "host": {
                     +      "type": "string",
                     +      "description": "the host name this route is exposed to by the specified router"
                     +     },
                     +     "routerName": {
                     +      "type": "string",
                     +      "description": "the name of the router exposing this route"
                     +     },
                     +     "conditions": {
                     +      "type": "array",
                     +      "items": {
                     +       "$ref": "v1.RouteIngressCondition"
                     +      },
                     +      "description": "the conditions that apply to this router"
                     +     }
                     +    }
                     +   },
                     +   "v1.RouteIngressCondition": {
                     +    "id": "v1.RouteIngressCondition",
                     +    "required": [
                     +     "type",
                     +     "status"
                     +    ],
                     +    "properties": {
                     +     "type": {
                     +      "type": "string",
                     +      "description": "the type of the condition"
                     +     },
                     +     "status": {
                     +      "type": "string",
                     +      "description": "status is the status of the condition; True, False, or Unknown"
                     +     },
                     +     "reason": {
                     +      "type": "string",
                     +      "description": "brief reason for the condition's last transition, machine readable constant"
                     +     },
                     +     "message": {
                     +      "type": "string",
                     +      "description": "human readable message indicating details about this condition"
                     +     },
                     +     "lastTransitionTime": {
                     +      "type": "string",
                     +      "description": "the last time at which this condition transitioned to the current status"
                     +     }
                     +    }
                         },
                         "v1.SubjectAccessReview": {
                          "id": "v1.SubjectAccessReview",

@@ -17675,6 +17675,7 @@ _openshift_infra_router()
                          flags+=("--kubernetes=")
                          flags+=("--labels=")
                          flags+=("--master=")
                     +    flags+=("--name=")
                          flags+=("--namespace=")
                          two_word_flags+=("-n")
                          flags+=("--namespace-labels=")
@@ -17755,6 +17756,7 @@ _openshift_infra_f5-router()
                          flags+=("--kubernetes=")
                          flags+=("--labels=")
                          flags+=("--master=")
                     +    flags+=("--name=")
                          flags+=("--namespace=")
                          two_word_flags+=("-n")
                          flags+=("--namespace-labels=")

@@ -197,6 +197,8 @@ v1.routelist
                      v1.routeport
                      v1.routespec
                      v1.routestatus
                     +v1.routeingress
                     +v1.routeingresscondition
                      v1.runasuserstrategyoptions
                      v1.secret
                      v1.secretlist

@@ -2717,6 +2717,39 @@ func deepCopy_api_Route(in routeapi.Route, out *routeapi.Route, c *conversion.Cl
                      	return nil
+                     }
                     +func deepCopy_api_RouteIngress(in routeapi.RouteIngress, out *routeapi.RouteIngress, c *conversion.Cloner) error {
                     +	out.Host = in.Host
                     +	out.RouterName = in.RouterName
                     +	if in.Conditions != nil {
                     +		out.Conditions = make([]routeapi.RouteIngressCondition, len(in.Conditions))
                     +		for i := range in.Conditions {
                     +			if err := deepCopy_api_RouteIngressCondition(in.Conditions[i], &out.Conditions[i], c); err != nil {
                     +				return err
                     +			}
                     +		}
                     +	} else {
                     +		out.Conditions = nil
                     +	}
                     +	return nil
                     +}
+                    +
                     +func deepCopy_api_RouteIngressCondition(in routeapi.RouteIngressCondition, out *routeapi.RouteIngressCondition, c *conversion.Cloner) error {
                     +	out.Type = in.Type
                     +	out.Status = in.Status
                     +	out.Reason = in.Reason
                     +	out.Message = in.Message
                     +	if in.LastTransitionTime != nil {
                     +		if newVal, err := c.DeepCopy(in.LastTransitionTime); err != nil {
                     +			return err
                     +		} else {
                     +			out.LastTransitionTime = newVal.(*unversioned.Time)
                     +		}
                     +	} else {
                     +		out.LastTransitionTime = nil
                     +	}
                     +	return nil
                     +}
+                    +
                      func deepCopy_api_RouteList(in routeapi.RouteList, out *routeapi.RouteList, c *conversion.Cloner) error {
                      	if newVal, err := c.DeepCopy(in.TypeMeta); err != nil {
                      		return err
@@ -2778,6 +2811,16 @@ func deepCopy_api_RouteSpec(in routeapi.RouteSpec, out *routeapi.RouteSpec, c *c
+                     }
                      func deepCopy_api_RouteStatus(in routeapi.RouteStatus, out *routeapi.RouteStatus, c *conversion.Cloner) error {
                     +	if in.Ingress != nil {
                     +		out.Ingress = make([]routeapi.RouteIngress, len(in.Ingress))
                     +		for i := range in.Ingress {
                     +			if err := deepCopy_api_RouteIngress(in.Ingress[i], &out.Ingress[i], c); err != nil {
                     +				return err
                     +			}
                     +		}
                     +	} else {
                     +		out.Ingress = nil
                     +	}
                      	return nil
+                     }
@@ -3287,6 +3330,8 @@ func init() {
                      		deepCopy_api_ProjectSpec,
                      		deepCopy_api_ProjectStatus,
                      		deepCopy_api_Route,
                     +		deepCopy_api_RouteIngress,
                     +		deepCopy_api_RouteIngressCondition,
                      		deepCopy_api_RouteList,
                      		deepCopy_api_RoutePort,
                      		deepCopy_api_RouteSpec,

@@ -5026,6 +5026,53 @@ func Convert_api_Route_To_v1_Route(in *routeapi.Route, out *routeapiv1.Route, s
                      	return autoConvert_api_Route_To_v1_Route(in, out, s)
+                     }
                     +func autoConvert_api_RouteIngress_To_v1_RouteIngress(in *routeapi.RouteIngress, out *routeapiv1.RouteIngress, s conversion.Scope) error {
                     +	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
                     +		defaulting.(func(*routeapi.RouteIngress))(in)
                     +	}
                     +	out.Host = in.Host
                     +	out.RouterName = in.RouterName
                     +	if in.Conditions != nil {
                     +		out.Conditions = make([]routeapiv1.RouteIngressCondition, len(in.Conditions))
                     +		for i := range in.Conditions {
                     +			if err := Convert_api_RouteIngressCondition_To_v1_RouteIngressCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
                     +				return err
                     +			}
                     +		}
                     +	} else {
                     +		out.Conditions = nil
                     +	}
                     +	return nil
                     +}
+                    +
                     +func Convert_api_RouteIngress_To_v1_RouteIngress(in *routeapi.RouteIngress, out *routeapiv1.RouteIngress, s conversion.Scope) error {
                     +	return autoConvert_api_RouteIngress_To_v1_RouteIngress(in, out, s)
                     +}
+                    +
                     +func autoConvert_api_RouteIngressCondition_To_v1_RouteIngressCondition(in *routeapi.RouteIngressCondition, out *routeapiv1.RouteIngressCondition, s conversion.Scope) error {
                     +	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
                     +		defaulting.(func(*routeapi.RouteIngressCondition))(in)
                     +	}
                     +	out.Type = routeapiv1.RouteIngressConditionType(in.Type)
                     +	out.Status = apiv1.ConditionStatus(in.Status)
                     +	out.Reason = in.Reason
                     +	out.Message = in.Message
                     +	// unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
                     +	if in.LastTransitionTime != nil {
                     +		out.LastTransitionTime = new(unversioned.Time)
                     +		if err := api.Convert_unversioned_Time_To_unversioned_Time(in.LastTransitionTime, out.LastTransitionTime, s); err != nil {
                     +			return err
                     +		}
                     +	} else {
                     +		out.LastTransitionTime = nil
                     +	}
                     +	return nil
                     +}
+                    +
                     +func Convert_api_RouteIngressCondition_To_v1_RouteIngressCondition(in *routeapi.RouteIngressCondition, out *routeapiv1.RouteIngressCondition, s conversion.Scope) error {
                     +	return autoConvert_api_RouteIngressCondition_To_v1_RouteIngressCondition(in, out, s)
                     +}
+                    +
                      func autoConvert_api_RouteList_To_v1_RouteList(in *routeapi.RouteList, out *routeapiv1.RouteList, s conversion.Scope) error {
                      	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
                      		defaulting.(func(*routeapi.RouteList))(in)
@@ -5102,6 +5149,16 @@ func autoConvert_api_RouteStatus_To_v1_RouteStatus(in *routeapi.RouteStatus, out
                      	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
                      		defaulting.(func(*routeapi.RouteStatus))(in)
+                     	}
                     +	if in.Ingress != nil {
                     +		out.Ingress = make([]routeapiv1.RouteIngress, len(in.Ingress))
                     +		for i := range in.Ingress {
                     +			if err := Convert_api_RouteIngress_To_v1_RouteIngress(&in.Ingress[i], &out.Ingress[i], s); err != nil {
                     +				return err
                     +			}
                     +		}
                     +	} else {
                     +		out.Ingress = nil
                     +	}
                      	return nil
+                     }
@@ -5146,6 +5203,53 @@ func Convert_v1_Route_To_api_Route(in *routeapiv1.Route, out *routeapi.Route, s
                      	return autoConvert_v1_Route_To_api_Route(in, out, s)
+                     }
                     +func autoConvert_v1_RouteIngress_To_api_RouteIngress(in *routeapiv1.RouteIngress, out *routeapi.RouteIngress, s conversion.Scope) error {
                     +	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
                     +		defaulting.(func(*routeapiv1.RouteIngress))(in)
                     +	}
                     +	out.Host = in.Host
                     +	out.RouterName = in.RouterName
                     +	if in.Conditions != nil {
                     +		out.Conditions = make([]routeapi.RouteIngressCondition, len(in.Conditions))
                     +		for i := range in.Conditions {
                     +			if err := Convert_v1_RouteIngressCondition_To_api_RouteIngressCondition(&in.Conditions[i], &out.Conditions[i], s); err != nil {
                     +				return err
                     +			}
                     +		}
                     +	} else {
                     +		out.Conditions = nil
                     +	}
                     +	return nil
                     +}
+                    +
                     +func Convert_v1_RouteIngress_To_api_RouteIngress(in *routeapiv1.RouteIngress, out *routeapi.RouteIngress, s conversion.Scope) error {
                     +	return autoConvert_v1_RouteIngress_To_api_RouteIngress(in, out, s)
                     +}
+                    +
                     +func autoConvert_v1_RouteIngressCondition_To_api_RouteIngressCondition(in *routeapiv1.RouteIngressCondition, out *routeapi.RouteIngressCondition, s conversion.Scope) error {
                     +	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
                     +		defaulting.(func(*routeapiv1.RouteIngressCondition))(in)
                     +	}
                     +	out.Type = routeapi.RouteIngressConditionType(in.Type)
                     +	out.Status = api.ConditionStatus(in.Status)
                     +	out.Reason = in.Reason
                     +	out.Message = in.Message
                     +	// unable to generate simple pointer conversion for unversioned.Time -> unversioned.Time
                     +	if in.LastTransitionTime != nil {
                     +		out.LastTransitionTime = new(unversioned.Time)
                     +		if err := api.Convert_unversioned_Time_To_unversioned_Time(in.LastTransitionTime, out.LastTransitionTime, s); err != nil {
                     +			return err
                     +		}
                     +	} else {
                     +		out.LastTransitionTime = nil
                     +	}
                     +	return nil
                     +}
+                    +
                     +func Convert_v1_RouteIngressCondition_To_api_RouteIngressCondition(in *routeapiv1.RouteIngressCondition, out *routeapi.RouteIngressCondition, s conversion.Scope) error {
                     +	return autoConvert_v1_RouteIngressCondition_To_api_RouteIngressCondition(in, out, s)
                     +}
+                    +
                      func autoConvert_v1_RouteList_To_api_RouteList(in *routeapiv1.RouteList, out *routeapi.RouteList, s conversion.Scope) error {
                      	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
                      		defaulting.(func(*routeapiv1.RouteList))(in)
@@ -5222,6 +5326,16 @@ func autoConvert_v1_RouteStatus_To_api_RouteStatus(in *routeapiv1.RouteStatus, o
                      	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
                      		defaulting.(func(*routeapiv1.RouteStatus))(in)
+                     	}
                     +	if in.Ingress != nil {
                     +		out.Ingress = make([]routeapi.RouteIngress, len(in.Ingress))
                     +		for i := range in.Ingress {
                     +			if err := Convert_v1_RouteIngress_To_api_RouteIngress(&in.Ingress[i], &out.Ingress[i], s); err != nil {
                     +				return err
                     +			}
                     +		}
                     +	} else {
                     +		out.Ingress = nil
                     +	}
                      	return nil
+                     }
@@ -8444,6 +8558,8 @@ func init() {
                      		autoConvert_api_RoleList_To_v1_RoleList,
                      		autoConvert_api_Role_To_v1_Role,
                      		autoConvert_api_RollingDeploymentStrategyParams_To_v1_RollingDeploymentStrategyParams,
                     +		autoConvert_api_RouteIngressCondition_To_v1_RouteIngressCondition,
                     +		autoConvert_api_RouteIngress_To_v1_RouteIngress,
                      		autoConvert_api_RouteList_To_v1_RouteList,
                      		autoConvert_api_RoutePort_To_v1_RoutePort,
                      		autoConvert_api_RouteSpec_To_v1_RouteSpec,
@@ -8613,6 +8729,8 @@ func init() {
                      		autoConvert_v1_RoleList_To_api_RoleList,
                      		autoConvert_v1_Role_To_api_Role,
                      		autoConvert_v1_RollingDeploymentStrategyParams_To_api_RollingDeploymentStrategyParams,
                     +		autoConvert_v1_RouteIngressCondition_To_api_RouteIngressCondition,
                     +		autoConvert_v1_RouteIngress_To_api_RouteIngress,
                      		autoConvert_v1_RouteList_To_api_RouteList,
                      		autoConvert_v1_RoutePort_To_api_RoutePort,
                      		autoConvert_v1_RouteSpec_To_api_RouteSpec,

@@ -18,6 +18,7 @@ type RouteInterface interface {
                      	Get(name string) (*routeapi.Route, error)
                      	Create(route *routeapi.Route) (*routeapi.Route, error)
                      	Update(route *routeapi.Route) (*routeapi.Route, error)
                     +	UpdateStatus(route *routeapi.Route) (*routeapi.Route, error)
                      	Delete(name string) error
                      	Watch(opts kapi.ListOptions) (watch.Interface, error)
+                     }
@@ -74,6 +75,13 @@ func (c *routes) Update(route *routeapi.Route) (result *routeapi.Route, err erro
                      	return
+                     }
                     +// UpdateStatus takes the route with altered status.  Returns the server's representation of the route, and an error, if it occurs.
                     +func (c *routes) UpdateStatus(route *routeapi.Route) (result *routeapi.Route, err error) {
                     +	result = &routeapi.Route{}
                     +	err = c.r.Put().Namespace(c.ns).Resource("routes").Name(route.Name).SubResource("status").Body(route).Do().Into(result)
                     +	return
                     +}
+                    +
                      // Watch returns a watch.Interface that watches the requested routes.
                      func (c *routes) Watch(opts kapi.ListOptions) (watch.Interface, error) {
                      	return c.r.Get().

@@ -9,6 +9,7 @@ import (
                      	"k8s.io/kubernetes/pkg/runtime"
                      	"k8s.io/kubernetes/pkg/watch"
                     +	_ "github.com/openshift/origin/pkg/api/install"
                      	"github.com/openshift/origin/pkg/client"
+                     )

@@ -51,6 +51,17 @@ func (c *FakeRoutes) Update(inObj *routeapi.Route) (*routeapi.Route, error) {
                      	return obj.(*routeapi.Route), err
+                     }
                     +func (c *FakeRoutes) UpdateStatus(inObj *routeapi.Route) (*routeapi.Route, error) {
                     +	action := ktestclient.NewUpdateAction("routes", c.Namespace, inObj)
                     +	action.Subresource = "status"
                     +	obj, err := c.Fake.Invokes(action, inObj)
                     +	if obj == nil {
                     +		return nil, err
                     +	}
+                    +
                     +	return obj.(*routeapi.Route), err
                     +}
+                    +
                      func (c *FakeRoutes) Delete(name string) error {
                      	_, err := c.Fake.Invokes(ktestclient.NewDeleteAction("routes", c.Namespace, name), &routeapi.Route{})
                      	return err

@@ -595,9 +595,56 @@ func (d *RouteDescriber) Describe(namespace, name string) (string, error) {
                      	return tabbedString(func(out *tabwriter.Writer) error {
                      		formatMeta(out, route.ObjectMeta)
                     -		formatString(out, "Host", route.Spec.Host)
                     +		if len(route.Spec.Host) > 0 {
                     +			formatString(out, "Requested Host", route.Spec.Host)
                     +			for _, ingress := range route.Status.Ingress {
                     +				if route.Spec.Host != ingress.Host {
                     +					continue
                     +				}
                     +				switch status, condition := ingressConditionStatus(&ingress, routeapi.RouteAdmitted); status {
                     +				case kapi.ConditionTrue:
                     +					fmt.Fprintf(out, "\t  exposed on router %s %s ago\n", ingress.RouterName, strings.ToLower(formatRelativeTime(condition.LastTransitionTime.Time)))
                     +				case kapi.ConditionFalse:
                     +					fmt.Fprintf(out, "\t  rejected by router %s: %s (%s ago)\n", ingress.RouterName, condition.Reason, strings.ToLower(formatRelativeTime(condition.LastTransitionTime.Time)))
                     +					if len(condition.Message) > 0 {
                     +						fmt.Fprintf(out, "\t    %s\n", condition.Message)
                     +					}
                     +				}
                     +			}
                     +		} else {
                     +			formatString(out, "Requested Host", "<auto>")
                     +		}
                     +		for _, ingress := range route.Status.Ingress {
                     +			if route.Spec.Host == ingress.Host {
                     +				continue
                     +			}
                     +			switch status, condition := ingressConditionStatus(&ingress, routeapi.RouteAdmitted); status {
                     +			case kapi.ConditionTrue:
                     +				fmt.Fprintf(out, "\t%s exposed on router %s %s ago\n", ingress.Host, ingress.RouterName, strings.ToLower(formatRelativeTime(condition.LastTransitionTime.Time)))
                     +			case kapi.ConditionFalse:
                     +				fmt.Fprintf(out, "\trejected by router %s: %s (%s ago)\n", ingress.RouterName, condition.Reason, strings.ToLower(formatRelativeTime(condition.LastTransitionTime.Time)))
                     +				if len(condition.Message) > 0 {
                     +					fmt.Fprintf(out, "\t  %s\n", condition.Message)
                     +				}
                     +			}
                     +		}
                      		formatString(out, "Path", route.Spec.Path)
+                    +
                     +		tlsTerm := ""
                     +		insecurePolicy := ""
                     +		if route.Spec.TLS != nil {
                     +			tlsTerm = string(route.Spec.TLS.Termination)
                     +			insecurePolicy = string(route.Spec.TLS.InsecureEdgeTerminationPolicy)
                     +		}
                     +		formatString(out, "TLS Termination", tlsTerm)
                     +		formatString(out, "Insecure Policy", insecurePolicy)
+                    +
                      		formatString(out, "Service", route.Spec.To.Name)
                     +		if route.Spec.Port != nil {
                     +			formatString(out, "Endpoint Port", route.Spec.Port.TargetPort.String())
                     +		} else {
                     +			formatString(out, "Endpoint Port", "<all endpoint ports>")
                     +		}
                      		ends := "<none>"
                      		if endsErr != nil {
@@ -619,21 +666,12 @@ func (d *RouteDescriber) Describe(namespace, name string) (string, error) {
+                     					}
+                     				}
+                     			}
                     -			ends = strings.Join(list, ",")
                     +			ends = strings.Join(list, ", ")
                      			if count > max {
                      				ends += fmt.Sprintf(" + %d more...", count-max)
+                     			}
+                     		}
                      		formatString(out, "Endpoints", ends)
+                    -
                     -		tlsTerm := ""
                     -		insecurePolicy := ""
                     -		if route.Spec.TLS != nil {
                     -			tlsTerm = string(route.Spec.TLS.Termination)
                     -			insecurePolicy = string(route.Spec.TLS.InsecureEdgeTerminationPolicy)
                     -		}
                     -		formatString(out, "TLS Termination", tlsTerm)
                     -		formatString(out, "Insecure Policy", insecurePolicy)
                      		return nil
                      	})
+                     }

@@ -9,6 +9,7 @@ import (
                      	"text/tabwriter"
                      	"time"
                     +	kapi "k8s.io/kubernetes/pkg/api"
                      	"k8s.io/kubernetes/pkg/api/unversioned"
                      	kctl "k8s.io/kubernetes/pkg/kubectl"
                      	"k8s.io/kubernetes/pkg/labels"
@@ -34,7 +35,7 @@ var (
                      	imageStreamImageColumns = []string{"NAME", "DOCKER REF", "UPDATED", "IMAGENAME"}
                      	imageStreamColumns      = []string{"NAME", "DOCKER REPO", "TAGS", "UPDATED"}
                      	projectColumns          = []string{"NAME", "DISPLAY NAME", "STATUS"}
                     -	routeColumns            = []string{"NAME", "HOST/PORT", "PATH", "SERVICE", "LABELS", "INSECURE POLICY", "TLS TERMINATION"}
                     +	routeColumns            = []string{"NAME", "HOST/PORT", "PATH", "SERVICE", "TERMINATION", "LABELS"}
                      	deploymentColumns       = []string{"NAME", "STATUS", "CAUSE"}
                      	deploymentConfigColumns = []string{"NAME", "REVISION", "REPLICAS", "TRIGGERED BY"}
                      	templateColumns         = []string{"NAME", "DESCRIPTION", "PARAMETERS", "OBJECTS"}
@@ -425,6 +426,16 @@ func printProjectList(projects *projectapi.ProjectList, w io.Writer, opts kctl.P
                      	return nil
+                     }
                     +func ingressConditionStatus(ingress *routeapi.RouteIngress, t routeapi.RouteIngressConditionType) (kapi.ConditionStatus, routeapi.RouteIngressCondition) {
                     +	for _, condition := range ingress.Conditions {
                     +		if t != condition.Type {
                     +			continue
                     +		}
                     +		return condition.Status, condition
                     +	}
                     +	return kapi.ConditionUnknown, routeapi.RouteIngressCondition{}
                     +}
+                    +
                      func printRoute(route *routeapi.Route, w io.Writer, opts kctl.PrintOptions) error {
                      	tlsTerm := ""
                      	insecurePolicy := ""
@@ -437,8 +448,57 @@ func printRoute(route *routeapi.Route, w io.Writer, opts kctl.PrintOptions) erro
                      			return err
+                     		}
+                     	}
                     -	_, err := fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
                     -		route.Name, route.Spec.Host, route.Spec.Path, route.Spec.To.Name, labels.Set(route.Labels), insecurePolicy, tlsTerm)
                     +	var (
                     +		matchedHost bool
                     +		reason      string
                     +		host        = route.Spec.Host
+                    +
                     +		admitted, errors = 0, 0
                     +	)
                     +	for _, ingress := range route.Status.Ingress {
                     +		switch status, condition := ingressConditionStatus(&ingress, routeapi.RouteAdmitted); status {
                     +		case kapi.ConditionTrue:
                     +			admitted++
                     +			if !matchedHost {
                     +				matchedHost = ingress.Host == route.Spec.Host
                     +				host = ingress.Host
                     +			}
                     +		case kapi.ConditionFalse:
                     +			reason = condition.Reason
                     +			errors++
                     +		}
                     +	}
                     +	switch {
                     +	case route.Status.Ingress == nil:
                     +		// this is the legacy case, we should continue to show the host when talking to servers
                     +		// that have not set status ingress, since we can't distinguish this condition from there
                     +		// being no routers.
                     +	case admitted == 0 && errors > 0:
                     +		host = reason
                     +	case errors > 0:
                     +		host = fmt.Sprintf("%s ... %d rejected", host, errors)
                     +	case admitted == 0:
                     +		host = "Pending"
                     +	case admitted > 1:
                     +		host = fmt.Sprintf("%s ... %d more", host, admitted-1)
                     +	}
                     +	var policy string
                     +	switch {
                     +	case len(tlsTerm) != 0 && len(insecurePolicy) != 0:
                     +		policy = fmt.Sprintf("%s/%s", tlsTerm, insecurePolicy)
                     +	case len(tlsTerm) != 0:
                     +		policy = tlsTerm
                     +	case len(insecurePolicy) != 0:
                     +		policy = fmt.Sprintf("default/%s", insecurePolicy)
                     +	default:
                     +		policy = ""
                     +	}
                     +	svc := route.Spec.To.Name
                     +	if route.Spec.Port != nil {
                     +		svc = fmt.Sprintf("%s:%s", svc, route.Spec.Port.TargetPort.String())
                     +	}
                     +	_, err := fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\n",
                     +		route.Name, host, route.Spec.Path, svc, policy, labels.Set(route.Labels))
                      	return err
+                     }

@@ -40,6 +40,8 @@ type F5RouterOptions struct {
                      // F5Router is the config necessary to start an F5 router plugin.
                      type F5Router struct {
                     +	RouterName string
+                    +
                      	// Host specifies the hostname or IP address of the F5 BIG-IP host.
                      	Host string
@@ -76,6 +78,7 @@ type F5Router struct {
                      // Bind binds F5Router arguments to flags
                      func (o *F5Router) Bind(flag *pflag.FlagSet) {
                     +	flag.StringVar(&o.RouterName, "name", util.Env("ROUTER_SERVICE_NAME", "public"), "The name the router will identify itself with in the route status")
                      	flag.StringVar(&o.Host, "f5-host", util.Env("ROUTER_EXTERNAL_HOST_HOSTNAME", ""), "The host of F5 BIG-IP's management interface")
                      	flag.StringVar(&o.Username, "f5-username", util.Env("ROUTER_EXTERNAL_HOST_USERNAME", ""), "The username for F5 BIG-IP's management utility")
                      	flag.StringVar(&o.Password, "f5-password", util.Env("ROUTER_EXTERNAL_HOST_PASSWORD", ""), "The password for F5 BIG-IP's management utility")
@@ -167,13 +170,14 @@ func (o *F5RouterOptions) Run() error {
                      		return err
+                     	}
                     -	plugin := controller.NewUniqueHost(f5Plugin, o.RouteSelectionFunc())
+                    -
                      	oc, kc, err := o.Config.Clients()
                      	if err != nil {
                      		return err
+                     	}
                     +	statusPlugin := controller.NewStatusAdmitter(f5Plugin, oc, o.RouterName)
                     +	plugin := controller.NewUniqueHost(statusPlugin, o.RouteSelectionFunc(), statusPlugin)
+                    +
                      	factory := o.RouterSelection.NewFactory(oc, kc)
                      	controller := factory.Create(plugin)
                      	controller.Run()

@@ -45,6 +45,7 @@ type TemplateRouterOptions struct {
+                     }
                      type TemplateRouter struct {
                     +	RouterName         string
                      	WorkingDir         string
                      	TemplateFile       string
                      	ReloadScript       string
@@ -54,6 +55,7 @@ type TemplateRouter struct {
+                     }
                      func (o *TemplateRouter) Bind(flag *pflag.FlagSet) {
                     +	flag.StringVar(&o.RouterName, "name", util.Env("ROUTER_SERVICE_NAME", "public"), "The name the router will identify itself with in the route status")
                      	flag.StringVar(&o.WorkingDir, "working-dir", "/var/lib/containers/router", "The working directory for the router plugin")
                      	flag.StringVar(&o.DefaultCertificate, "default-certificate", util.Env("DEFAULT_CERTIFICATE", ""), "A path to default certificate to use for routes that don't expose a TLS server cert; in PEM format")
                      	flag.StringVar(&o.TemplateFile, "template", util.Env("TEMPLATE_FILE", ""), "The path to the template file to use")
@@ -139,6 +141,9 @@ func (o *TemplateRouterOptions) Complete() error {
+                     }
                      func (o *TemplateRouterOptions) Validate() error {
                     +	if len(o.RouterName) == 0 {
                     +		return errors.New("router must have a name to identify itself in route status")
                     +	}
                      	if len(o.TemplateFile) == 0 {
                      		return errors.New("template file must be specified")
+                     	}
@@ -169,13 +174,14 @@ func (o *TemplateRouterOptions) Run() error {
                      		return err
+                     	}
                     -	plugin := controller.NewUniqueHost(templatePlugin, o.RouteSelectionFunc())
+                    -
                      	oc, kc, err := o.Config.Clients()
                      	if err != nil {
                      		return err
+                     	}
                     +	statusPlugin := controller.NewStatusAdmitter(templatePlugin, oc, o.RouterName)
                     +	plugin := controller.NewUniqueHost(statusPlugin, o.RouteSelectionFunc(), statusPlugin)
+                    +
                      	factory := o.RouterSelection.NewFactory(oc, kc)
                      	controller := factory.Create(plugin)
                      	controller.Run()

@@ -117,6 +117,11 @@ func GetBootstrapClusterRoles() []authorizationapi.ClusterRole {
                      					// this is used by verifyImageStreamAccess in pkg/dockerregistry/server/auth.go
                      					Resources: sets.NewString("imagestreams/layers"),
                      				},
                     +				// an admin can run routers that write back conditions to the route
                     +				{
                     +					Verbs:     sets.NewString("update"),
                     +					Resources: sets.NewString("routes/status"),
                     +				},
                      			},
                      		},
+                     		{
@@ -323,6 +328,11 @@ func GetBootstrapClusterRoles() []authorizationapi.ClusterRole {
                      					Verbs:     sets.NewString("list", "watch"),
                      					Resources: sets.NewString("routes", "endpoints"),
                      				},
                     +				// routers write back conditions to the route
                     +				{
                     +					Verbs:     sets.NewString("update"),
                     +					Resources: sets.NewString("routes/status"),
                     +				},
                      			},
                      		},
+                     		{

@@ -49,6 +49,49 @@ type RoutePort struct {
                      // RouteStatus provides relevant info about the status of a route, including which routers
                      // acknowledge it.
                      type RouteStatus struct {
                     +	// Ingress describes the places where the route may be exposed. The list of
                     +	// ingress points may contain duplicate Host or RouterName values. Routes
                     +	// are considered live once they are `Ready`
                     +	Ingress []RouteIngress
                     +}
+                    +
                     +// RouteIngress holds information about the places where a route is exposed
                     +type RouteIngress struct {
                     +	// Host is the host string under which the route is exposed; this value is required
                     +	Host string
                     +	// Name is a name chosen by the router to identify itself; this value is required
                     +	RouterName string
                     +	// Conditions is the state of the route, may be empty.
                     +	Conditions []RouteIngressCondition
                     +}
+                    +
                     +// RouteIngressConditionType is a valid value for RouteCondition
                     +type RouteIngressConditionType string
+                    +
                     +// These are valid conditions of pod.
                     +const (
                     +	// RouteAdmitted means the route is able to service requests for the provided Host
                     +	RouteAdmitted RouteIngressConditionType = "Admitted"
                     +	// TODO: add other route condition types
                     +)
+                    +
                     +// RouteIngressCondition contains details for the current condition of this pod.
                     +// TODO: add LastTransitionTime, Reason, Message to match NodeCondition api.
                     +type RouteIngressCondition struct {
                     +	// Type is the type of the condition.
                     +	// Currently only Ready.
                     +	Type RouteIngressConditionType
                     +	// Status is the status of the condition.
                     +	// Can be True, False, Unknown.
                     +	Status kapi.ConditionStatus
                     +	// (brief) reason for the condition's last transition, and is usually a machine and human
                     +	// readable constant
                     +	Reason string
                     +	// Human readable message indicating details about last transition.
                     +	Message string
                     +	// RFC 3339 date and time at which the object was acknowledged by the router.
                     +	// This may be before the router exposes the route
                     +	LastTransitionTime *unversioned.Time
+                     }
                      // RouteList is a collection of Routes.

@@ -46,7 +46,10 @@ func NewREST(s storage.Interface, allocator route.RouteAllocator) (*REST, *Statu
                      		Storage: s,
+                     	}
                     -	return &REST{store}, &StatusREST{store}
                     +	statusStore := *store
                     +	statusStore.UpdateStrategy = rest.StatusStrategy
+                    +
                     +	return &REST{store}, &StatusREST{&statusStore}
+                     }
                      // StatusREST implements the REST endpoint for changing the status of a route.

                     new file mode 100644
@@ -0,0 +1,238 @@
                     +package controller
+                    +
                     +import (
                     +	"fmt"
                     +	"time"
+                    +
                     +	"github.com/golang/glog"
                     +	lru "github.com/hashicorp/golang-lru"
+                    +
                     +	kapi "k8s.io/kubernetes/pkg/api"
                     +	"k8s.io/kubernetes/pkg/api/errors"
                     +	"k8s.io/kubernetes/pkg/api/unversioned"
                     +	"k8s.io/kubernetes/pkg/util"
                     +	"k8s.io/kubernetes/pkg/util/sets"
                     +	"k8s.io/kubernetes/pkg/watch"
+                    +
                     +	"github.com/openshift/origin/pkg/client"
                     +	routeapi "github.com/openshift/origin/pkg/route/api"
                     +	"github.com/openshift/origin/pkg/router"
                     +)
+                    +
                     +// StatusAdmitter ensures routes added to the plugin have status set.
                     +type StatusAdmitter struct {
                     +	plugin     router.Plugin
                     +	client     client.RoutesNamespacer
                     +	routerName string
+                    +
                     +	contentionInterval time.Duration
                     +	expected           *lru.Cache
                     +}
+                    +
                     +// NewStatusAdmitter creates a plugin wrapper that ensures every accepted
                     +// route has a status field set that matches this router. The admitter manages
                     +// an LRU of recently seen conflicting updates to handle when two router processes
                     +// with differing configurations are writing updates at the same time.
                     +func NewStatusAdmitter(plugin router.Plugin, client client.RoutesNamespacer, name string) *StatusAdmitter {
                     +	expected, _ := lru.New(1024)
                     +	return &StatusAdmitter{
                     +		plugin:     plugin,
                     +		client:     client,
                     +		routerName: name,
+                    +
                     +		contentionInterval: 1 * time.Minute,
                     +		expected:           expected,
                     +	}
                     +}
+                    +
                     +// nowFn allows the package to be tested
                     +var nowFn = unversioned.Now
+                    +
                     +// findOrCreateIngress loops through the router status ingress array looking for an entry
                     +// that matches name. If there is no entry in the array, it creates one and appends it
                     +// to the array. If there are multiple entries with that name, the first one is
                     +// returned and later ones are removed. Changed is returned as true if any part of the
                     +// array is altered.
                     +func findOrCreateIngress(route *routeapi.Route, name string) (_ *routeapi.RouteIngress, changed bool) {
                     +	position := -1
                     +	updated := make([]routeapi.RouteIngress, 0, len(route.Status.Ingress))
                     +	for i := range route.Status.Ingress {
                     +		existing := &route.Status.Ingress[i]
                     +		if existing.RouterName != name {
                     +			updated = append(updated, *existing)
                     +			continue
                     +		}
                     +		if position != -1 {
                     +			changed = true
                     +			continue
                     +		}
                     +		updated = append(updated, *existing)
                     +		position = i
                     +	}
                     +	switch {
                     +	case position == -1:
                     +		position = len(route.Status.Ingress)
                     +		route.Status.Ingress = append(route.Status.Ingress, routeapi.RouteIngress{
                     +			RouterName: name,
                     +			Host:       route.Spec.Host,
                     +		})
                     +		changed = true
                     +	case changed:
                     +		route.Status.Ingress = updated
                     +	}
                     +	ingress := &route.Status.Ingress[position]
                     +	if ingress.Host != route.Spec.Host {
                     +		ingress.Host = route.Spec.Host
                     +		changed = true
                     +	}
                     +	return ingress, changed
                     +}
+                    +
                     +// setIngressCondition records the condition on the ingress, returning true if the ingress was changed and
                     +// false if no modification was made.
                     +func setIngressCondition(ingress *routeapi.RouteIngress, condition routeapi.RouteIngressCondition) bool {
                     +	for _, existing := range ingress.Conditions {
                     +		//existing.LastTransitionTime = nil
                     +		if existing == condition {
                     +			return false
                     +		}
                     +	}
                     +	now := nowFn()
                     +	condition.LastTransitionTime = &now
                     +	ingress.Conditions = []routeapi.RouteIngressCondition{condition}
                     +	return true
                     +}
+                    +
                     +func ingressConditionTouched(ingress *routeapi.RouteIngress) *unversioned.Time {
                     +	var lastTouch *unversioned.Time
                     +	for _, condition := range ingress.Conditions {
                     +		if t := condition.LastTransitionTime; t != nil {
                     +			switch {
                     +			case lastTouch == nil, t.After(lastTouch.Time):
                     +				lastTouch = t
                     +			}
                     +		}
                     +	}
                     +	return lastTouch
                     +}
+                    +
                     +// recordIngressConditionFailure updates the matching ingress on the route (or adds a new one) with the specified
                     +// condition, returning true if the object was modified.
                     +func recordIngressConditionFailure(route *routeapi.Route, name string, condition routeapi.RouteIngressCondition) (*routeapi.RouteIngress, bool, *unversioned.Time) {
                     +	for i := range route.Status.Ingress {
                     +		existing := &route.Status.Ingress[i]
                     +		if existing.RouterName != name {
                     +			continue
                     +		}
                     +		lastTouch := ingressConditionTouched(existing)
                     +		return existing, setIngressCondition(existing, condition), lastTouch
                     +	}
                     +	route.Status.Ingress = append(route.Status.Ingress, routeapi.RouteIngress{RouterName: name})
                     +	ingress := &route.Status.Ingress[len(route.Status.Ingress)-1]
                     +	setIngressCondition(ingress, condition)
                     +	return ingress, true, nil
                     +}
+                    +
                     +// hasIngressBeenTouched returns true if the route appears to have been touched since the last time
                     +func (a *StatusAdmitter) hasIngressBeenTouched(route *routeapi.Route, lastTouch *unversioned.Time) bool {
                     +	glog.V(4).Infof("has last touch %v for %s/%s", lastTouch, route.Namespace, route.Name)
                     +	if lastTouch.IsZero() {
                     +		return false
                     +	}
                     +	old, ok := a.expected.Get(route.UID)
                     +	if !ok || old.(time.Time).Equal(lastTouch.Time) {
                     +		return false
                     +	}
                     +	return true
                     +}
+                    +
                     +// recordIngressTouch
                     +func (a *StatusAdmitter) recordIngressTouch(route *routeapi.Route, touch *unversioned.Time, err error) {
                     +	switch {
                     +	case err == nil:
                     +		if touch != nil {
                     +			a.expected.Add(route.UID, touch.Time)
                     +		}
                     +	case errors.IsConflict(err):
                     +		a.expected.Add(route.UID, time.Time{})
                     +	}
                     +}
+                    +
                     +// admitRoute returns true if the route has already been accepted to this router, or
                     +// updates the route to contain an accepted condition. Returns an error if the route could
                     +// not be admitted.
                     +func (a *StatusAdmitter) admitRoute(oc client.RoutesNamespacer, route *routeapi.Route, name string) (bool, error) {
                     +	ingress, updated := findOrCreateIngress(route, name)
                     +	if !updated {
                     +		for i := range ingress.Conditions {
                     +			cond := &ingress.Conditions[i]
                     +			if cond.Type == routeapi.RouteAdmitted && cond.Status == kapi.ConditionTrue {
                     +				glog.V(4).Infof("admit: route already admitted")
                     +				return true, nil
                     +			}
                     +		}
                     +	}
+                    +
                     +	if a.hasIngressBeenTouched(route, ingressConditionTouched(ingress)) {
                     +		glog.V(4).Infof("admit: observed a route update from someone else: route %s/%s has been updated to an inconsistent value, doing nothing", route.Namespace, route.Name)
                     +		return true, nil
                     +	}
+                    +
                     +	setIngressCondition(ingress, routeapi.RouteIngressCondition{
                     +		Type:   routeapi.RouteAdmitted,
                     +		Status: kapi.ConditionTrue,
                     +	})
                     +	glog.V(4).Infof("admit: admitting route by updating status: %s (%t): %s", route.Name, updated, route.Spec.Host)
                     +	_, err := oc.Routes(route.Namespace).UpdateStatus(route)
                     +	a.recordIngressTouch(route, ingress.Conditions[0].LastTransitionTime, err)
                     +	return err == nil, err
                     +}
+                    +
                     +// RecordRouteRejection attempts to update the route status with a reason for a route being rejected.
                     +func (a *StatusAdmitter) RecordRouteRejection(route *routeapi.Route, reason, message string) {
                     +	ingress, changed, lastTouch := recordIngressConditionFailure(route, a.routerName, routeapi.RouteIngressCondition{
                     +		Type:    routeapi.RouteAdmitted,
                     +		Status:  kapi.ConditionFalse,
                     +		Reason:  reason,
                     +		Message: message,
                     +	})
                     +	if !changed {
                     +		glog.V(4).Infof("reject: no changes to route needed: %s/%s", route.Namespace, route.Name)
                     +		return
                     +	}
+                    +
                     +	if a.hasIngressBeenTouched(route, lastTouch) {
                     +		glog.V(4).Infof("reject: observed a route update from someone else: route %s/%s has been updated to an inconsistent value, doing nothing", route.Namespace, route.Name)
                     +		return
                     +	}
+                    +
                     +	_, err := a.client.Routes(route.Namespace).UpdateStatus(route)
                     +	a.recordIngressTouch(route, ingress.Conditions[0].LastTransitionTime, err)
                     +	if err != nil {
                     +		util.HandleError(fmt.Errorf("unable to write route rejection to the status: %v", err))
                     +	}
                     +}
+                    +
                     +// HandleRoute attempts to admit the provided route on watch add / modifications.
                     +func (a *StatusAdmitter) HandleRoute(eventType watch.EventType, route *routeapi.Route) error {
                     +	switch eventType {
                     +	case watch.Added, watch.Modified:
                     +		ok, err := a.admitRoute(a.client, route, a.routerName)
                     +		if err != nil {
                     +			return err
                     +		}
                     +		if !ok {
                     +			glog.V(4).Infof("skipping route: %s", route.Name)
                     +			return nil
                     +		}
                     +	}
                     +	return a.plugin.HandleRoute(eventType, route)
                     +}
+                    +
                     +func (a *StatusAdmitter) HandleEndpoints(eventType watch.EventType, route *kapi.Endpoints) error {
                     +	return a.plugin.HandleEndpoints(eventType, route)
                     +}
+                    +
                     +func (a *StatusAdmitter) HandleNamespaces(namespaces sets.String) error {
                     +	return a.plugin.HandleNamespaces(namespaces)
                     +}

                     new file mode 100644
@@ -0,0 +1,313 @@
                     +package controller
+                    +
                     +import (
                     +	"fmt"
                     +	"reflect"
                     +	"testing"
                     +	"time"
+                    +
                     +	kapi "k8s.io/kubernetes/pkg/api"
                     +	"k8s.io/kubernetes/pkg/api/errors"
                     +	"k8s.io/kubernetes/pkg/api/unversioned"
                     +	ktestclient "k8s.io/kubernetes/pkg/client/unversioned/testclient"
                     +	"k8s.io/kubernetes/pkg/types"
                     +	"k8s.io/kubernetes/pkg/util/sets"
                     +	"k8s.io/kubernetes/pkg/watch"
+                    +
                     +	"github.com/openshift/origin/pkg/client/testclient"
                     +	routeapi "github.com/openshift/origin/pkg/route/api"
                     +)
+                    +
                     +type fakePlugin struct {
                     +	t     watch.EventType
                     +	route *routeapi.Route
                     +	err   error
                     +}
+                    +
                     +func (p *fakePlugin) HandleRoute(t watch.EventType, route *routeapi.Route) error {
                     +	p.t, p.route = t, route
                     +	return p.err
                     +}
                     +func (p *fakePlugin) HandleEndpoints(watch.EventType, *kapi.Endpoints) error {
                     +	return fmt.Errorf("not expected")
                     +}
                     +func (p *fakePlugin) HandleNamespaces(namespaces sets.String) error {
                     +	return fmt.Errorf("not expected")
                     +}
+                    +
                     +func TestStatusNoOp(t *testing.T) {
                     +	now := unversioned.Now()
                     +	touched := unversioned.Time{Time: now.Add(-time.Minute)}
                     +	p := &fakePlugin{}
                     +	c := testclient.NewSimpleFake()
                     +	admitter := NewStatusAdmitter(p, c, "test")
                     +	err := admitter.HandleRoute(watch.Added, &routeapi.Route{
                     +		ObjectMeta: kapi.ObjectMeta{Name: "route1", Namespace: "default", UID: types.UID("uid1")},
                     +		Spec:       routeapi.RouteSpec{Host: "route1.test.local"},
                     +		Status: routeapi.RouteStatus{
                     +			Ingress: []routeapi.RouteIngress{
                     +				{
                     +					Host:       "route1.test.local",
                     +					RouterName: "test",
                     +					Conditions: []routeapi.RouteIngressCondition{
                     +						{
                     +							Type:               routeapi.RouteAdmitted,
                     +							Status:             kapi.ConditionTrue,
                     +							LastTransitionTime: &touched,
                     +						},
                     +					},
                     +				},
                     +			},
                     +		},
                     +	})
                     +	if err != nil {
                     +		t.Fatalf("unexpected error: %v", err)
                     +	}
                     +	if len(c.Actions()) > 0 {
                     +		t.Fatalf("unexpected actions: %#v", c.Actions())
                     +	}
                     +}
+                    +
                     +func TestStatusResetsHost(t *testing.T) {
                     +	now := unversioned.Now()
                     +	nowFn = func() unversioned.Time { return now }
                     +	touched := unversioned.Time{Time: now.Add(-time.Minute)}
                     +	p := &fakePlugin{}
                     +	c := testclient.NewSimpleFake(&routeapi.Route{})
                     +	admitter := NewStatusAdmitter(p, c, "test")
                     +	err := admitter.HandleRoute(watch.Added, &routeapi.Route{
                     +		ObjectMeta: kapi.ObjectMeta{Name: "route1", Namespace: "default", UID: types.UID("uid1")},
                     +		Spec:       routeapi.RouteSpec{Host: "route1.test.local"},
                     +		Status: routeapi.RouteStatus{
                     +			Ingress: []routeapi.RouteIngress{
                     +				{
                     +					Host:       "route2.test.local",
                     +					RouterName: "test",
                     +					Conditions: []routeapi.RouteIngressCondition{
                     +						{
                     +							Type:               routeapi.RouteAdmitted,
                     +							Status:             kapi.ConditionTrue,
                     +							LastTransitionTime: &touched,
                     +						},
                     +					},
                     +				},
                     +			},
                     +		},
                     +	})
                     +	if err != nil {
                     +		t.Fatalf("unexpected error: %v", err)
                     +	}
                     +	if len(c.Actions()) != 1 {
                     +		t.Fatalf("unexpected actions: %#v", c.Actions())
                     +	}
                     +	action := c.Actions()[0]
                     +	if action.GetVerb() != "update" || action.GetResource() != "routes" || action.GetSubresource() != "status" {
                     +		t.Fatalf("unexpected action: %#v", action)
                     +	}
                     +	obj := c.Actions()[0].(ktestclient.UpdateAction).GetObject().(*routeapi.Route)
                     +	if len(obj.Status.Ingress) != 1 && obj.Status.Ingress[0].Host != "route1.test.local" {
                     +		t.Fatalf("expected route reset: %#v", obj)
                     +	}
                     +	condition := obj.Status.Ingress[0].Conditions[0]
                     +	if condition.LastTransitionTime == nil || *condition.LastTransitionTime != now || condition.Status != kapi.ConditionTrue || condition.Reason != "" {
                     +		t.Fatalf("unexpected condition: %#v", condition)
                     +	}
                     +	if v, ok := admitter.expected.Peek(types.UID("uid1")); !ok || !reflect.DeepEqual(v, now.Time) {
                     +		t.Fatalf("did not record last modification time: %#v %#v", admitter.expected, v)
                     +	}
                     +}
+                    +
                     +func TestStatusBackoffOnConflict(t *testing.T) {
                     +	now := unversioned.Now()
                     +	nowFn = func() unversioned.Time { return now }
                     +	touched := unversioned.Time{Time: now.Add(-time.Minute)}
                     +	p := &fakePlugin{}
                     +	c := testclient.NewSimpleFake(&(errors.NewConflict(kapi.Resource("Route"), "route1", nil).(*errors.StatusError).ErrStatus))
                     +	admitter := NewStatusAdmitter(p, c, "test")
                     +	err := admitter.HandleRoute(watch.Added, &routeapi.Route{
                     +		ObjectMeta: kapi.ObjectMeta{Name: "route1", Namespace: "default", UID: types.UID("uid1")},
                     +		Spec:       routeapi.RouteSpec{Host: "route1.test.local"},
                     +		Status: routeapi.RouteStatus{
                     +			Ingress: []routeapi.RouteIngress{
                     +				{
                     +					Host:       "route2.test.local",
                     +					RouterName: "test",
                     +					Conditions: []routeapi.RouteIngressCondition{
                     +						{
                     +							Type:               routeapi.RouteAdmitted,
                     +							Status:             kapi.ConditionFalse,
                     +							LastTransitionTime: &touched,
                     +						},
                     +					},
                     +				},
                     +			},
                     +		},
                     +	})
                     +	if len(c.Actions()) != 1 {
                     +		t.Fatalf("unexpected actions: %#v", c.Actions())
                     +	}
                     +	action := c.Actions()[0]
                     +	if action.GetVerb() != "update" || action.GetResource() != "routes" || action.GetSubresource() != "status" {
                     +		t.Fatalf("unexpected action: %#v", action)
                     +	}
                     +	obj := c.Actions()[0].(ktestclient.UpdateAction).GetObject().(*routeapi.Route)
                     +	if len(obj.Status.Ingress) != 1 && obj.Status.Ingress[0].Host != "route1.test.local" {
                     +		t.Fatalf("expected route reset: %#v", obj)
                     +	}
                     +	condition := obj.Status.Ingress[0].Conditions[0]
                     +	if condition.LastTransitionTime == nil || *condition.LastTransitionTime != now || condition.Status != kapi.ConditionTrue || condition.Reason != "" {
                     +		t.Fatalf("unexpected condition: %#v", condition)
                     +	}
+                    +
                     +	if err == nil {
                     +		t.Fatalf("unexpected non-error: %#v", admitter.expected)
                     +	}
                     +	if v, ok := admitter.expected.Peek(types.UID("uid1")); !ok || !reflect.DeepEqual(v, time.Time{}) {
                     +		t.Fatalf("expected empty time: %#v", v)
                     +	}
                     +}
+                    +
                     +func TestStatusRecordRejection(t *testing.T) {
                     +	now := unversioned.Now()
                     +	nowFn = func() unversioned.Time { return now }
                     +	touched := unversioned.Time{Time: now.Add(-time.Minute)}
                     +	p := &fakePlugin{}
                     +	c := testclient.NewSimpleFake(&routeapi.Route{})
                     +	admitter := NewStatusAdmitter(p, c, "test")
                     +	admitter.RecordRouteRejection(&routeapi.Route{
                     +		ObjectMeta: kapi.ObjectMeta{Name: "route1", Namespace: "default", UID: types.UID("uid1")},
                     +		Spec:       routeapi.RouteSpec{Host: "route1.test.local"},
                     +		Status: routeapi.RouteStatus{
                     +			Ingress: []routeapi.RouteIngress{
                     +				{
                     +					Host:       "route2.test.local",
                     +					RouterName: "test",
                     +					Conditions: []routeapi.RouteIngressCondition{
                     +						{
                     +							Type:               routeapi.RouteAdmitted,
                     +							Status:             kapi.ConditionFalse,
                     +							LastTransitionTime: &touched,
                     +						},
                     +					},
                     +				},
                     +			},
                     +		},
                     +	}, "Failed", "generic error")
+                    +
                     +	if len(c.Actions()) != 1 {
                     +		t.Fatalf("unexpected actions: %#v", c.Actions())
                     +	}
                     +	action := c.Actions()[0]
                     +	if action.GetVerb() != "update" || action.GetResource() != "routes" || action.GetSubresource() != "status" {
                     +		t.Fatalf("unexpected action: %#v", action)
                     +	}
                     +	obj := c.Actions()[0].(ktestclient.UpdateAction).GetObject().(*routeapi.Route)
                     +	if len(obj.Status.Ingress) != 1 && obj.Status.Ingress[0].Host != "route1.test.local" {
                     +		t.Fatalf("expected route reset: %#v", obj)
                     +	}
                     +	condition := obj.Status.Ingress[0].Conditions[0]
                     +	if condition.LastTransitionTime == nil || *condition.LastTransitionTime != now || condition.Status != kapi.ConditionFalse || condition.Reason != "Failed" || condition.Message != "generic error" {
                     +		t.Fatalf("unexpected condition: %#v", condition)
                     +	}
                     +	if v, ok := admitter.expected.Peek(types.UID("uid1")); !ok || !reflect.DeepEqual(v, now.Time) {
                     +		t.Fatalf("expected empty time: %#v", v)
                     +	}
                     +}
+                    +
                     +func TestStatusRecordRejectionConflict(t *testing.T) {
                     +	now := unversioned.Now()
                     +	nowFn = func() unversioned.Time { return now }
                     +	touched := unversioned.Time{Time: now.Add(-time.Minute)}
                     +	p := &fakePlugin{}
                     +	c := testclient.NewSimpleFake(&(errors.NewConflict(kapi.Resource("Route"), "route1", nil).(*errors.StatusError).ErrStatus))
                     +	admitter := NewStatusAdmitter(p, c, "test")
                     +	admitter.RecordRouteRejection(&routeapi.Route{
                     +		ObjectMeta: kapi.ObjectMeta{Name: "route1", Namespace: "default", UID: types.UID("uid1")},
                     +		Spec:       routeapi.RouteSpec{Host: "route1.test.local"},
                     +		Status: routeapi.RouteStatus{
                     +			Ingress: []routeapi.RouteIngress{
                     +				{
                     +					Host:       "route2.test.local",
                     +					RouterName: "test",
                     +					Conditions: []routeapi.RouteIngressCondition{
                     +						{
                     +							Type:               routeapi.RouteAdmitted,
                     +							Status:             kapi.ConditionFalse,
                     +							LastTransitionTime: &touched,
                     +						},
                     +					},
                     +				},
                     +			},
                     +		},
                     +	}, "Failed", "generic error")
+                    +
                     +	if len(c.Actions()) != 1 {
                     +		t.Fatalf("unexpected actions: %#v", c.Actions())
                     +	}
                     +	action := c.Actions()[0]
                     +	if action.GetVerb() != "update" || action.GetResource() != "routes" || action.GetSubresource() != "status" {
                     +		t.Fatalf("unexpected action: %#v", action)
                     +	}
                     +	obj := c.Actions()[0].(ktestclient.UpdateAction).GetObject().(*routeapi.Route)
                     +	if len(obj.Status.Ingress) != 1 && obj.Status.Ingress[0].Host != "route1.test.local" {
                     +		t.Fatalf("expected route reset: %#v", obj)
                     +	}
                     +	condition := obj.Status.Ingress[0].Conditions[0]
                     +	if condition.LastTransitionTime == nil || *condition.LastTransitionTime != now || condition.Status != kapi.ConditionFalse || condition.Reason != "Failed" || condition.Message != "generic error" {
                     +		t.Fatalf("unexpected condition: %#v", condition)
                     +	}
                     +	if v, ok := admitter.expected.Peek(types.UID("uid1")); !ok || !reflect.DeepEqual(v, time.Time{}) {
                     +		t.Fatalf("expected empty time: %#v", v)
                     +	}
                     +}
+                    +
                     +func TestFindOrCreateIngress(t *testing.T) {
                     +	route := &routeapi.Route{
                     +		Status: routeapi.RouteStatus{
                     +			Ingress: []routeapi.RouteIngress{
                     +				{
                     +					RouterName: "bar",
                     +					Conditions: []routeapi.RouteIngressCondition{
                     +						{
                     +							Reason: "bar",
                     +						},
                     +					},
                     +				},
                     +				{
                     +					RouterName: "foo",
                     +					Conditions: []routeapi.RouteIngressCondition{
                     +						{
                     +							Reason: "foo1",
                     +						},
                     +					},
                     +				},
                     +				{
                     +					RouterName: "baz",
                     +					Conditions: []routeapi.RouteIngressCondition{
                     +						{
                     +							Reason: "baz",
                     +						},
                     +					},
                     +				},
                     +				{
                     +					RouterName: "foo",
                     +					Conditions: []routeapi.RouteIngressCondition{
                     +						{
                     +							Reason: "foo2",
                     +						},
                     +					},
                     +				},
                     +			},
                     +		},
                     +	}
+                    +
                     +	routerName := "foo"
                     +	ingress, changed := findOrCreateIngress(route, routerName)
                     +	if !changed {
                     +		t.Errorf("expected the route list to be changed: %#v", route.Status.Ingress)
                     +	}
                     +	if ingress.RouterName != routerName {
                     +		t.Errorf("returned ingress had router name %s but expected %s", ingress.RouterName, routerName)
                     +	}
                     +	t.Logf("routes: %#v", route.Status.Ingress)
                     +}

@@ -23,12 +23,27 @@ func HostForRoute(route *routeapi.Route) string {
                      type HostToRouteMap map[string][]*routeapi.Route
                      type RouteToHostMap map[string]string
                     +// RejectionRecorder is an object capable of recording why a route was rejected
                     +type RejectionRecorder interface {
                     +	RecordRouteRejection(route *routeapi.Route, reason, message string)
                     +}
+                    +
                     +var LogRejections = logRecorder{}
+                    +
                     +type logRecorder struct{}
+                    +
                     +func (_ logRecorder) RecordRouteRejection(route *routeapi.Route, reason, message string) {
                     +	glog.V(4).Infof("Rejected route %s: %s: %s", route.Name, reason, message)
                     +}
+                    +
                      // UniqueHost implements the router.Plugin interface to provide
                      // a template based, backend-agnostic router.
                      type UniqueHost struct {
                      	plugin       router.Plugin
                      	hostForRoute RouteHostFunc
                     +	recorder RejectionRecorder
+                    +
                      	hostToRoute HostToRouteMap
                      	routeToHost RouteToHostMap
                      	// nil means different than empty
@@ -36,12 +51,15 @@ type UniqueHost struct {
+                     }
                      // NewUniqueHost creates a plugin wrapper that ensures only unique routes are passed into
                     -// the underlying plugin.
                     -func NewUniqueHost(plugin router.Plugin, fn RouteHostFunc) *UniqueHost {
                     +// the underlying plugin. Recorder is an interface for indicating why a route was
                     +// rejected.
                     +func NewUniqueHost(plugin router.Plugin, fn RouteHostFunc, recorder RejectionRecorder) *UniqueHost {
                      	return &UniqueHost{
                      		plugin:       plugin,
                      		hostForRoute: fn,
                     +		recorder: recorder,
+                    +
                      		hostToRoute: make(HostToRouteMap),
                      		routeToHost: make(RouteToHostMap),
+                     	}
@@ -81,6 +99,7 @@ func (p *UniqueHost) HandleRoute(eventType watch.EventType, route *routeapi.Rout
                      	host := p.hostForRoute(route)
                      	if len(host) == 0 {
                      		glog.V(4).Infof("Route %s has no host value", routeName)
                     +		p.recorder.RecordRouteRejection(route, "NoHostValue", "no host value was defined for the route")
                      		return nil
+                     	}
                      	route.Spec.Host = host
@@ -97,14 +116,17 @@ func (p *UniqueHost) HandleRoute(eventType watch.EventType, route *routeapi.Rout
                      				if old[i].Spec.Path == route.Spec.Path {
                      					if old[i].CreationTimestamp.Before(route.CreationTimestamp) {
                      						glog.V(4).Infof("Route %s cannot take %s from %s", routeName, host, routeNameKey(oldest))
                     -						return fmt.Errorf("route %s holds %s and is older than %s", routeNameKey(oldest), host, key)
                     +						err := fmt.Errorf("route %s already exposes %s and is older", oldest.Name, host)
                     +						p.recorder.RecordRouteRejection(route, "HostAlreadyClaimed", err.Error())
                     +						return err
+                     					}
                      					added = true
                      					if old[i].Namespace == route.Namespace && old[i].Name == route.Name {
                      						old[i] = route
                      						break
+                     					}
                     -					glog.V(4).Infof("Route %s will replace path %s from %s because it is older", routeName, route.Spec.Path, routeNameKey(old[i]))
                     +					glog.V(4).Infof("route %s will replace path %s from %s because it is older", routeName, route.Spec.Path, old[i].Name)
                     +					p.recorder.RecordRouteRejection(old[i], "HostAlreadyClaimed", fmt.Sprintf("replaced by older route %s", route.Name))
                      					p.plugin.HandleRoute(watch.Deleted, old[i])
                      					old[i] = route
+                     				}
@@ -119,11 +141,14 @@ func (p *UniqueHost) HandleRoute(eventType watch.EventType, route *routeapi.Rout
                      		} else {
                      			if oldest.CreationTimestamp.Before(route.CreationTimestamp) {
                      				glog.V(4).Infof("Route %s cannot take %s from %s", routeName, host, routeNameKey(oldest))
                     -				return fmt.Errorf("route %s holds %s and is older than %s", routeNameKey(oldest), host, key)
                     +				err := fmt.Errorf("another route holds %s and is older than %s", host, route.Name)
                     +				p.recorder.RecordRouteRejection(route, "HostAlreadyClaimed", err.Error())
                     +				return err
+                     			}
                      			glog.V(4).Infof("Route %s is reclaiming %s from namespace %s", routeName, host, oldest.Namespace)
                      			for i := range old {
                     +				p.recorder.RecordRouteRejection(old[i], "HostAlreadyClaimed", fmt.Sprintf("namespace %s owns hostname %s", oldest.Namespace, host))
                      				p.plugin.HandleRoute(watch.Deleted, old[i])
+                     			}
                      			p.hostToRoute[host] = []*routeapi.Route{route}

@@ -204,7 +204,7 @@ func TestHandleEndpoints(t *testing.T) {
                      	templatePlugin := newDefaultTemplatePlugin(router, true)
                      	// TODO: move tests that rely on unique hosts to pkg/router/controller and remove them from
                      	// here
                     -	plugin := controller.NewUniqueHost(templatePlugin, controller.HostForRoute)
                     +	plugin := controller.NewUniqueHost(templatePlugin, controller.HostForRoute, controller.LogRejections)
                      	for _, tc := range testCases {
                      		plugin.HandleEndpoints(tc.eventType, tc.endpoints)
@@ -315,7 +315,7 @@ func TestHandleTCPEndpoints(t *testing.T) {
                      	templatePlugin := newDefaultTemplatePlugin(router, false)
                      	// TODO: move tests that rely on unique hosts to pkg/router/controller and remove them from
                      	// here
                     -	plugin := controller.NewUniqueHost(templatePlugin, controller.HostForRoute)
                     +	plugin := controller.NewUniqueHost(templatePlugin, controller.HostForRoute, controller.LogRejections)
                      	for _, tc := range testCases {
                      		plugin.HandleEndpoints(tc.eventType, tc.endpoints)
@@ -340,13 +340,28 @@ func TestHandleTCPEndpoints(t *testing.T) {
+                     	}
+                     }
                     +type rejection struct {
                     +	route   *routeapi.Route
                     +	reason  string
                     +	message string
                     +}
+                    +
                     +type fakeRejections struct {
                     +	rejections []rejection
                     +}
+                    +
                     +func (r *fakeRejections) RecordRouteRejection(route *routeapi.Route, reason, message string) {
                     +	r.rejections = append(r.rejections, rejection{route: route, reason: reason, message: message})
                     +}
+                    +
                      // TestHandleRoute test route watch events
                      func TestHandleRoute(t *testing.T) {
                     +	rejections := &fakeRejections{}
                      	router := newTestRouter(make(map[string]ServiceUnit))
                      	templatePlugin := newDefaultTemplatePlugin(router, true)
                      	// TODO: move tests that rely on unique hosts to pkg/router/controller and remove them from
                      	// here
                     -	plugin := controller.NewUniqueHost(templatePlugin, controller.HostForRoute)
                     +	plugin := controller.NewUniqueHost(templatePlugin, controller.HostForRoute, rejections)
                      	original := unversioned.Time{Time: time.Now()}
@@ -388,6 +403,10 @@ func TestHandleRoute(t *testing.T) {
+                     		}
+                     	}
                     +	if len(rejections.rejections) > 0 {
                     +		t.Fatalf("did not expect a recorded rejection: %#v", rejections)
                     +	}
+                    +
                      	// attempt to add a second route with a newer time, verify it is ignored
                      	duplicateRoute := &routeapi.Route{
                      		ObjectMeta: kapi.ObjectMeta{
@@ -411,6 +430,13 @@ func TestHandleRoute(t *testing.T) {
                      	if r, ok := plugin.RoutesForHost("www.example.com"); !ok || r[0].Name != "test" {
                      		t.Fatalf("unexpected claimed routes: %#v", r)
+                     	}
                     +	if len(rejections.rejections) != 1 ||
                     +		rejections.rejections[0].route.Name != "dupe" ||
                     +		rejections.rejections[0].reason != "HostAlreadyClaimed" ||
                     +		rejections.rejections[0].message != "route test already exposes www.example.com and is older" {
                     +		t.Fatalf("did not record rejection: %#v", rejections)
                     +	}
                     +	rejections.rejections = nil
                      	// attempt to remove the second route that is not being used, verify it is ignored
                      	if err := plugin.HandleRoute(watch.Deleted, duplicateRoute); err == nil {
@@ -425,6 +451,13 @@ func TestHandleRoute(t *testing.T) {
                      	if r, ok := plugin.RoutesForHost("www.example.com"); !ok || r[0].Name != "test" {
                      		t.Fatalf("unexpected claimed routes: %#v", r)
+                     	}
                     +	if len(rejections.rejections) != 1 ||
                     +		rejections.rejections[0].route.Name != "dupe" ||
                     +		rejections.rejections[0].reason != "HostAlreadyClaimed" ||
                     +		rejections.rejections[0].message != "route test already exposes www.example.com and is older" {
                     +		t.Fatalf("did not record rejection: %#v", rejections)
                     +	}
                     +	rejections.rejections = nil
                      	// add a second route with an older time, verify it takes effect
                      	duplicateRoute.CreationTimestamp = unversioned.Time{Time: original.Add(-time.Hour)}
@@ -441,6 +474,13 @@ func TestHandleRoute(t *testing.T) {
                      	if _, ok := actualSU.ServiceAliasConfigs[router.routeKey(route)]; ok {
                      		t.Errorf("unexpected service alias config %s", router.routeKey(route))
+                     	}
                     +	if len(rejections.rejections) != 1 ||
                     +		rejections.rejections[0].route.Name != "test" ||
                     +		rejections.rejections[0].reason != "HostAlreadyClaimed" ||
                     +		rejections.rejections[0].message != "replaced by older route dupe" {
                     +		t.Fatalf("did not record rejection: %#v", rejections)
                     +	}
                     +	rejections.rejections = nil
                      	//mod
                      	route.Spec.Host = "www.example2.com"
@@ -467,6 +507,9 @@ func TestHandleRoute(t *testing.T) {
                      	if plugin.HostLen() != 1 {
                      		t.Fatalf("did not clear claimed route: %#v", plugin)
+                     	}
                     +	if len(rejections.rejections) != 0 {
                     +		t.Fatalf("unexpected rejection: %#v", rejections)
                     +	}
                      	//delete
                      	if err := plugin.HandleRoute(watch.Deleted, route); err != nil {
@@ -488,6 +531,9 @@ func TestHandleRoute(t *testing.T) {
                      	if plugin.HostLen() != 0 {
                      		t.Errorf("did not clear claimed route: %#v", plugin)
+                     	}
                     +	if len(rejections.rejections) != 0 {
                     +		t.Fatalf("unexpected rejection: %#v", rejections)
                     +	}
+                     }
                      func TestNamespaceScopingFromEmpty(t *testing.T) {
@@ -495,7 +541,7 @@ func TestNamespaceScopingFromEmpty(t *testing.T) {
                      	templatePlugin := newDefaultTemplatePlugin(router, true)
                      	// TODO: move tests that rely on unique hosts to pkg/router/controller and remove them from
                      	// here
                     -	plugin := controller.NewUniqueHost(templatePlugin, controller.HostForRoute)
                     +	plugin := controller.NewUniqueHost(templatePlugin, controller.HostForRoute, controller.LogRejections)
                      	// no namespaces allowed
                      	plugin.HandleNamespaces(sets.String{})

@@ -256,6 +256,12 @@ items:
                          verbs:
                          - get
                          - update
                     +  - apiGroups: null
                     +    attributeRestrictions: null
                     +    resources:
                     +    - routes/status
                     +    verbs:
                     +    - update
                      - apiVersion: v1
                        kind: ClusterRole
                        metadata:
@@ -671,6 +677,12 @@ items:
                          verbs:
                          - list
                          - watch
                     +  - apiGroups: null
                     +    attributeRestrictions: null
                     +    resources:
                     +    - routes/status
                     +    verbs:
                     +    - update
                      - apiVersion: v1
                        kind: ClusterRole
                        metadata:

@@ -126,6 +126,11 @@ func (s *TestHttpService) handleRouteList(w http.ResponseWriter, r *http.Request
                      	fmt.Fprint(w, "{}")
+                     }
                     +// handleRouteCalls handles calls to /osapi/v1/routes/* and returns whatever the client sent
                     +func (s *TestHttpService) handleRouteCalls(w http.ResponseWriter, r *http.Request) {
                     +	fmt.Fprint(w, "{}")
                     +}
+                    +
                      // handleEndpointWatch handles calls to /api/v1beta1/watch/endpoints and uses the endpoint channel to simulate watch events
                      func (s *TestHttpService) handleEndpointWatch(w http.ResponseWriter, r *http.Request) {
                      	io.WriteString(w, <-s.EndpointChannel)
@@ -182,6 +187,7 @@ func (s *TestHttpService) startMaster() error {
                      		masterServer.HandleFunc(fmt.Sprintf("/api/%s/endpoints", version), s.handleEndpointList)
                      		masterServer.HandleFunc(fmt.Sprintf("/api/%s/watch/endpoints", version), s.handleEndpointWatch)
                      		masterServer.HandleFunc(fmt.Sprintf("/oapi/%s/routes", version), s.handleRouteList)
                     +		masterServer.HandleFunc(fmt.Sprintf("/oapi/%s/namespaces/", version), s.handleRouteCalls)
                      		masterServer.HandleFunc(fmt.Sprintf("/oapi/%s/watch/routes", version), s.handleRouteWatch)
+                     	}