@@ -77,7 +77,7 @@ func (c *RouterController) HandleRoute() {

 	c.lock.Lock()

 	defer c.lock.Unlock()

-	glog.V(4).Infof("Processing Route: %s", route.Spec.To.Name)

+	glog.V(4).Infof("Processing Route: %s -> %s", route.Name, route.Spec.To.Name)

 	glog.V(4).Infof("           Alias: %s", route.Spec.Host)

 	glog.V(4).Infof("           Event: %s", eventType)

@@ -2,6 +2,7 @@ package factory

 import (

 	"fmt"

+	"sort"

 	"time"

 	kapi "k8s.io/kubernetes/pkg/api"

@@ -166,6 +167,21 @@ func (r *routesByHost) Endpoints(namespace, name string) *kapi.Endpoints {

 	return obj.(*kapi.Endpoints)

 }

+// routeAge sorts routes from oldest to newest and is stable for all routes.

+type routeAge []routeapi.Route

+

+func (r routeAge) Len() int      { return len(r) }

+func (r routeAge) Swap(i, j int) { r[i], r[j] = r[j], r[i] }

+func (r routeAge) Less(i, j int) bool {

+	if r[i].CreationTimestamp.Before(r[j].CreationTimestamp) {

+		return true

+	}

+	if r[i].Namespace < r[j].Namespace {

+		return true

+	}

+	return r[i].Name < r[j].Name

+}

+

 func oldestRoute(routes []interface{}) *routeapi.Route {

 	var oldest *routeapi.Route

 	for i := range routes {

@@ -202,7 +218,13 @@ func (lw *routeLW) List(options kapi.ListOptions) (runtime.Object, error) {

 		LabelSelector: lw.label,

 		FieldSelector: lw.field,

 	}

-	return lw.client.Routes(lw.namespace).List(opts)

+	routes, err := lw.client.Routes(lw.namespace).List(opts)

+	if err != nil {

+		return nil, err

+	}

+	// return routes in order of age to avoid rejections during resync

+	sort.Sort(routeAge(routes.Items))

+	return routes, nil

 }

 func (lw *routeLW) Watch(options kapi.ListOptions) (watch.Interface, error) {

@@ -92,7 +92,8 @@ func findOrCreateIngress(route *routeapi.Route, name string) (_ *routeapi.RouteI

 // false if no modification was made.

 func setIngressCondition(ingress *routeapi.RouteIngress, condition routeapi.RouteIngressCondition) bool {

 	for _, existing := range ingress.Conditions {

-		//existing.LastTransitionTime = nil

+		// ensures that the comparison is based on the actual value, not the time

+		existing.LastTransitionTime = condition.LastTransitionTime

 		if existing == condition {

 			return false

 		}

@@ -109,10 +109,10 @@ func TestStatusResetsHost(t *testing.T) {

 		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 != "" {

+	if condition.LastTransitionTime == nil || *condition.LastTransitionTime != touched || 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) {

+	if v, ok := admitter.expected.Peek(types.UID("uid1")); !ok || !reflect.DeepEqual(v, touched.Time) {

 		t.Fatalf("did not record last modification time: %#v %#v", admitter.expected, v)

 	}

 }

@@ -198,6 +198,43 @@ func TestStatusRecordRejection(t *testing.T) {

 	}

 }

+func TestStatusRecordRejectionNoChange(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:       "route1.test.local",

+					RouterName: "test",

+					Conditions: []routeapi.RouteIngressCondition{

+						{

+							Type:               routeapi.RouteAdmitted,

+							Status:             kapi.ConditionFalse,

+							Reason:             "Failed",

+							Message:            "generic error",

+							LastTransitionTime: &touched,

+						},

+					},

+				},

+			},

+		},

+	}, "Failed", "generic error")

+

+	if len(c.Actions()) != 0 {

+		t.Fatalf("unexpected actions: %#v", c.Actions())

+	}

+	if v, ok := admitter.expected.Peek(types.UID("uid1")); ok {

+		t.Fatalf("expected empty time: %#v", v)

+	}

+}

+

 func TestStatusRecordRejectionWithStatus(t *testing.T) {

 	now := unversioned.Now()

 	nowFn = func() unversioned.Time { return now }