@@ -59,6 +59,9 @@ const (

 	InfraPetSetControllerServiceAccountName = "pet-set-controller"

 	PetSetControllerRoleName                = "system:pet-set-controller"

+	InfraUnidlingControllerServiceAccountName = "unidling-controller"

+	UnidlingControllerRoleName                = "system:unidling-controller"

+

 	ServiceServingCertServiceAccountName = "service-serving-cert-controller"

 	ServiceServingCertControllerRoleName = "system:service-serving-cert-controller"

@@ -774,6 +777,55 @@ func init() {

 	}

 	err = InfraSAs.addServiceAccount(

+		InfraUnidlingControllerServiceAccountName,

+		authorizationapi.ClusterRole{

+			ObjectMeta: kapi.ObjectMeta{

+				Name: UnidlingControllerRoleName,

+			},

+			Rules: []authorizationapi.PolicyRule{

+				{

+					APIGroups: []string{kapi.GroupName, extensions.GroupName},

+					Verbs:     sets.NewString("get", "update"),

+					Resources: sets.NewString("replicationcontrollers/scale"),

+				},

+				{

+					APIGroups: []string{extensions.GroupName},

+					Verbs:     sets.NewString("get", "update"),

+					Resources: sets.NewString("replicasets/scale", "deployments/scale"),

+				},

+				{

+					Verbs:     sets.NewString("get", "update"),

+					Resources: sets.NewString("deploymentconfigs/scale"),

+				},

+				{

+					Verbs:     sets.NewString("list", "watch"),

+					Resources: sets.NewString("events"),

+				},

+				{

+					APIGroups: []string{kapi.GroupName},

+					Verbs:     sets.NewString("get", "update"),

+					Resources: sets.NewString("endpoints"),

+				},

+				// these are used to "manually" scale and annotate known objects, and should be

+				// removed once we can set the last-scale-reason field via the scale subresource

+				{

+					APIGroups: []string{kapi.GroupName},

+					Verbs:     sets.NewString("get", "update"),

+					Resources: sets.NewString("replicationcontrollers"),

+				},

+				{

+					APIGroups: []string{},

+					Verbs:     sets.NewString("get", "update"),

+					Resources: sets.NewString("deploymentconfigs"),

+				},

+			},

+		},

+	)

+	if err != nil {

+		panic(err)

+	}

+

+	err = InfraSAs.addServiceAccount(

 		ServiceServingCertServiceAccountName,

 		authorizationapi.ClusterRole{

 			ObjectMeta: kapi.ObjectMeta{

@@ -924,6 +924,15 @@ func (c *MasterConfig) OriginNamespaceControllerClients() (*osclient.Client, *kc

 	return c.PrivilegedLoopbackOpenShiftClient, c.PrivilegedLoopbackKubernetesClient

 }

+// UnidlingControllerClients returns the unidling controller clients

+func (c *MasterConfig) UnidlingControllerClients() (*osclient.Client, *kclient.Client) {

+	_, osClient, kClient, err := c.GetServiceAccountClients(bootstrappolicy.InfraUnidlingControllerServiceAccountName)

+	if err != nil {

+		glog.Fatal(err)

+	}

+	return osClient, kClient

+}

+

 // NewEtcdStorage returns a storage interface for the provided storage version.

 func NewEtcdStorage(client newetcdclient.Client, version unversioned.GroupVersion, prefix string) (oshelper storage.Interface, err error) {

 	return etcdstorage.NewEtcdStorage(client, kapi.Codecs.LegacyCodec(version), prefix, false, genericapiserveroptions.DefaultDeserializationCacheSize), nil

@@ -9,6 +9,7 @@ import (

 	"github.com/golang/glog"

+	deployclient "github.com/openshift/origin/pkg/deploy/client/clientset_generated/internalclientset/typed/core/unversioned"

 	kctrlmgr "k8s.io/kubernetes/cmd/kube-controller-manager/app"

 	cmapp "k8s.io/kubernetes/cmd/kube-controller-manager/app/options"

 	"k8s.io/kubernetes/pkg/admission"

@@ -30,6 +31,7 @@ import (

 	buildclient "github.com/openshift/origin/pkg/build/client"

 	buildcontrollerfactory "github.com/openshift/origin/pkg/build/controller/factory"

 	buildstrategy "github.com/openshift/origin/pkg/build/controller/strategy"

+	osclient "github.com/openshift/origin/pkg/client"

 	cmdadmission "github.com/openshift/origin/pkg/cmd/server/admission"

 	"github.com/openshift/origin/pkg/cmd/server/crypto"

 	cmdutil "github.com/openshift/origin/pkg/cmd/util"

@@ -48,6 +50,7 @@ import (

 	"github.com/openshift/origin/pkg/security/uidallocator"

 	"github.com/openshift/origin/pkg/service/controller/ingressip"

 	servingcertcontroller "github.com/openshift/origin/pkg/service/controller/servingcert"

+	unidlingcontroller "github.com/openshift/origin/pkg/unidling/controller"

 	configapi "github.com/openshift/origin/pkg/cmd/server/api"

 	"github.com/openshift/origin/pkg/cmd/server/bootstrappolicy"

@@ -540,3 +543,15 @@ func (c *MasterConfig) RunIngressIPController(client *kclient.Client) {

 	ingressIPController := ingressip.NewIngressIPController(client, ipNet, defaultIngressIPSyncPeriod)

 	go ingressIPController.Run(utilwait.NeverStop)

 }

+

+// RunUnidlingController starts the unidling controller

+func (c *MasterConfig) RunUnidlingController() {

+	oc, kc := c.UnidlingControllerClients()

+	resyncPeriod := 2 * time.Hour

+	scaleNamespacer := osclient.NewDelegatingScaleNamespacer(oc, kc)

+	coreClient := clientadapter.FromUnversionedClient(kc).Core()

+	dcCoreClient := deployclient.New(oc.RESTClient)

+	cont := unidlingcontroller.NewUnidlingController(scaleNamespacer, coreClient, coreClient, dcCoreClient, coreClient, resyncPeriod)

+

+	cont.Run(utilwait.NeverStop)

+}

@@ -674,6 +674,7 @@ func startControllers(oc *origin.MasterConfig, kc *kubernetes.MasterConfig) erro

 		glog.Fatalf("Could not get client: %v", err)

 	}

 	oc.RunServiceServingCertController(serviceServingCertClient)

+	oc.RunUnidlingController()

 	_, _, ingressIPClient, err := oc.GetServiceAccountClients(bootstrappolicy.InfraServiceIngressIPControllerServiceAccountName)

 	if err != nil {

@@ -12,3 +12,28 @@ const (

 	// NeedPodsReason is the reason for the event emitted to indicate that endpoints should be unidled

 	NeedPodsReason = "NeedPods"

 )

+

+// NB: if these get changed, you'll need to actually add in the full API machinery for them

+

+// RecordedScaleReference is a CrossGroupObjectReference to a scale subresource that also

+// has the previous replica count recorded

+type RecordedScaleReference struct {

+	// Reference to the idled resource

+	CrossGroupObjectReference `json:",inline" protobuf:"bytes,1,opt,name=crossVersionObjectReference"`

+	// The last seen scale of the idled resource (before idling)

+	Replicas int32 `json:"replicas" protobuf:"varint,2,opt,name=replicas"`

+}

+

+// CrossGroupObjectReference is a reference to an object in the same

+// namespace in the specified group.  It is similar to

+// autoscaling.CrossVersionObjectReference.

+type CrossGroupObjectReference struct {

+	// Kind of the referent; More info: http://releases.k8s.io/release-1.3/docs/devel/api-conventions.md#types-kinds"

+	Kind string `json:"kind" protobuf:"bytes,1,opt,name=kind"`

+	// Name of the referent; More info: http://releases.k8s.io/release-1.3/docs/user-guide/identifiers.md#names

+	Name string `json:"name" protobuf:"bytes,2,opt,name=name"`

+	// API version of the referent (deprecated, prefer usng Group instead)

+	APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,3,opt,name=apiVersion"`

+	// Group of the referent

+	Group string `json:"group,omitempty" protobuf:"bytes,3,opt,name=group"`

+}

new file mode 100644

@@ -0,0 +1,339 @@

+package controller

+

+import (

+	"encoding/json"

+	"fmt"

+	"sync"

+	"time"

+

+	unidlingapi "github.com/openshift/origin/pkg/unidling/api"

+	unidlingutil "github.com/openshift/origin/pkg/unidling/util"

+

+	deployclient "github.com/openshift/origin/pkg/deploy/client/clientset_generated/internalclientset/typed/core/unversioned"

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

+	"k8s.io/kubernetes/pkg/api/errors"

+	kextapi "k8s.io/kubernetes/pkg/apis/extensions"

+	"k8s.io/kubernetes/pkg/client/cache"

+	kclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"

+	kextclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned"

+	"k8s.io/kubernetes/pkg/controller/framework"

+	"k8s.io/kubernetes/pkg/fields"

+	"k8s.io/kubernetes/pkg/runtime"

+	"k8s.io/kubernetes/pkg/types"

+	utilruntime "k8s.io/kubernetes/pkg/util/runtime"

+	"k8s.io/kubernetes/pkg/util/wait"

+	"k8s.io/kubernetes/pkg/util/workqueue"

+	"k8s.io/kubernetes/pkg/watch"

+

+	"github.com/golang/glog"

+)

+

+const MaxRetries = 5

+

+type lastFiredCache struct {

+	sync.RWMutex

+	items map[types.NamespacedName]time.Time

+}

+

+func (c *lastFiredCache) Get(info types.NamespacedName) time.Time {

+	c.RLock()

+	defer c.RUnlock()

+

+	return c.items[info]

+}

+

+func (c *lastFiredCache) Clear(info types.NamespacedName) {

+	c.Lock()

+	defer c.Unlock()

+

+	delete(c.items, info)

+}

+

+func (c *lastFiredCache) AddIfNewer(info types.NamespacedName, newLastFired time.Time) bool {

+	c.Lock()

+	defer c.Unlock()

+

+	if lastFired, hasLastFired := c.items[info]; !hasLastFired || lastFired.Before(newLastFired) {

+		c.items[info] = newLastFired

+		return true

+	}

+

+	return false

+}

+

+type UnidlingController struct {

+	controller          *framework.Controller

+	scaleNamespacer     kextclient.ScalesGetter

+	endpointsNamespacer kclient.EndpointsGetter

+	queue               workqueue.RateLimitingInterface

+	lastFiredCache      *lastFiredCache

+

+	// TODO: remove these once we get the scale-source functionality in the scale endpoints

+	dcNamespacer deployclient.DeploymentConfigsGetter

+	rcNamespacer kclient.ReplicationControllersGetter

+}

+

+func NewUnidlingController(scaleNS kextclient.ScalesGetter, endptsNS kclient.EndpointsGetter, evtNS kclient.EventsGetter, dcNamespacer deployclient.DeploymentConfigsGetter, rcNamespacer kclient.ReplicationControllersGetter, resyncPeriod time.Duration) *UnidlingController {

+	fieldSet := fields.Set{}

+	fieldSet["reason"] = unidlingapi.NeedPodsReason

+	fieldSelector := fieldSet.AsSelector()

+

+	unidlingController := &UnidlingController{

+		scaleNamespacer:     scaleNS,

+		endpointsNamespacer: endptsNS,

+		queue:               workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()),

+		lastFiredCache: &lastFiredCache{

+			items: make(map[types.NamespacedName]time.Time),

+		},

+

+		dcNamespacer: dcNamespacer,

+		rcNamespacer: rcNamespacer,

+	}

+

+	_, controller := framework.NewInformer(

+		&cache.ListWatch{

+			// No need to list -- we only care about new events

+			ListFunc: func(options kapi.ListOptions) (runtime.Object, error) {

+				return &kapi.EventList{}, nil

+			},

+			WatchFunc: func(options kapi.ListOptions) (watch.Interface, error) {

+				options.FieldSelector = fieldSelector

+				return evtNS.Events(kapi.NamespaceAll).Watch(options)

+			},

+		},

+		&kapi.Event{},

+		resyncPeriod,

+		framework.ResourceEventHandlerFuncs{

+			AddFunc: func(obj interface{}) {

+				event := obj.(*kapi.Event)

+				unidlingController.enqueueEvent(event)

+			},

+			UpdateFunc: func(oldObj interface{}, newObj interface{}) {

+				// retrigger on new last-seen times

+				event := newObj.(*kapi.Event)

+				unidlingController.enqueueEvent(event)

+			},

+			DeleteFunc: func(obj interface{}) {

+				// this is just to clean up our cache of the last seen times

+				event := obj.(*kapi.Event)

+				unidlingController.clearEventFromCache(event)

+			},

+		},

+	)

+

+	unidlingController.controller = controller

+

+	return unidlingController

+}

+

+// clearEventFromCache removes the entry for the given event from the lastFiredCache.

+func (c *UnidlingController) clearEventFromCache(event *kapi.Event) {

+	if event.Reason != unidlingapi.NeedPodsReason {

+		return

+	}

+

+	info := types.NamespacedName{

+		Namespace: event.InvolvedObject.Namespace,

+		Name:      event.InvolvedObject.Name,

+	}

+	c.lastFiredCache.Clear(info)

+}

+

+// equeueEvent checks if the given event is relevant (i.e. if it's a NeedPods event),

+// and, if so, extracts relevant information, and enqueues that information in the

+// processing queue.

+func (c *UnidlingController) enqueueEvent(event *kapi.Event) {

+	if event.Reason != unidlingapi.NeedPodsReason {

+		return

+	}

+

+	info := types.NamespacedName{

+		Namespace: event.InvolvedObject.Namespace,

+		Name:      event.InvolvedObject.Name,

+	}

+

+	// only add things to the queue if they're newer than what we already have

+	if c.lastFiredCache.AddIfNewer(info, event.LastTimestamp.Time) {

+		c.queue.Add(info)

+	}

+}

+

+func (c *UnidlingController) Run(stopCh <-chan struct{}) {

+	defer utilruntime.HandleCrash()

+	go c.controller.Run(stopCh)

+	go wait.Until(c.processRequests, time.Second, stopCh)

+}

+

+// processRequests calls awaitRequest repeatedly, until told to stop by

+// the return value of awaitRequest.

+func (c *UnidlingController) processRequests() {

+	for {

+		if !c.awaitRequest() {

+			return

+		}

+	}

+}

+

+// awaitRequest awaits a new request on the queue, and sends it off for processing.

+// If more requests on the queue should be processed, it returns true.  If we should

+// stop processing, it returns false.

+func (c *UnidlingController) awaitRequest() bool {

+	infoRaw, stop := c.queue.Get()

+	if stop {

+		return false

+	}

+

+	defer c.queue.Done(infoRaw)

+

+	info := infoRaw.(types.NamespacedName)

+	lastFired := c.lastFiredCache.Get(info)

+

+	var retry bool

+	var err error

+	if retry, err = c.handleRequest(info, lastFired); err == nil {

+		// if there was no error, we succeeded in the unidling, and we need to

+		// tell the rate limitter to stop tracking this request

+		c.queue.Forget(infoRaw)

+		return true

+	}

+

+	// check to see if we think the error was transient (e.g. server error on the update request),

+	// and if not, do not retry

+	if !retry {

+		utilruntime.HandleError(fmt.Errorf("Unable to process unidling event for %s/%s at (%s), will not retry: %v", info.Namespace, info.Name, lastFired, err))

+		return true

+	}

+

+	// Otherwise, if we have an error, we were at least partially unsucessful in unidling, so

+	// we requeue the event to process later

+

+	// don't try to process failing requests forever

+	if c.queue.NumRequeues(infoRaw) > MaxRetries {

+		utilruntime.HandleError(fmt.Errorf("Unable to process unidling event for %s/%s (at %s), will not retry again: %v", info.Namespace, info.Name, lastFired, err))

+		c.queue.Forget(infoRaw)

+		return true

+	}

+

+	glog.V(4).Infof("Unable to fully process unidling request for %s/%s (at %s), will retry: %v", info.Namespace, info.Name, lastFired, err)

+	c.queue.AddRateLimited(infoRaw)

+	return true

+}

+

+// handleRequest handles a single request to unidle.  After checking the validity of the request,

+// it will examine the endpoints in question to determine which scalables to scale, and will scale

+// them and remove them from the endpoints' list of idled scalables.  If it is unable to properly

+// process the request, it will return a boolean indicating whether or not we should retry later,

+// as well as an error (e.g. if we're unable to parse an annotation, retrying later won't help,

+// so it will return false).

+func (c *UnidlingController) handleRequest(info types.NamespacedName, lastFired time.Time) (bool, error) {

+	// fetch the endpoints associated with the service in question

+	targetEndpoints, err := c.endpointsNamespacer.Endpoints(info.Namespace).Get(info.Name)

+	if err != nil {

+		return true, fmt.Errorf("unable to retrieve endpoints: %v", err)

+	}

+

+	// make sure we actually were idled...

+	idledTimeRaw, wasIdled := targetEndpoints.Annotations[unidlingapi.IdledAtAnnotation]

+	if !wasIdled {

+		glog.V(5).Infof("UnidlingController received a NeedPods event for a service that was not idled, ignoring")

+		return false, nil

+	}

+

+	// ...and make sure this request was to wake up from the most recent idling, and not a previous one

+	idledTime, err := time.Parse(time.RFC3339, idledTimeRaw)

+	if err != nil {

+		// retrying here won't help, we're just stuck as idle since we can't get parse the idled time

+		return false, fmt.Errorf("unable to check idled-at time: %v", err)

+	}

+	if lastFired.Before(idledTime) {

+		glog.V(5).Infof("UnidlingController received an out-of-date NeedPods event, ignoring")

+		return false, nil

+	}

+

+	// TODO: ew, this is unversioned.  Such is life when working with annotations.

+	var targetScalables []unidlingapi.RecordedScaleReference

+	if targetScalablesStr, hasTargetScalables := targetEndpoints.Annotations[unidlingapi.UnidleTargetAnnotation]; hasTargetScalables {

+		if err = json.Unmarshal([]byte(targetScalablesStr), &targetScalables); err != nil {

+			// retrying here won't help, we're just stuck as idled since we can't parse the idled scalables list

+			return false, fmt.Errorf("unable to unmarshal target scalable references: %v", err)

+		}

+	} else {

+		glog.V(4).Infof("Service %s/%s had no scalables to unidle", info.Namespace, info.Name)

+		targetScalables = []unidlingapi.RecordedScaleReference{}

+	}

+

+	targetScalablesSet := make(map[unidlingapi.RecordedScaleReference]struct{}, len(targetScalables))

+	for _, v := range targetScalables {

+		targetScalablesSet[v] = struct{}{}

+	}

+

+	deleteIdledAtAnnotation := func(annotations map[string]string) {

+		delete(annotations, unidlingapi.IdledAtAnnotation)

+	}

+

+	scaleAnnotater := unidlingutil.NewScaleAnnotater(c.scaleNamespacer, c.dcNamespacer, c.rcNamespacer, deleteIdledAtAnnotation)

+

+	for _, scalableRef := range targetScalables {

+		var scale *kextapi.Scale

+		var obj runtime.Object

+

+		obj, scale, err = scaleAnnotater.GetObjectWithScale(info.Namespace, scalableRef.CrossGroupObjectReference)

+		if err != nil {

+			if errors.IsNotFound(err) {

+				utilruntime.HandleError(fmt.Errorf("%s %q does not exist, removing from list of scalables while unidling service %s/%s: %v", scalableRef.Kind, scalableRef.Name, info.Namespace, info.Name, err))

+				delete(targetScalablesSet, scalableRef)

+			} else {

+				utilruntime.HandleError(fmt.Errorf("Unable to get scale for %s %q while unidling service %s/%s, will try again later: %v", scalableRef.Kind, scalableRef.Name, info.Namespace, info.Name, err))

+			}

+			continue

+		}

+

+		if scale.Spec.Replicas > 0 {

+			glog.V(4).Infof("%s %q is not idle, skipping while unidling service %s/%s", scalableRef.Kind, scalableRef.Name, info.Namespace, info.Name)

+			continue

+		}

+

+		scale.Spec.Replicas = scalableRef.Replicas

+

+		if err = scaleAnnotater.UpdateObjectScale(info.Namespace, scalableRef.CrossGroupObjectReference, obj, scale); err != nil {

+			if errors.IsNotFound(err) {

+				utilruntime.HandleError(fmt.Errorf("%s %q does not exist, removing from list of scalables while unidling service %s/%s: %v", scalableRef.Kind, scalableRef.Name, info.Namespace, info.Name, err))

+				delete(targetScalablesSet, scalableRef)

+			} else {

+				utilruntime.HandleError(fmt.Errorf("Unable to scale up %s %q while unidling service %s/%s: %v", scalableRef.Kind, scalableRef.Name, info.Namespace, info.Name, err))

+			}

+			continue

+		} else {

+			glog.V(4).Infof("Scaled up %s %q while unidling service %s/%s", scalableRef.Kind, scalableRef.Name, info.Namespace, info.Name)

+		}

+

+		delete(targetScalablesSet, scalableRef)

+	}

+

+	newAnnotationList := make([]unidlingapi.RecordedScaleReference, 0, len(targetScalablesSet))

+	for k := range targetScalablesSet {

+		newAnnotationList = append(newAnnotationList, k)

+	}

+

+	if len(newAnnotationList) == 0 {

+		delete(targetEndpoints.Annotations, unidlingapi.UnidleTargetAnnotation)

+		delete(targetEndpoints.Annotations, unidlingapi.IdledAtAnnotation)

+	} else {

+		var newAnnotationBytes []byte

+		newAnnotationBytes, err = json.Marshal(newAnnotationList)

+		if err != nil {

+			utilruntime.HandleError(fmt.Errorf("unable to update/remove idle annotations from %s/%s: unable to marshal list of remaining scalables, removing list entirely: %v", info.Namespace, info.Name, err))

+

+			delete(targetEndpoints.Annotations, unidlingapi.UnidleTargetAnnotation)

+			delete(targetEndpoints.Annotations, unidlingapi.IdledAtAnnotation)

+		} else {

+			targetEndpoints.Annotations[unidlingapi.UnidleTargetAnnotation] = string(newAnnotationBytes)

+		}

+	}

+

+	if _, err = c.endpointsNamespacer.Endpoints(info.Namespace).Update(targetEndpoints); err != nil {

+		return true, fmt.Errorf("unable to update/remove idle annotations from %s/%s: %v", info.Namespace, info.Name, err)

+	}

+

+	return false, nil

+}

new file mode 100644

@@ -0,0 +1,671 @@

+package controller

+

+import (

+	"encoding/json"

+	"fmt"

+	"testing"

+	"time"

+

+	unidlingapi "github.com/openshift/origin/pkg/unidling/api"

+

+	deployapi "github.com/openshift/origin/pkg/deploy/api"

+	deployfake "github.com/openshift/origin/pkg/deploy/client/clientset_generated/internalclientset/fake"

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

+	"k8s.io/kubernetes/pkg/api/errors"

+	kunversioned "k8s.io/kubernetes/pkg/api/unversioned"

+	kextapi "k8s.io/kubernetes/pkg/apis/extensions"

+	kfake "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake"

+	ktestingcore "k8s.io/kubernetes/pkg/client/testing/core"

+	"k8s.io/kubernetes/pkg/runtime"

+	"k8s.io/kubernetes/pkg/types"

+)

+

+type fakeResults struct {

+	resMap       map[unidlingapi.CrossGroupObjectReference]kextapi.Scale

+	resEndpoints *kapi.Endpoints

+}

+

+func prepFakeClient(t *testing.T, nowTime time.Time, scales ...kextapi.Scale) (*kfake.Clientset, *deployfake.Clientset, *fakeResults) {

+	fakeClient := &kfake.Clientset{}

+	fakeDeployClient := &deployfake.Clientset{}

+

+	nowTimeStr := nowTime.Format(time.RFC3339)

+

+	targets := make([]unidlingapi.RecordedScaleReference, len(scales))

+	for i, scale := range scales {

+		targets[i] = unidlingapi.RecordedScaleReference{

+			CrossGroupObjectReference: unidlingapi.CrossGroupObjectReference{

+				Name: scale.Name,

+				Kind: scale.Kind,

+			},

+			Replicas: 2,

+		}

+	}

+	targetsAnnotation, err := json.Marshal(targets)

+	if err != nil {

+		t.Fatalf("unexpected error: %v", err)

+	}

+

+	endpointsObj := kapi.Endpoints{

+		ObjectMeta: kapi.ObjectMeta{

+			Name: "somesvc",

+			Annotations: map[string]string{

+				unidlingapi.IdledAtAnnotation:      nowTimeStr,

+				unidlingapi.UnidleTargetAnnotation: string(targetsAnnotation),

+			},

+		},

+	}

+	fakeClient.PrependReactor("get", "endpoints", func(action ktestingcore.Action) (bool, runtime.Object, error) {

+		if action.(ktestingcore.GetAction).GetName() == endpointsObj.Name {

+			return true, &endpointsObj, nil

+		}

+

+		return false, nil, nil

+	})

+

+	fakeDeployClient.PrependReactor("get", "deploymentconfigs", func(action ktestingcore.Action) (bool, runtime.Object, error) {

+		objName := action.(ktestingcore.GetAction).GetName()

+		for _, scale := range scales {

+			if scale.Kind == "DeploymentConfig" && objName == scale.Name {

+				return true, &deployapi.DeploymentConfig{

+					ObjectMeta: kapi.ObjectMeta{

+						Name: objName,

+					},

+					Spec: deployapi.DeploymentConfigSpec{

+						Replicas: scale.Spec.Replicas,

+					},

+				}, nil

+			}

+		}

+

+		return true, nil, errors.NewNotFound(action.GetResource().GroupResource(), objName)

+	})

+

+	fakeClient.PrependReactor("get", "replicationcontrollers", func(action ktestingcore.Action) (bool, runtime.Object, error) {

+		objName := action.(ktestingcore.GetAction).GetName()

+		for _, scale := range scales {

+			if scale.Kind == "ReplicationController" && objName == scale.Name {

+				return true, &kapi.ReplicationController{

+					ObjectMeta: kapi.ObjectMeta{

+						Name: objName,

+					},

+					Spec: kapi.ReplicationControllerSpec{

+						Replicas: scale.Spec.Replicas,

+					},

+				}, nil

+			}

+		}

+

+		return true, nil, errors.NewNotFound(action.GetResource().GroupResource(), objName)

+	})

+

+	res := &fakeResults{

+		resMap: make(map[unidlingapi.CrossGroupObjectReference]kextapi.Scale),

+	}

+

+	fakeDeployClient.PrependReactor("update", "deploymentconfigs", func(action ktestingcore.Action) (bool, runtime.Object, error) {

+		obj := action.(ktestingcore.UpdateAction).GetObject().(*deployapi.DeploymentConfig)

+		for _, scale := range scales {

+			if scale.Kind == "DeploymentConfig" && obj.Name == scale.Name {

+				newScale := scale

+				newScale.Spec.Replicas = obj.Spec.Replicas

+				res.resMap[unidlingapi.CrossGroupObjectReference{Name: obj.Name, Kind: "DeploymentConfig"}] = newScale

+				return true, &deployapi.DeploymentConfig{}, nil

+			}

+		}

+

+		return true, nil, errors.NewNotFound(action.GetResource().GroupResource(), obj.Name)

+	})

+

+	fakeClient.PrependReactor("update", "replicationcontrollers", func(action ktestingcore.Action) (bool, runtime.Object, error) {

+		obj := action.(ktestingcore.UpdateAction).GetObject().(*kapi.ReplicationController)

+		for _, scale := range scales {

+			if scale.Kind == "ReplicationController" && obj.Name == scale.Name {

+				newScale := scale

+				newScale.Spec.Replicas = obj.Spec.Replicas

+				res.resMap[unidlingapi.CrossGroupObjectReference{Name: obj.Name, Kind: "ReplicationController"}] = newScale

+				return true, &kapi.ReplicationController{}, nil

+			}

+		}

+

+		return true, nil, errors.NewNotFound(action.GetResource().GroupResource(), obj.Name)

+	})

+

+	fakeClient.AddReactor("*", "endpoints", func(action ktestingcore.Action) (bool, runtime.Object, error) {

+		obj := action.(ktestingcore.UpdateAction).GetObject().(*kapi.Endpoints)

+		if obj.Name != endpointsObj.Name {

+			return false, nil, nil

+		}

+

+		res.resEndpoints = obj

+

+		return true, obj, nil

+	})

+

+	return fakeClient, fakeDeployClient, res

+}

+

+func TestControllerHandlesStaleEvents(t *testing.T) {

+	nowTime := time.Now().Truncate(time.Second)

+	fakeClient, fakeDeployClient, res := prepFakeClient(t, nowTime)

+	controller := &UnidlingController{

+		scaleNamespacer:     fakeClient.Extensions(),

+		endpointsNamespacer: fakeClient.Core(),

+		rcNamespacer:        fakeClient.Core(),

+		dcNamespacer:        fakeDeployClient.Core(),

+	}

+

+	retry, err := controller.handleRequest(types.NamespacedName{

+		Namespace: "somens",

+		Name:      "somesvc",

+	}, nowTime.Add(-10*time.Second))

+

+	if err != nil {

+		t.Fatalf("Unable to unidle: unexpected error (retry: %v): %v", retry, err)

+	}

+

+	if len(res.resMap) != 0 {

+		t.Errorf("Did not expect to have anything scaled, but got %v", res.resMap)

+	}

+

+	if res.resEndpoints != nil {

+		t.Errorf("Did not expect to have endpoints object updated, but got %v", res.resEndpoints)

+	}

+}

+

+func TestControllerIgnoresAlreadyScaledObjects(t *testing.T) {

+	// truncate to avoid conversion comparison issues

+	nowTime := time.Now().Truncate(time.Second)

+	baseScales := []kextapi.Scale{

+		{

+			ObjectMeta: kapi.ObjectMeta{

+				Name: "somerc",

+			},

+			TypeMeta: kunversioned.TypeMeta{

+				Kind: "ReplicationController",

+			},

+			Spec: kextapi.ScaleSpec{

+				Replicas: 0,

+			},

+		},

+		{

+			ObjectMeta: kapi.ObjectMeta{

+				Name: "somedc",

+			},

+			TypeMeta: kunversioned.TypeMeta{

+				Kind: "DeploymentConfig",

+			},

+			Spec: kextapi.ScaleSpec{

+				Replicas: 5,

+			},

+		},

+	}

+

+	idledTime := nowTime.Add(-10 * time.Second)

+	fakeClient, fakeDeployClient, res := prepFakeClient(t, idledTime, baseScales...)

+

+	controller := &UnidlingController{

+		scaleNamespacer:     fakeClient.Extensions(),

+		endpointsNamespacer: fakeClient.Core(),

+		rcNamespacer:        fakeClient.Core(),

+		dcNamespacer:        fakeDeployClient.Core(),

+	}

+

+	retry, err := controller.handleRequest(types.NamespacedName{

+		Namespace: "somens",

+		Name:      "somesvc",

+	}, nowTime)

+

+	if err != nil {

+		t.Fatalf("Unable to unidle: unexpected error (retry: %v): %v", retry, err)

+	}

+

+	if len(res.resMap) != 1 {

+		t.Errorf("Incorrect unidling results: got %v, expected to end up with 1 objects scaled to 1", res.resMap)

+	}

+

+	stillPresent := make(map[unidlingapi.CrossGroupObjectReference]struct{})

+

+	for _, scale := range baseScales {

+		scaleRef := unidlingapi.CrossGroupObjectReference{Kind: scale.Kind, Name: scale.Name}

+		resScale, ok := res.resMap[scaleRef]

+		if scale.Spec.Replicas != 0 {

+			stillPresent[scaleRef] = struct{}{}

+			if ok {

+				t.Errorf("Expected to %s %q to not have been scaled, but it was scaled to %v", scale.Kind, scale.Name, resScale.Spec.Replicas)

+			}

+			continue

+		} else if !ok {

+			t.Errorf("Expected to %s %q to have been scaled, but it was not", scale.Kind, scale.Name)

+			continue

+		}

+

+		if resScale.Spec.Replicas != 2 {

+			t.Errorf("Expected %s %q to have been scaled to 2, but it was scaled to %v", scale.Kind, scale.Name, resScale.Spec.Replicas)

+		}

+	}

+

+	if res.resEndpoints == nil {

+		t.Fatalf("Expected endpoints object to be updated, but it was not")

+	}

+

+	resTargetsRaw, hadTargets := res.resEndpoints.Annotations[unidlingapi.UnidleTargetAnnotation]

+	resIdledTimeRaw, hadIdledTime := res.resEndpoints.Annotations[unidlingapi.IdledAtAnnotation]

+

+	if !hadTargets {

+		t.Errorf("Expected targets annotation to still be present, but it was not")

+	}

+	var resTargets []unidlingapi.RecordedScaleReference

+	if err = json.Unmarshal([]byte(resTargetsRaw), &resTargets); err != nil {

+		t.Fatalf("Unexpected error: %v", err)

+	}

+	if len(resTargets) != len(stillPresent) {

+		t.Errorf("Expected the new target list to contain the unscaled scalables only, but it was %v", resTargets)

+	}

+	for _, target := range resTargets {

+		if _, ok := stillPresent[target.CrossGroupObjectReference]; !ok {

+			t.Errorf("Expected new target list to contain the unscaled scalables only, but it was %v", resTargets)

+		}

+	}

+

+	if !hadIdledTime {

+		t.Errorf("Expected idled-at annotation to still be present, but it was not")

+	}

+	resIdledTime, err := time.Parse(time.RFC3339, resIdledTimeRaw)

+	if err != nil {

+		t.Fatalf("Unexpected error: %v", err)

+	}

+	if !resIdledTime.Equal(idledTime) {

+		t.Errorf("Expected output idled time annotation to be %s, but was changed to %s", idledTime, resIdledTime)

+	}

+}

+

+func TestControllerUnidlesProperly(t *testing.T) {

+	nowTime := time.Now().Truncate(time.Second)

+	baseScales := []kextapi.Scale{

+		{

+			ObjectMeta: kapi.ObjectMeta{

+				Name: "somerc",

+			},

+			TypeMeta: kunversioned.TypeMeta{

+				Kind: "ReplicationController",

+			},

+			Spec: kextapi.ScaleSpec{

+				Replicas: 0,

+			},

+		},

+		{

+			ObjectMeta: kapi.ObjectMeta{

+				Name: "somedc",

+			},

+			TypeMeta: kunversioned.TypeMeta{

+				Kind: "DeploymentConfig",

+			},

+			Spec: kextapi.ScaleSpec{

+				Replicas: 0,

+			},

+		},

+	}

+

+	fakeClient, fakeDeployClient, res := prepFakeClient(t, nowTime.Add(-10*time.Second), baseScales...)

+

+	controller := &UnidlingController{

+		scaleNamespacer:     fakeClient.Extensions(),

+		endpointsNamespacer: fakeClient.Core(),

+		rcNamespacer:        fakeClient.Core(),

+		dcNamespacer:        fakeDeployClient.Core(),

+	}

+

+	retry, err := controller.handleRequest(types.NamespacedName{

+		Namespace: "somens",

+		Name:      "somesvc",

+	}, nowTime)

+

+	if err != nil {

+		t.Fatalf("Unable to unidle: unexpected error (retry: %v): %v", retry, err)

+	}

+

+	if len(res.resMap) != len(baseScales) {

+		t.Errorf("Incorrect unidling results: got %v, expected to end up with %v objects scaled to 1", res.resMap, len(baseScales))

+	}

+

+	for _, scale := range baseScales {

+		resScale, ok := res.resMap[unidlingapi.CrossGroupObjectReference{Kind: scale.Kind, Name: scale.Name}]

+		if !ok {

+			t.Errorf("Expected to %s %q to have been scaled, but it was not", scale.Kind, scale.Name)

+			continue

+		}

+

+		if resScale.Spec.Replicas != 2 {

+			t.Errorf("Expected %s %q to have been scaled to 2, but it was scaled to %v", scale.Kind, scale.Name, resScale.Spec.Replicas)

+		}

+	}

+

+	if res.resEndpoints == nil {

+		t.Fatalf("Expected endpoints object to be updated, but it was not")

+	}

+

+	resTargets, hadTargets := res.resEndpoints.Annotations[unidlingapi.UnidleTargetAnnotation]

+	resIdledTime, hadIdledTime := res.resEndpoints.Annotations[unidlingapi.IdledAtAnnotation]

+

+	if hadTargets {

+		t.Errorf("Expected targets annotation to be removed, but it was %q", resTargets)

+	}

+

+	if hadIdledTime {

+		t.Errorf("Expected idled-at annotation to be removed, but it was %q", resIdledTime)

+	}

+}

+

+type failureTestInfo struct {

+	name                   string

+	endpointsGet           *kapi.Endpoints

+	scaleGets              []kextapi.Scale

+	scaleUpdatesNotFound   []bool

+	preventEndpointsUpdate bool

+

+	errorExpected       bool

+	retryExpected       bool

+	annotationsExpected map[string]string

+}

+

+func prepareFakeClientForFailureTest(test failureTestInfo) (*kfake.Clientset, *deployfake.Clientset) {