vendor files

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/BUILD

@@ -0,0 +1,107 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "horizontal.go",
+        "rate_limitters.go",
+        "replica_calculator.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/controller/podautoscaler",
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/api/v1/pod:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/podautoscaler/metrics:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/autoscaling/v1:go_default_library",
+        "//vendor/k8s.io/api/autoscaling/v2beta1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/equality:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/informers/autoscaling/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/scheme:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/typed/autoscaling/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/listers/autoscaling/v1:go_default_library",
+        "//vendor/k8s.io/client-go/scale:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/tools/record:go_default_library",
+        "//vendor/k8s.io/client-go/util/workqueue:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "horizontal_test.go",
+        "legacy_horizontal_test.go",
+        "legacy_replica_calculator_test.go",
+        "replica_calculator_test.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/controller/podautoscaler",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/apis/autoscaling:go_default_library",
+        "//pkg/apis/autoscaling/install:go_default_library",
+        "//pkg/apis/core/install:go_default_library",
+        "//pkg/apis/extensions/install:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/podautoscaler/metrics:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/github.com/stretchr/testify/require:go_default_library",
+        "//vendor/k8s.io/api/autoscaling/v1:go_default_library",
+        "//vendor/k8s.io/api/autoscaling/v2beta1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/fake:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/scale/fake:go_default_library",
+        "//vendor/k8s.io/client-go/testing:go_default_library",
+        "//vendor/k8s.io/heapster/metrics/api/v1/types:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/apis/metrics/v1alpha1:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/apis/metrics/v1beta1:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/client/clientset_generated/clientset/fake:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/client/custom_metrics/fake:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/controller/podautoscaler/metrics:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/OWNERS

@@ -0,0 +1,13 @@
+reviewers:
+- DirectXMan12
+- mwielgus
+- piosz
+- jszczepkowski
+- fgrzadkowski
+- MaciekPytel
+approvers:
+- DirectXMan12
+- mwielgus
+- piosz
+- jszczepkowski
+- MaciekPytel

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/doc.go

@@ -0,0 +1,19 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package podautoscaler contains logic for autoscaling number of
+// pods based on metrics observed.
+package podautoscaler // import "k8s.io/kubernetes/pkg/controller/podautoscaler"

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/horizontal.go

@@ -0,0 +1,711 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package podautoscaler
+
+import (
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/golang/glog"
+	autoscalingv1 "k8s.io/api/autoscaling/v1"
+	autoscalingv2 "k8s.io/api/autoscaling/v2beta1"
+	"k8s.io/api/core/v1"
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/api/errors"
+	apimeta "k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	"k8s.io/apimachinery/pkg/util/wait"
+	autoscalinginformers "k8s.io/client-go/informers/autoscaling/v1"
+	"k8s.io/client-go/kubernetes/scheme"
+	autoscalingclient "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
+	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
+	autoscalinglisters "k8s.io/client-go/listers/autoscaling/v1"
+	scaleclient "k8s.io/client-go/scale"
+	"k8s.io/client-go/tools/cache"
+	"k8s.io/client-go/tools/record"
+	"k8s.io/client-go/util/workqueue"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/controller"
+)
+
+var (
+	scaleUpLimitFactor  = 2.0
+	scaleUpLimitMinimum = 4.0
+)
+
+// HorizontalController is responsible for the synchronizing HPA objects stored
+// in the system with the actual deployments/replication controllers they
+// control.
+type HorizontalController struct {
+	scaleNamespacer scaleclient.ScalesGetter
+	hpaNamespacer   autoscalingclient.HorizontalPodAutoscalersGetter
+	mapper          apimeta.RESTMapper
+
+	replicaCalc   *ReplicaCalculator
+	eventRecorder record.EventRecorder
+
+	upscaleForbiddenWindow   time.Duration
+	downscaleForbiddenWindow time.Duration
+
+	// hpaLister is able to list/get HPAs from the shared cache from the informer passed in to
+	// NewHorizontalController.
+	hpaLister       autoscalinglisters.HorizontalPodAutoscalerLister
+	hpaListerSynced cache.InformerSynced
+
+	// Controllers that need to be synced
+	queue workqueue.RateLimitingInterface
+}
+
+// NewHorizontalController creates a new HorizontalController.
+func NewHorizontalController(
+	evtNamespacer v1core.EventsGetter,
+	scaleNamespacer scaleclient.ScalesGetter,
+	hpaNamespacer autoscalingclient.HorizontalPodAutoscalersGetter,
+	mapper apimeta.RESTMapper,
+	replicaCalc *ReplicaCalculator,
+	hpaInformer autoscalinginformers.HorizontalPodAutoscalerInformer,
+	resyncPeriod time.Duration,
+	upscaleForbiddenWindow time.Duration,
+	downscaleForbiddenWindow time.Duration,
+
+) *HorizontalController {
+	broadcaster := record.NewBroadcaster()
+	broadcaster.StartLogging(glog.Infof)
+	// TODO: remove the wrapper when every clients have moved to use the clientset.
+	broadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: evtNamespacer.Events("")})
+	recorder := broadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "horizontal-pod-autoscaler"})
+
+	hpaController := &HorizontalController{
+		replicaCalc:              replicaCalc,
+		eventRecorder:            recorder,
+		scaleNamespacer:          scaleNamespacer,
+		hpaNamespacer:            hpaNamespacer,
+		upscaleForbiddenWindow:   upscaleForbiddenWindow,
+		downscaleForbiddenWindow: downscaleForbiddenWindow,
+		queue:  workqueue.NewNamedRateLimitingQueue(NewDefaultHPARateLimiter(resyncPeriod), "horizontalpodautoscaler"),
+		mapper: mapper,
+	}
+
+	hpaInformer.Informer().AddEventHandlerWithResyncPeriod(
+		cache.ResourceEventHandlerFuncs{
+			AddFunc:    hpaController.enqueueHPA,
+			UpdateFunc: hpaController.updateHPA,
+			DeleteFunc: hpaController.deleteHPA,
+		},
+		resyncPeriod,
+	)
+	hpaController.hpaLister = hpaInformer.Lister()
+	hpaController.hpaListerSynced = hpaInformer.Informer().HasSynced
+
+	return hpaController
+}
+
+// Run begins watching and syncing.
+func (a *HorizontalController) Run(stopCh <-chan struct{}) {
+	defer utilruntime.HandleCrash()
+	defer a.queue.ShutDown()
+
+	glog.Infof("Starting HPA controller")
+	defer glog.Infof("Shutting down HPA controller")
+
+	if !controller.WaitForCacheSync("HPA", stopCh, a.hpaListerSynced) {
+		return
+	}
+
+	// start a single worker (we may wish to start more in the future)
+	go wait.Until(a.worker, time.Second, stopCh)
+
+	<-stopCh
+}
+
+// obj could be an *v1.HorizontalPodAutoscaler, or a DeletionFinalStateUnknown marker item.
+func (a *HorizontalController) updateHPA(old, cur interface{}) {
+	a.enqueueHPA(cur)
+}
+
+// obj could be an *v1.HorizontalPodAutoscaler, or a DeletionFinalStateUnknown marker item.
+func (a *HorizontalController) enqueueHPA(obj interface{}) {
+	key, err := controller.KeyFunc(obj)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("couldn't get key for object %+v: %v", obj, err))
+		return
+	}
+
+	// always add rate-limitted so we don't fetch metrics more that once per resync interval
+	a.queue.AddRateLimited(key)
+}
+
+func (a *HorizontalController) deleteHPA(obj interface{}) {
+	key, err := controller.KeyFunc(obj)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("couldn't get key for object %+v: %v", obj, err))
+		return
+	}
+
+	// TODO: could we leak if we fail to get the key?
+	a.queue.Forget(key)
+}
+
+func (a *HorizontalController) worker() {
+	for a.processNextWorkItem() {
+	}
+	glog.Infof("horizontal pod autoscaler controller worker shutting down")
+}
+
+func (a *HorizontalController) processNextWorkItem() bool {
+	key, quit := a.queue.Get()
+	if quit {
+		return false
+	}
+	defer a.queue.Done(key)
+
+	err := a.reconcileKey(key.(string))
+	if err == nil {
+		// don't "forget" here because we want to only process a given HPA once per resync interval
+		return true
+	}
+
+	a.queue.AddRateLimited(key)
+	utilruntime.HandleError(err)
+	return true
+}
+
+// Computes the desired number of replicas for the metric specifications listed in the HPA, returning the maximum
+// of the computed replica counts, a description of the associated metric, and the statuses of all metrics
+// computed.
+func (a *HorizontalController) computeReplicasForMetrics(hpa *autoscalingv2.HorizontalPodAutoscaler, scale *autoscalingv1.Scale,
+	metricSpecs []autoscalingv2.MetricSpec) (replicas int32, metric string, statuses []autoscalingv2.MetricStatus, timestamp time.Time, err error) {
+
+	currentReplicas := scale.Status.Replicas
+
+	statuses = make([]autoscalingv2.MetricStatus, len(metricSpecs))
+
+	for i, metricSpec := range metricSpecs {
+		if scale.Status.Selector == "" {
+			errMsg := "selector is required"
+			a.eventRecorder.Event(hpa, v1.EventTypeWarning, "SelectorRequired", errMsg)
+			setCondition(hpa, autoscalingv2.ScalingActive, v1.ConditionFalse, "InvalidSelector", "the HPA target's scale is missing a selector")
+			return 0, "", nil, time.Time{}, fmt.Errorf(errMsg)
+		}
+
+		selector, err := labels.Parse(scale.Status.Selector)
+		if err != nil {
+			errMsg := fmt.Sprintf("couldn't convert selector into a corresponding internal selector object: %v", err)
+			a.eventRecorder.Event(hpa, v1.EventTypeWarning, "InvalidSelector", errMsg)
+			setCondition(hpa, autoscalingv2.ScalingActive, v1.ConditionFalse, "InvalidSelector", errMsg)
+			return 0, "", nil, time.Time{}, fmt.Errorf(errMsg)
+		}
+
+		var replicaCountProposal int32
+		var utilizationProposal int64
+		var timestampProposal time.Time
+		var metricNameProposal string
+
+		switch metricSpec.Type {
+		case autoscalingv2.ObjectMetricSourceType:
+			replicaCountProposal, utilizationProposal, timestampProposal, err = a.replicaCalc.GetObjectMetricReplicas(currentReplicas, metricSpec.Object.TargetValue.MilliValue(), metricSpec.Object.MetricName, hpa.Namespace, &metricSpec.Object.Target)
+			if err != nil {
+				a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedGetObjectMetric", err.Error())
+				setCondition(hpa, autoscalingv2.ScalingActive, v1.ConditionFalse, "FailedGetObjectMetric", "the HPA was unable to compute the replica count: %v", err)
+				return 0, "", nil, time.Time{}, fmt.Errorf("failed to get object metric value: %v", err)
+			}
+			metricNameProposal = fmt.Sprintf("%s metric %s", metricSpec.Object.Target.Kind, metricSpec.Object.MetricName)
+			statuses[i] = autoscalingv2.MetricStatus{
+				Type: autoscalingv2.ObjectMetricSourceType,
+				Object: &autoscalingv2.ObjectMetricStatus{
+					Target:       metricSpec.Object.Target,
+					MetricName:   metricSpec.Object.MetricName,
+					CurrentValue: *resource.NewMilliQuantity(utilizationProposal, resource.DecimalSI),
+				},
+			}
+		case autoscalingv2.PodsMetricSourceType:
+			replicaCountProposal, utilizationProposal, timestampProposal, err = a.replicaCalc.GetMetricReplicas(currentReplicas, metricSpec.Pods.TargetAverageValue.MilliValue(), metricSpec.Pods.MetricName, hpa.Namespace, selector)
+			if err != nil {
+				a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedGetPodsMetric", err.Error())
+				setCondition(hpa, autoscalingv2.ScalingActive, v1.ConditionFalse, "FailedGetPodsMetric", "the HPA was unable to compute the replica count: %v", err)
+				return 0, "", nil, time.Time{}, fmt.Errorf("failed to get pods metric value: %v", err)
+			}
+			metricNameProposal = fmt.Sprintf("pods metric %s", metricSpec.Pods.MetricName)
+			statuses[i] = autoscalingv2.MetricStatus{
+				Type: autoscalingv2.PodsMetricSourceType,
+				Pods: &autoscalingv2.PodsMetricStatus{
+					MetricName:          metricSpec.Pods.MetricName,
+					CurrentAverageValue: *resource.NewMilliQuantity(utilizationProposal, resource.DecimalSI),
+				},
+			}
+		case autoscalingv2.ResourceMetricSourceType:
+			if metricSpec.Resource.TargetAverageValue != nil {
+				var rawProposal int64
+				replicaCountProposal, rawProposal, timestampProposal, err = a.replicaCalc.GetRawResourceReplicas(currentReplicas, metricSpec.Resource.TargetAverageValue.MilliValue(), metricSpec.Resource.Name, hpa.Namespace, selector)
+				if err != nil {
+					a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedGetResourceMetric", err.Error())
+					setCondition(hpa, autoscalingv2.ScalingActive, v1.ConditionFalse, "FailedGetResourceMetric", "the HPA was unable to compute the replica count: %v", err)
+					return 0, "", nil, time.Time{}, fmt.Errorf("failed to get %s utilization: %v", metricSpec.Resource.Name, err)
+				}
+				metricNameProposal = fmt.Sprintf("%s resource", metricSpec.Resource.Name)
+				statuses[i] = autoscalingv2.MetricStatus{
+					Type: autoscalingv2.ResourceMetricSourceType,
+					Resource: &autoscalingv2.ResourceMetricStatus{
+						Name:                metricSpec.Resource.Name,
+						CurrentAverageValue: *resource.NewMilliQuantity(rawProposal, resource.DecimalSI),
+					},
+				}
+			} else {
+				// set a default utilization percentage if none is set
+				if metricSpec.Resource.TargetAverageUtilization == nil {
+					errMsg := "invalid resource metric source: neither a utilization target nor a value target was set"
+					a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedGetResourceMetric", errMsg)
+					setCondition(hpa, autoscalingv2.ScalingActive, v1.ConditionFalse, "FailedGetResourceMetric", "the HPA was unable to compute the replica count: %s", errMsg)
+					return 0, "", nil, time.Time{}, fmt.Errorf(errMsg)
+				}
+
+				targetUtilization := *metricSpec.Resource.TargetAverageUtilization
+
+				var percentageProposal int32
+				var rawProposal int64
+				replicaCountProposal, percentageProposal, rawProposal, timestampProposal, err = a.replicaCalc.GetResourceReplicas(currentReplicas, targetUtilization, metricSpec.Resource.Name, hpa.Namespace, selector)
+				if err != nil {
+					a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedGetResourceMetric", err.Error())
+					setCondition(hpa, autoscalingv2.ScalingActive, v1.ConditionFalse, "FailedGetResourceMetric", "the HPA was unable to compute the replica count: %v", err)
+					return 0, "", nil, time.Time{}, fmt.Errorf("failed to get %s utilization: %v", metricSpec.Resource.Name, err)
+				}
+				metricNameProposal = fmt.Sprintf("%s resource utilization (percentage of request)", metricSpec.Resource.Name)
+				statuses[i] = autoscalingv2.MetricStatus{
+					Type: autoscalingv2.ResourceMetricSourceType,
+					Resource: &autoscalingv2.ResourceMetricStatus{
+						Name: metricSpec.Resource.Name,
+						CurrentAverageUtilization: &percentageProposal,
+						CurrentAverageValue:       *resource.NewMilliQuantity(rawProposal, resource.DecimalSI),
+					},
+				}
+			}
+		default:
+			errMsg := fmt.Sprintf("unknown metric source type %q", string(metricSpec.Type))
+			a.eventRecorder.Event(hpa, v1.EventTypeWarning, "InvalidMetricSourceType", errMsg)
+			setCondition(hpa, autoscalingv2.ScalingActive, v1.ConditionFalse, "InvalidMetricSourceType", "the HPA was unable to compute the replica count: %s", errMsg)
+			return 0, "", nil, time.Time{}, fmt.Errorf(errMsg)
+		}
+
+		if replicas == 0 || replicaCountProposal > replicas {
+			timestamp = timestampProposal
+			replicas = replicaCountProposal
+			metric = metricNameProposal
+		}
+	}
+
+	setCondition(hpa, autoscalingv2.ScalingActive, v1.ConditionTrue, "ValidMetricFound", "the HPA was able to succesfully calculate a replica count from %s", metric)
+	return replicas, metric, statuses, timestamp, nil
+}
+
+func (a *HorizontalController) reconcileKey(key string) error {
+	namespace, name, err := cache.SplitMetaNamespaceKey(key)
+	if err != nil {
+		return err
+	}
+
+	hpa, err := a.hpaLister.HorizontalPodAutoscalers(namespace).Get(name)
+	if errors.IsNotFound(err) {
+		glog.Infof("Horizontal Pod Autoscaler has been deleted %v", key)
+		return nil
+	}
+
+	return a.reconcileAutoscaler(hpa)
+}
+
+func (a *HorizontalController) reconcileAutoscaler(hpav1Shared *autoscalingv1.HorizontalPodAutoscaler) error {
+	// make a copy so that we never mutate the shared informer cache (conversion can mutate the object)
+	hpav1 := hpav1Shared.DeepCopy()
+	// then, convert to autoscaling/v2, which makes our lives easier when calculating metrics
+	hpaRaw, err := unsafeConvertToVersionVia(hpav1, autoscalingv2.SchemeGroupVersion)
+	if err != nil {
+		a.eventRecorder.Event(hpav1, v1.EventTypeWarning, "FailedConvertHPA", err.Error())
+		return fmt.Errorf("failed to convert the given HPA to %s: %v", autoscalingv2.SchemeGroupVersion.String(), err)
+	}
+	hpa := hpaRaw.(*autoscalingv2.HorizontalPodAutoscaler)
+	hpaStatusOriginal := hpa.Status.DeepCopy()
+
+	reference := fmt.Sprintf("%s/%s/%s", hpa.Spec.ScaleTargetRef.Kind, hpa.Namespace, hpa.Spec.ScaleTargetRef.Name)
+
+	targetGV, err := schema.ParseGroupVersion(hpa.Spec.ScaleTargetRef.APIVersion)
+	if err != nil {
+		a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedGetScale", err.Error())
+		setCondition(hpa, autoscalingv2.AbleToScale, v1.ConditionFalse, "FailedGetScale", "the HPA controller was unable to get the target's current scale: %v", err)
+		a.updateStatusIfNeeded(hpaStatusOriginal, hpa)
+		return fmt.Errorf("invalid API version in scale target reference: %v", err)
+	}
+
+	targetGK := schema.GroupKind{
+		Group: targetGV.Group,
+		Kind:  hpa.Spec.ScaleTargetRef.Kind,
+	}
+
+	mappings, err := a.mapper.RESTMappings(targetGK)
+	if err != nil {
+		a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedGetScale", err.Error())
+		setCondition(hpa, autoscalingv2.AbleToScale, v1.ConditionFalse, "FailedGetScale", "the HPA controller was unable to get the target's current scale: %v", err)
+		a.updateStatusIfNeeded(hpaStatusOriginal, hpa)
+		return fmt.Errorf("unable to determine resource for scale target reference: %v", err)
+	}
+
+	scale, targetGR, err := a.scaleForResourceMappings(hpa.Namespace, hpa.Spec.ScaleTargetRef.Name, mappings)
+	if err != nil {
+		a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedGetScale", err.Error())
+		setCondition(hpa, autoscalingv2.AbleToScale, v1.ConditionFalse, "FailedGetScale", "the HPA controller was unable to get the target's current scale: %v", err)
+		a.updateStatusIfNeeded(hpaStatusOriginal, hpa)
+		return fmt.Errorf("failed to query scale subresource for %s: %v", reference, err)
+	}
+	setCondition(hpa, autoscalingv2.AbleToScale, v1.ConditionTrue, "SucceededGetScale", "the HPA controller was able to get the target's current scale")
+	currentReplicas := scale.Status.Replicas
+
+	var metricStatuses []autoscalingv2.MetricStatus
+	metricDesiredReplicas := int32(0)
+	metricName := ""
+	metricTimestamp := time.Time{}
+
+	desiredReplicas := int32(0)
+	rescaleReason := ""
+	timestamp := time.Now()
+
+	rescale := true
+
+	if scale.Spec.Replicas == 0 {
+		// Autoscaling is disabled for this resource
+		desiredReplicas = 0
+		rescale = false
+		setCondition(hpa, autoscalingv2.ScalingActive, v1.ConditionFalse, "ScalingDisabled", "scaling is disabled since the replica count of the target is zero")
+	} else if currentReplicas > hpa.Spec.MaxReplicas {
+		rescaleReason = "Current number of replicas above Spec.MaxReplicas"
+		desiredReplicas = hpa.Spec.MaxReplicas
+	} else if hpa.Spec.MinReplicas != nil && currentReplicas < *hpa.Spec.MinReplicas {
+		rescaleReason = "Current number of replicas below Spec.MinReplicas"
+		desiredReplicas = *hpa.Spec.MinReplicas
+	} else if currentReplicas == 0 {
+		rescaleReason = "Current number of replicas must be greater than 0"
+		desiredReplicas = 1
+	} else {
+		metricDesiredReplicas, metricName, metricStatuses, metricTimestamp, err = a.computeReplicasForMetrics(hpa, scale, hpa.Spec.Metrics)
+		if err != nil {
+			a.setCurrentReplicasInStatus(hpa, currentReplicas)
+			if err := a.updateStatusIfNeeded(hpaStatusOriginal, hpa); err != nil {
+				utilruntime.HandleError(err)
+			}
+			a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedComputeMetricsReplicas", err.Error())
+			return fmt.Errorf("failed to compute desired number of replicas based on listed metrics for %s: %v", reference, err)
+		}
+
+		glog.V(4).Infof("proposing %v desired replicas (based on %s from %s) for %s", metricDesiredReplicas, metricName, timestamp, reference)
+
+		rescaleMetric := ""
+		if metricDesiredReplicas > desiredReplicas {
+			desiredReplicas = metricDesiredReplicas
+			timestamp = metricTimestamp
+			rescaleMetric = metricName
+		}
+		if desiredReplicas > currentReplicas {
+			rescaleReason = fmt.Sprintf("%s above target", rescaleMetric)
+		}
+		if desiredReplicas < currentReplicas {
+			rescaleReason = "All metrics below target"
+		}
+
+		desiredReplicas = a.normalizeDesiredReplicas(hpa, currentReplicas, desiredReplicas)
+
+		rescale = a.shouldScale(hpa, currentReplicas, desiredReplicas, timestamp)
+		backoffDown := false
+		backoffUp := false
+		if hpa.Status.LastScaleTime != nil {
+			if !hpa.Status.LastScaleTime.Add(a.downscaleForbiddenWindow).Before(timestamp) {
+				setCondition(hpa, autoscalingv2.AbleToScale, v1.ConditionFalse, "BackoffDownscale", "the time since the previous scale is still within the downscale forbidden window")
+				backoffDown = true
+			}
+
+			if !hpa.Status.LastScaleTime.Add(a.upscaleForbiddenWindow).Before(timestamp) {
+				backoffUp = true
+				if backoffDown {
+					setCondition(hpa, autoscalingv2.AbleToScale, v1.ConditionFalse, "BackoffBoth", "the time since the previous scale is still within both the downscale and upscale forbidden windows")
+				} else {
+					setCondition(hpa, autoscalingv2.AbleToScale, v1.ConditionFalse, "BackoffUpscale", "the time since the previous scale is still within the upscale forbidden window")
+				}
+			}
+		}
+
+		if !backoffDown && !backoffUp {
+			// mark that we're not backing off
+			setCondition(hpa, autoscalingv2.AbleToScale, v1.ConditionTrue, "ReadyForNewScale", "the last scale time was sufficiently old as to warrant a new scale")
+		}
+
+	}
+
+	if rescale {
+		scale.Spec.Replicas = desiredReplicas
+		_, err = a.scaleNamespacer.Scales(hpa.Namespace).Update(targetGR, scale)
+		if err != nil {
+			a.eventRecorder.Eventf(hpa, v1.EventTypeWarning, "FailedRescale", "New size: %d; reason: %s; error: %v", desiredReplicas, rescaleReason, err.Error())
+			setCondition(hpa, autoscalingv2.AbleToScale, v1.ConditionFalse, "FailedUpdateScale", "the HPA controller was unable to update the target scale: %v", err)
+			a.setCurrentReplicasInStatus(hpa, currentReplicas)
+			if err := a.updateStatusIfNeeded(hpaStatusOriginal, hpa); err != nil {
+				utilruntime.HandleError(err)
+			}
+			return fmt.Errorf("failed to rescale %s: %v", reference, err)
+		}
+		setCondition(hpa, autoscalingv2.AbleToScale, v1.ConditionTrue, "SucceededRescale", "the HPA controller was able to update the target scale to %d", desiredReplicas)
+		a.eventRecorder.Eventf(hpa, v1.EventTypeNormal, "SuccessfulRescale", "New size: %d; reason: %s", desiredReplicas, rescaleReason)
+		glog.Infof("Successful rescale of %s, old size: %d, new size: %d, reason: %s",
+			hpa.Name, currentReplicas, desiredReplicas, rescaleReason)
+	} else {
+		glog.V(4).Infof("decided not to scale %s to %v (last scale time was %s)", reference, desiredReplicas, hpa.Status.LastScaleTime)
+		desiredReplicas = currentReplicas
+	}
+
+	a.setStatus(hpa, currentReplicas, desiredReplicas, metricStatuses, rescale)
+	return a.updateStatusIfNeeded(hpaStatusOriginal, hpa)
+}
+
+// normalizeDesiredReplicas takes the metrics desired replicas value and normalizes it based on the appropriate conditions (i.e. < maxReplicas, >
+// minReplicas, etc...)
+func (a *HorizontalController) normalizeDesiredReplicas(hpa *autoscalingv2.HorizontalPodAutoscaler, currentReplicas int32, prenormalizedDesiredReplicas int32) int32 {
+	var minReplicas int32
+	if hpa.Spec.MinReplicas != nil {
+		minReplicas = *hpa.Spec.MinReplicas
+	} else {
+		minReplicas = 0
+	}
+
+	desiredReplicas, condition, reason := convertDesiredReplicasWithRules(currentReplicas, prenormalizedDesiredReplicas, minReplicas, hpa.Spec.MaxReplicas)
+
+	if desiredReplicas == prenormalizedDesiredReplicas {
+		setCondition(hpa, autoscalingv2.ScalingLimited, v1.ConditionFalse, condition, reason)
+	} else {
+		setCondition(hpa, autoscalingv2.ScalingLimited, v1.ConditionTrue, condition, reason)
+	}
+
+	return desiredReplicas
+}
+
+// convertDesiredReplicas performs the actual normalization, without depending on `HorizontalController` or `HorizontalPodAutoscaler`
+func convertDesiredReplicasWithRules(currentReplicas, desiredReplicas, hpaMinReplicas, hpaMaxReplicas int32) (int32, string, string) {
+
+	var minimumAllowedReplicas int32
+	var maximumAllowedReplicas int32
+
+	var possibleLimitingCondition string
+	var possibleLimitingReason string
+
+	if hpaMinReplicas == 0 {
+		minimumAllowedReplicas = 1
+		possibleLimitingReason = "the desired replica count is zero"
+	} else {
+		minimumAllowedReplicas = hpaMinReplicas
+		possibleLimitingReason = "the desired replica count is less than the minimum replica count"
+	}
+
+	// Do not upscale too much to prevent incorrect rapid increase of the number of master replicas caused by
+	// bogus CPU usage report from heapster/kubelet (like in issue #32304).
+	scaleUpLimit := calculateScaleUpLimit(currentReplicas)
+
+	if hpaMaxReplicas > scaleUpLimit {
+		maximumAllowedReplicas = scaleUpLimit
+
+		possibleLimitingCondition = "ScaleUpLimit"
+		possibleLimitingReason = "the desired replica count is increasing faster than the maximum scale rate"
+	} else {
+		maximumAllowedReplicas = hpaMaxReplicas
+
+		possibleLimitingCondition = "TooManyReplicas"
+		possibleLimitingReason = "the desired replica count is more than the maximum replica count"
+	}
+
+	if desiredReplicas < minimumAllowedReplicas {
+		possibleLimitingCondition = "TooFewReplicas"
+
+		return minimumAllowedReplicas, possibleLimitingCondition, possibleLimitingReason
+	} else if desiredReplicas > maximumAllowedReplicas {
+		return maximumAllowedReplicas, possibleLimitingCondition, possibleLimitingReason
+	}
+
+	return desiredReplicas, "DesiredWithinRange", "the desired count is within the acceptable range"
+}
+
+func calculateScaleUpLimit(currentReplicas int32) int32 {
+	return int32(math.Max(scaleUpLimitFactor*float64(currentReplicas), scaleUpLimitMinimum))
+}
+
+func (a *HorizontalController) shouldScale(hpa *autoscalingv2.HorizontalPodAutoscaler, currentReplicas, desiredReplicas int32, timestamp time.Time) bool {
+	if desiredReplicas == currentReplicas {
+		return false
+	}
+
+	if hpa.Status.LastScaleTime == nil {
+		return true
+	}
+
+	// Going down only if the usageRatio dropped significantly below the target
+	// and there was no rescaling in the last downscaleForbiddenWindow.
+	if desiredReplicas < currentReplicas && hpa.Status.LastScaleTime.Add(a.downscaleForbiddenWindow).Before(timestamp) {
+		return true
+	}
+
+	// Going up only if the usage ratio increased significantly above the target
+	// and there was no rescaling in the last upscaleForbiddenWindow.
+	if desiredReplicas > currentReplicas && hpa.Status.LastScaleTime.Add(a.upscaleForbiddenWindow).Before(timestamp) {
+		return true
+	}
+
+	return false
+}
+
+// scaleForResourceMappings attempts to fetch the scale for the
+// resource with the given name and namespace, trying each RESTMapping
+// in turn until a working one is found.  If none work, the first error
+// is returned.  It returns both the scale, as well as the group-resource from
+// the working mapping.
+func (a *HorizontalController) scaleForResourceMappings(namespace, name string, mappings []*apimeta.RESTMapping) (*autoscalingv1.Scale, schema.GroupResource, error) {
+	var firstErr error
+	for i, mapping := range mappings {
+		targetGR := mapping.GroupVersionKind.GroupVersion().WithResource(mapping.Resource).GroupResource()
+		scale, err := a.scaleNamespacer.Scales(namespace).Get(targetGR, name)
+		if err == nil {
+			return scale, targetGR, nil
+		}
+
+		// if this is the first error, remember it,
+		// then go on and try other mappings until we find a good one
+		if i == 0 {
+			firstErr = err
+		}
+	}
+
+	// make sure we handle an empty set of mappings
+	if firstErr == nil {
+		firstErr = fmt.Errorf("unrecognized resource")
+	}
+
+	return nil, schema.GroupResource{}, firstErr
+}
+
+// setCurrentReplicasInStatus sets the current replica count in the status of the HPA.
+func (a *HorizontalController) setCurrentReplicasInStatus(hpa *autoscalingv2.HorizontalPodAutoscaler, currentReplicas int32) {
+	a.setStatus(hpa, currentReplicas, hpa.Status.DesiredReplicas, hpa.Status.CurrentMetrics, false)
+}
+
+// setStatus recreates the status of the given HPA, updating the current and
+// desired replicas, as well as the metric statuses
+func (a *HorizontalController) setStatus(hpa *autoscalingv2.HorizontalPodAutoscaler, currentReplicas, desiredReplicas int32, metricStatuses []autoscalingv2.MetricStatus, rescale bool) {
+	hpa.Status = autoscalingv2.HorizontalPodAutoscalerStatus{
+		CurrentReplicas: currentReplicas,
+		DesiredReplicas: desiredReplicas,
+		LastScaleTime:   hpa.Status.LastScaleTime,
+		CurrentMetrics:  metricStatuses,
+		Conditions:      hpa.Status.Conditions,
+	}
+
+	if rescale {
+		now := metav1.NewTime(time.Now())
+		hpa.Status.LastScaleTime = &now
+	}
+}
+
+// updateStatusIfNeeded calls updateStatus only if the status of the new HPA is not the same as the old status
+func (a *HorizontalController) updateStatusIfNeeded(oldStatus *autoscalingv2.HorizontalPodAutoscalerStatus, newHPA *autoscalingv2.HorizontalPodAutoscaler) error {
+	// skip a write if we wouldn't need to update
+	if apiequality.Semantic.DeepEqual(oldStatus, &newHPA.Status) {
+		return nil
+	}
+	return a.updateStatus(newHPA)
+}
+
+// updateStatus actually does the update request for the status of the given HPA
+func (a *HorizontalController) updateStatus(hpa *autoscalingv2.HorizontalPodAutoscaler) error {
+	// convert back to autoscalingv1
+	hpaRaw, err := unsafeConvertToVersionVia(hpa, autoscalingv1.SchemeGroupVersion)
+	if err != nil {
+		a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedConvertHPA", err.Error())
+		return fmt.Errorf("failed to convert the given HPA to %s: %v", autoscalingv2.SchemeGroupVersion.String(), err)
+	}
+	hpav1 := hpaRaw.(*autoscalingv1.HorizontalPodAutoscaler)
+
+	_, err = a.hpaNamespacer.HorizontalPodAutoscalers(hpav1.Namespace).UpdateStatus(hpav1)
+	if err != nil {
+		a.eventRecorder.Event(hpa, v1.EventTypeWarning, "FailedUpdateStatus", err.Error())
+		return fmt.Errorf("failed to update status for %s: %v", hpa.Name, err)
+	}
+	glog.V(2).Infof("Successfully updated status for %s", hpa.Name)
+	return nil
+}
+
+// unsafeConvertToVersionVia is like Scheme.UnsafeConvertToVersion, but it does so via an internal version first.
+// We use it since working with v2alpha1 is convenient here, but we want to use the v1 client (and
+// can't just use the internal version).  Note that conversion mutates the object, so you need to deepcopy
+// *before* you call this if the input object came out of a shared cache.
+func unsafeConvertToVersionVia(obj runtime.Object, externalVersion schema.GroupVersion) (runtime.Object, error) {
+	objInt, err := legacyscheme.Scheme.UnsafeConvertToVersion(obj, schema.GroupVersion{Group: externalVersion.Group, Version: runtime.APIVersionInternal})
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert the given object to the internal version: %v", err)
+	}
+
+	objExt, err := legacyscheme.Scheme.UnsafeConvertToVersion(objInt, externalVersion)
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert the given object back to the external version: %v", err)
+	}
+
+	return objExt, err
+}
+
+// setCondition sets the specific condition type on the given HPA to the specified value with the given reason
+// and message.  The message and args are treated like a format string.  The condition will be added if it is
+// not present.
+func setCondition(hpa *autoscalingv2.HorizontalPodAutoscaler, conditionType autoscalingv2.HorizontalPodAutoscalerConditionType, status v1.ConditionStatus, reason, message string, args ...interface{}) {
+	hpa.Status.Conditions = setConditionInList(hpa.Status.Conditions, conditionType, status, reason, message, args...)
+}
+
+// setConditionInList sets the specific condition type on the given HPA to the specified value with the given
+// reason and message.  The message and args are treated like a format string.  The condition will be added if
+// it is not present.  The new list will be returned.
+func setConditionInList(inputList []autoscalingv2.HorizontalPodAutoscalerCondition, conditionType autoscalingv2.HorizontalPodAutoscalerConditionType, status v1.ConditionStatus, reason, message string, args ...interface{}) []autoscalingv2.HorizontalPodAutoscalerCondition {
+	resList := inputList
+	var existingCond *autoscalingv2.HorizontalPodAutoscalerCondition
+	for i, condition := range resList {
+		if condition.Type == conditionType {
+			// can't take a pointer to an iteration variable
+			existingCond = &resList[i]
+			break
+		}
+	}
+
+	if existingCond == nil {
+		resList = append(resList, autoscalingv2.HorizontalPodAutoscalerCondition{
+			Type: conditionType,
+		})
+		existingCond = &resList[len(resList)-1]
+	}
+
+	if existingCond.Status != status {
+		existingCond.LastTransitionTime = metav1.Now()
+	}
+
+	existingCond.Status = status
+	existingCond.Reason = reason
+	existingCond.Message = fmt.Sprintf(message, args...)
+
+	return resList
+}

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/legacy_replica_calculator_test.go

@@ -0,0 +1,663 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package podautoscaler
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/kubernetes/fake"
+	restclient "k8s.io/client-go/rest"
+	core "k8s.io/client-go/testing"
+	"k8s.io/kubernetes/pkg/controller/podautoscaler/metrics"
+
+	heapster "k8s.io/heapster/metrics/api/v1/types"
+	metricsapi "k8s.io/metrics/pkg/apis/metrics/v1alpha1"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type legacyReplicaCalcTestCase struct {
+	currentReplicas  int32
+	expectedReplicas int32
+	expectedError    error
+
+	timestamp time.Time
+
+	resource *resourceInfo
+	metric   *metricInfo
+
+	podReadiness []v1.ConditionStatus
+}
+
+func (tc *legacyReplicaCalcTestCase) prepareTestClient(t *testing.T) *fake.Clientset {
+
+	fakeClient := &fake.Clientset{}
+	fakeClient.AddReactor("list", "pods", func(action core.Action) (handled bool, ret runtime.Object, err error) {
+		obj := &v1.PodList{}
+		for i := 0; i < int(tc.currentReplicas); i++ {
+			podReadiness := v1.ConditionTrue
+			if tc.podReadiness != nil {
+				podReadiness = tc.podReadiness[i]
+			}
+			podName := fmt.Sprintf("%s-%d", podNamePrefix, i)
+			pod := v1.Pod{
+				Status: v1.PodStatus{
+					Phase: v1.PodRunning,
+					Conditions: []v1.PodCondition{
+						{
+							Type:   v1.PodReady,
+							Status: podReadiness,
+						},
+					},
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      podName,
+					Namespace: testNamespace,
+					Labels: map[string]string{
+						"name": podNamePrefix,
+					},
+				},
+				Spec: v1.PodSpec{
+					Containers: []v1.Container{{}, {}},
+				},
+			}
+
+			if tc.resource != nil && i < len(tc.resource.requests) {
+				pod.Spec.Containers[0].Resources = v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						tc.resource.name: tc.resource.requests[i],
+					},
+				}
+				pod.Spec.Containers[1].Resources = v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						tc.resource.name: tc.resource.requests[i],
+					},
+				}
+			}
+			obj.Items = append(obj.Items, pod)
+		}
+		return true, obj, nil
+	})
+
+	fakeClient.AddProxyReactor("services", func(action core.Action) (handled bool, ret restclient.ResponseWrapper, err error) {
+		var heapsterRawMemResponse []byte
+
+		if tc.resource != nil {
+			metrics := metricsapi.PodMetricsList{}
+			for i, resValue := range tc.resource.levels {
+				podName := fmt.Sprintf("%s-%d", podNamePrefix, i)
+				if len(tc.resource.podNames) > i {
+					podName = tc.resource.podNames[i]
+				}
+				podMetric := metricsapi.PodMetrics{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      podName,
+						Namespace: testNamespace,
+					},
+					Timestamp:  metav1.Time{Time: tc.timestamp},
+					Containers: make([]metricsapi.ContainerMetrics, numContainersPerPod),
+				}
+
+				for i := 0; i < numContainersPerPod; i++ {
+					podMetric.Containers[i] = metricsapi.ContainerMetrics{
+						Name: fmt.Sprintf("container%v", i),
+						Usage: v1.ResourceList{
+							v1.ResourceName(tc.resource.name): *resource.NewMilliQuantity(
+								int64(resValue),
+								resource.DecimalSI),
+						},
+					}
+				}
+				metrics.Items = append(metrics.Items, podMetric)
+			}
+			heapsterRawMemResponse, _ = json.Marshal(&metrics)
+		} else {
+			// only return the pods that we actually asked for
+			proxyAction := action.(core.ProxyGetAction)
+			pathParts := strings.Split(proxyAction.GetPath(), "/")
+			// pathParts should look like [ api, v1, model, namespaces, $NS, pod-list, $PODS, metrics, $METRIC... ]
+			if len(pathParts) < 9 {
+				return true, nil, fmt.Errorf("invalid heapster path %q", proxyAction.GetPath())
+			}
+
+			podNames := strings.Split(pathParts[7], ",")
+			podPresent := make([]bool, len(tc.metric.levels))
+			for _, name := range podNames {
+				if len(name) <= len(podNamePrefix)+1 {
+					return true, nil, fmt.Errorf("unknown pod %q", name)
+				}
+				num, err := strconv.Atoi(name[len(podNamePrefix)+1:])
+				if err != nil {
+					return true, nil, fmt.Errorf("unknown pod %q", name)
+				}
+				podPresent[num] = true
+			}
+
+			timestamp := tc.timestamp
+			metrics := heapster.MetricResultList{}
+			for i, level := range tc.metric.levels {
+				if !podPresent[i] {
+					continue
+				}
+
+				floatVal := float64(tc.metric.levels[i]) / 1000.0
+				metric := heapster.MetricResult{
+					Metrics:         []heapster.MetricPoint{{Timestamp: timestamp, Value: uint64(level), FloatValue: &floatVal}},
+					LatestTimestamp: timestamp,
+				}
+				metrics.Items = append(metrics.Items, metric)
+			}
+			heapsterRawMemResponse, _ = json.Marshal(&metrics)
+		}
+
+		return true, newFakeResponseWrapper(heapsterRawMemResponse), nil
+	})
+
+	return fakeClient
+}
+
+func (tc *legacyReplicaCalcTestCase) runTest(t *testing.T) {
+	testClient := tc.prepareTestClient(t)
+	metricsClient := metrics.NewHeapsterMetricsClient(testClient, metrics.DefaultHeapsterNamespace, metrics.DefaultHeapsterScheme, metrics.DefaultHeapsterService, metrics.DefaultHeapsterPort)
+
+	replicaCalc := &ReplicaCalculator{
+		metricsClient: metricsClient,
+		podsGetter:    testClient.Core(),
+		tolerance:     defaultTestingTolerance,
+	}
+
+	selector, err := metav1.LabelSelectorAsSelector(&metav1.LabelSelector{
+		MatchLabels: map[string]string{"name": podNamePrefix},
+	})
+	if err != nil {
+		require.Nil(t, err, "something went horribly wrong...")
+	}
+
+	if tc.resource != nil {
+		outReplicas, outUtilization, outRawValue, outTimestamp, err := replicaCalc.GetResourceReplicas(tc.currentReplicas, tc.resource.targetUtilization, tc.resource.name, testNamespace, selector)
+
+		if tc.expectedError != nil {
+			require.Error(t, err, "there should be an error calculating the replica count")
+			assert.Contains(t, err.Error(), tc.expectedError.Error(), "the error message should have contained the expected error message")
+			return
+		}
+		require.NoError(t, err, "there should not have been an error calculating the replica count")
+		assert.Equal(t, tc.expectedReplicas, outReplicas, "replicas should be as expected")
+		assert.Equal(t, tc.resource.expectedUtilization, outUtilization, "utilization should be as expected")
+		assert.Equal(t, tc.resource.expectedValue, outRawValue, "raw value should be as expected")
+		assert.True(t, tc.timestamp.Equal(outTimestamp), "timestamp should be as expected")
+
+	} else {
+		outReplicas, outUtilization, outTimestamp, err := replicaCalc.GetMetricReplicas(tc.currentReplicas, tc.metric.targetUtilization, tc.metric.name, testNamespace, selector)
+
+		if tc.expectedError != nil {
+			require.Error(t, err, "there should be an error calculating the replica count")
+			assert.Contains(t, err.Error(), tc.expectedError.Error(), "the error message should have contained the expected error message")
+			return
+		}
+		require.NoError(t, err, "there should not have been an error calculating the replica count")
+		assert.Equal(t, tc.expectedReplicas, outReplicas, "replicas should be as expected")
+		assert.Equal(t, tc.metric.expectedUtilization, outUtilization, "utilization should be as expected")
+		assert.True(t, tc.timestamp.Equal(outTimestamp), "timestamp should be as expected")
+	}
+}
+
+func LegacyTestReplicaCalcDisjointResourcesMetrics(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas: 1,
+		expectedError:   fmt.Errorf("no metrics returned matched known pods"),
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0")},
+			levels:   []int64{100},
+			podNames: []string{"an-older-pod-name"},
+
+			targetUtilization: 100,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcScaleUp(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 5,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{300, 500, 700},
+
+			targetUtilization:   30,
+			expectedUtilization: 50,
+			expectedValue:       numContainersPerPod * 500,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcScaleUpUnreadyLessScale(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 4,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionFalse, v1.ConditionTrue, v1.ConditionTrue},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{300, 500, 700},
+
+			targetUtilization:   30,
+			expectedUtilization: 60,
+			expectedValue:       numContainersPerPod * 600,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcScaleUpUnreadyNoScale(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionTrue, v1.ConditionFalse, v1.ConditionFalse},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{400, 500, 700},
+
+			targetUtilization:   30,
+			expectedUtilization: 40,
+			expectedValue:       numContainersPerPod * 400,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcScaleUpCM(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 4,
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{20000, 10000, 30000},
+			targetUtilization:   15000,
+			expectedUtilization: 20000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcScaleUpCMUnreadyLessScale(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 4,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionTrue, v1.ConditionTrue, v1.ConditionFalse},
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{50000, 10000, 30000},
+			targetUtilization:   15000,
+			expectedUtilization: 30000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcScaleUpCMUnreadyNoScaleWouldScaleDown(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionFalse, v1.ConditionTrue, v1.ConditionFalse},
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{50000, 15000, 30000},
+			targetUtilization:   15000,
+			expectedUtilization: 15000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcScaleDown(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  5,
+		expectedReplicas: 3,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{100, 300, 500, 250, 250},
+
+			targetUtilization:   50,
+			expectedUtilization: 28,
+			expectedValue:       numContainersPerPod * 280,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcScaleDownCM(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  5,
+		expectedReplicas: 3,
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{12000, 12000, 12000, 12000, 12000},
+			targetUtilization:   20000,
+			expectedUtilization: 12000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcScaleDownIgnoresUnreadyPods(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  5,
+		expectedReplicas: 2,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionTrue, v1.ConditionTrue, v1.ConditionTrue, v1.ConditionFalse, v1.ConditionFalse},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{100, 300, 500, 250, 250},
+
+			targetUtilization:   50,
+			expectedUtilization: 30,
+			expectedValue:       numContainersPerPod * 300,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcTolerance(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("0.9"), resource.MustParse("1.0"), resource.MustParse("1.1")},
+			levels:   []int64{1010, 1030, 1020},
+
+			targetUtilization:   100,
+			expectedUtilization: 102,
+			expectedValue:       numContainersPerPod * 1020,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcToleranceCM(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{20000, 21000, 21000},
+			targetUtilization:   20000,
+			expectedUtilization: 20666,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcSuperfluousMetrics(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  4,
+		expectedReplicas: 24,
+		resource: &resourceInfo{
+			name:                v1.ResourceCPU,
+			requests:            []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:              []int64{4000, 9500, 3000, 7000, 3200, 2000},
+			targetUtilization:   100,
+			expectedUtilization: 587,
+			expectedValue:       numContainersPerPod * 5875,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcMissingMetrics(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  4,
+		expectedReplicas: 3,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{400, 95},
+
+			targetUtilization:   100,
+			expectedUtilization: 24,
+			expectedValue:       495, // numContainersPerPod * 247, for sufficiently large values of 247
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcEmptyMetrics(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas: 4,
+		expectedError:   fmt.Errorf("unable to get metrics for resource cpu: no metrics returned from heapster"),
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{},
+
+			targetUtilization: 100,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcEmptyCPURequest(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas: 1,
+		expectedError:   fmt.Errorf("missing request for"),
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{},
+			levels:   []int64{200},
+
+			targetUtilization: 100,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcMissingMetricsNoChangeEq(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  2,
+		expectedReplicas: 2,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{1000},
+
+			targetUtilization:   100,
+			expectedUtilization: 100,
+			expectedValue:       numContainersPerPod * 1000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcMissingMetricsNoChangeGt(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  2,
+		expectedReplicas: 2,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{1900},
+
+			targetUtilization:   100,
+			expectedUtilization: 190,
+			expectedValue:       numContainersPerPod * 1900,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcMissingMetricsNoChangeLt(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  2,
+		expectedReplicas: 2,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{600},
+
+			targetUtilization:   100,
+			expectedUtilization: 60,
+			expectedValue:       numContainersPerPod * 600,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcMissingMetricsUnreadyNoChange(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionFalse, v1.ConditionTrue, v1.ConditionTrue},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{100, 450},
+
+			targetUtilization:   50,
+			expectedUtilization: 45,
+			expectedValue:       numContainersPerPod * 450,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcMissingMetricsUnreadyScaleUp(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 4,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionFalse, v1.ConditionTrue, v1.ConditionTrue},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{100, 2000},
+
+			targetUtilization:   50,
+			expectedUtilization: 200,
+			expectedValue:       numContainersPerPod * 2000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func LegacyTestReplicaCalcMissingMetricsUnreadyScaleDown(t *testing.T) {
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  4,
+		expectedReplicas: 3,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionFalse, v1.ConditionTrue, v1.ConditionTrue, v1.ConditionTrue},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{100, 100, 100},
+
+			targetUtilization:   50,
+			expectedUtilization: 10,
+			expectedValue:       numContainersPerPod * 100,
+		},
+	}
+	tc.runTest(t)
+}
+
+// TestComputedToleranceAlgImplementation is a regression test which
+// back-calculates a minimal percentage for downscaling based on a small percentage
+// increase in pod utilization which is calibrated against the tolerance value.
+func LegacyTestReplicaCalcComputedToleranceAlgImplementation(t *testing.T) {
+
+	startPods := int32(10)
+	// 150 mCPU per pod.
+	totalUsedCPUOfAllPods := int64(startPods * 150)
+	// Each pod starts out asking for 2X what is really needed.
+	// This means we will have a 50% ratio of used/requested
+	totalRequestedCPUOfAllPods := int32(2 * totalUsedCPUOfAllPods)
+	requestedToUsed := float64(totalRequestedCPUOfAllPods / int32(totalUsedCPUOfAllPods))
+	// Spread the amount we ask over 10 pods.  We can add some jitter later in reportedLevels.
+	perPodRequested := totalRequestedCPUOfAllPods / startPods
+
+	// Force a minimal scaling event by satisfying  (tolerance < 1 - resourcesUsedRatio).
+	target := math.Abs(1/(requestedToUsed*(1-defaultTestingTolerance))) + .01
+	finalCPUPercentTarget := int32(target * 100)
+	resourcesUsedRatio := float64(totalUsedCPUOfAllPods) / float64(float64(totalRequestedCPUOfAllPods)*target)
+
+	// i.e. .60 * 20 -> scaled down expectation.
+	finalPods := int32(math.Ceil(resourcesUsedRatio * float64(startPods)))
+
+	// To breach tolerance we will create a utilization ratio difference of tolerance to usageRatioToleranceValue)
+	tc := legacyReplicaCalcTestCase{
+		currentReplicas:  startPods,
+		expectedReplicas: finalPods,
+		resource: &resourceInfo{
+			name: v1.ResourceCPU,
+			levels: []int64{
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+			},
+			requests: []resource.Quantity{
+				resource.MustParse(fmt.Sprint(perPodRequested+100) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested-100) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested+10) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested-10) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested+2) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested-2) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested+1) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested-1) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested) + "m"),
+			},
+
+			targetUtilization:   finalCPUPercentTarget,
+			expectedUtilization: int32(totalUsedCPUOfAllPods*100) / totalRequestedCPUOfAllPods,
+			expectedValue:       numContainersPerPod * totalUsedCPUOfAllPods / 10,
+		},
+	}
+
+	tc.runTest(t)
+
+	// Reuse the data structure above, now testing "unscaling".
+	// Now, we test that no scaling happens if we are in a very close margin to the tolerance
+	target = math.Abs(1/(requestedToUsed*(1-defaultTestingTolerance))) + .004
+	finalCPUPercentTarget = int32(target * 100)
+	tc.resource.targetUtilization = finalCPUPercentTarget
+	tc.currentReplicas = startPods
+	tc.expectedReplicas = startPods
+	tc.runTest(t)
+}
+
+// TODO: add more tests

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/metrics/BUILD

@@ -0,0 +1,77 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "interfaces.go",
+        "legacy_metrics_client.go",
+        "rest_metrics_client.go",
+        "utilization.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/controller/podautoscaler/metrics",
+    deps = [
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/autoscaling/v2beta1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
+        "//vendor/k8s.io/heapster/metrics/api/v1/types:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/apis/metrics/v1alpha1:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/client/clientset_generated/clientset/typed/metrics/v1beta1:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/client/custom_metrics:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "legacy_metrics_client_test.go",
+        "rest_metrics_client_test.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/controller/podautoscaler/metrics",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/apis/extensions/install:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/k8s.io/api/autoscaling/v2beta1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/fake:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/testing:go_default_library",
+        "//vendor/k8s.io/heapster/metrics/api/v1/types:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/apis/metrics/v1alpha1:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/apis/metrics/v1beta1:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/client/clientset_generated/clientset/fake:go_default_library",
+        "//vendor/k8s.io/metrics/pkg/client/custom_metrics/fake:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/metrics/interfaces.go

@@ -0,0 +1,45 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metrics
+
+import (
+	"time"
+
+	autoscaling "k8s.io/api/autoscaling/v2beta1"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+)
+
+// PodMetricsInfo contains pod metric values as a map from pod names to
+// metric values (the metric values are expected to be the metric as a milli-value)
+type PodMetricsInfo map[string]int64
+
+// MetricsClient knows how to query a remote interface to retrieve container-level
+// resource metrics as well as pod-level arbitrary metrics
+type MetricsClient interface {
+	// GetResourceMetric gets the given resource metric (and an associated oldest timestamp)
+	// for all pods matching the specified selector in the given namespace
+	GetResourceMetric(resource v1.ResourceName, namespace string, selector labels.Selector) (PodMetricsInfo, time.Time, error)
+
+	// GetRawMetric gets the given metric (and an associated oldest timestamp)
+	// for all pods matching the specified selector in the given namespace
+	GetRawMetric(metricName string, namespace string, selector labels.Selector) (PodMetricsInfo, time.Time, error)
+
+	// GetObjectMetric gets the given metric (and an associated timestamp) for the given
+	// object in the given namespace
+	GetObjectMetric(metricName string, namespace string, objectRef *autoscaling.CrossVersionObjectReference) (int64, time.Time, error)
+}

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/metrics/legacy_metrics_client.go

@@ -0,0 +1,213 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metrics
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/golang/glog"
+	heapster "k8s.io/heapster/metrics/api/v1/types"
+	metricsapi "k8s.io/metrics/pkg/apis/metrics/v1alpha1"
+
+	autoscaling "k8s.io/api/autoscaling/v2beta1"
+	"k8s.io/api/core/v1"
+	clientgov1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	clientset "k8s.io/client-go/kubernetes"
+	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
+)
+
+const (
+	DefaultHeapsterNamespace = "kube-system"
+	DefaultHeapsterScheme    = "http"
+	DefaultHeapsterService   = "heapster"
+	DefaultHeapsterPort      = "" // use the first exposed port on the service
+)
+
+var heapsterQueryStart = -5 * time.Minute
+
+type HeapsterMetricsClient struct {
+	services        v1core.ServiceInterface
+	podsGetter      v1core.PodsGetter
+	heapsterScheme  string
+	heapsterService string
+	heapsterPort    string
+}
+
+func NewHeapsterMetricsClient(client clientset.Interface, namespace, scheme, service, port string) MetricsClient {
+	return &HeapsterMetricsClient{
+		services:        client.CoreV1().Services(namespace),
+		podsGetter:      client.CoreV1(),
+		heapsterScheme:  scheme,
+		heapsterService: service,
+		heapsterPort:    port,
+	}
+}
+
+func (h *HeapsterMetricsClient) GetResourceMetric(resource v1.ResourceName, namespace string, selector labels.Selector) (PodMetricsInfo, time.Time, error) {
+	metricPath := fmt.Sprintf("/apis/metrics/v1alpha1/namespaces/%s/pods", namespace)
+	params := map[string]string{"labelSelector": selector.String()}
+
+	resultRaw, err := h.services.
+		ProxyGet(h.heapsterScheme, h.heapsterService, h.heapsterPort, metricPath, params).
+		DoRaw()
+	if err != nil {
+		return nil, time.Time{}, fmt.Errorf("failed to get pod resource metrics: %v", err)
+	}
+
+	glog.V(4).Infof("Heapster metrics result: %s", string(resultRaw))
+
+	metrics := metricsapi.PodMetricsList{}
+	err = json.Unmarshal(resultRaw, &metrics)
+	if err != nil {
+		return nil, time.Time{}, fmt.Errorf("failed to unmarshal heapster response: %v", err)
+	}
+
+	if len(metrics.Items) == 0 {
+		return nil, time.Time{}, fmt.Errorf("no metrics returned from heapster")
+	}
+
+	res := make(PodMetricsInfo, len(metrics.Items))
+
+	for _, m := range metrics.Items {
+		podSum := int64(0)
+		missing := len(m.Containers) == 0
+		for _, c := range m.Containers {
+			resValue, found := c.Usage[clientgov1.ResourceName(resource)]
+			if !found {
+				missing = true
+				glog.V(2).Infof("missing resource metric %v for container %s in pod %s/%s", resource, c.Name, namespace, m.Name)
+				continue
+			}
+			podSum += resValue.MilliValue()
+		}
+
+		if !missing {
+			res[m.Name] = int64(podSum)
+		}
+	}
+
+	timestamp := metrics.Items[0].Timestamp.Time
+
+	return res, timestamp, nil
+}
+
+func (h *HeapsterMetricsClient) GetRawMetric(metricName string, namespace string, selector labels.Selector) (PodMetricsInfo, time.Time, error) {
+	podList, err := h.podsGetter.Pods(namespace).List(metav1.ListOptions{LabelSelector: selector.String()})
+	if err != nil {
+		return nil, time.Time{}, fmt.Errorf("failed to get pod list while fetching metrics: %v", err)
+	}
+
+	if len(podList.Items) == 0 {
+		return nil, time.Time{}, fmt.Errorf("no pods matched the provided selector")
+	}
+
+	podNames := make([]string, len(podList.Items))
+	for i, pod := range podList.Items {
+		podNames[i] = pod.Name
+	}
+
+	now := time.Now()
+
+	startTime := now.Add(heapsterQueryStart)
+	metricPath := fmt.Sprintf("/api/v1/model/namespaces/%s/pod-list/%s/metrics/%s",
+		namespace,
+		strings.Join(podNames, ","),
+		metricName)
+
+	resultRaw, err := h.services.
+		ProxyGet(h.heapsterScheme, h.heapsterService, h.heapsterPort, metricPath, map[string]string{"start": startTime.Format(time.RFC3339)}).
+		DoRaw()
+	if err != nil {
+		return nil, time.Time{}, fmt.Errorf("failed to get pod metrics: %v", err)
+	}
+
+	var metrics heapster.MetricResultList
+	err = json.Unmarshal(resultRaw, &metrics)
+	if err != nil {
+		return nil, time.Time{}, fmt.Errorf("failed to unmarshal heapster response: %v", err)
+	}
+
+	glog.V(4).Infof("Heapster metrics result: %s", string(resultRaw))
+
+	if len(metrics.Items) != len(podNames) {
+		// if we get too many metrics or two few metrics, we have no way of knowing which metric goes to which pod
+		// (note that Heapster returns *empty* metric items when a pod does not exist or have that metric, so this
+		// does not cover the "missing metric entry" case)
+		return nil, time.Time{}, fmt.Errorf("requested metrics for %v pods, got metrics for %v", len(podNames), len(metrics.Items))
+	}
+
+	var timestamp *time.Time
+	res := make(PodMetricsInfo, len(metrics.Items))
+	for i, podMetrics := range metrics.Items {
+		val, podTimestamp, hadMetrics := collapseTimeSamples(podMetrics, time.Minute)
+		if hadMetrics {
+			res[podNames[i]] = val
+			if timestamp == nil || podTimestamp.Before(*timestamp) {
+				timestamp = &podTimestamp
+			}
+		}
+	}
+
+	if timestamp == nil {
+		timestamp = &time.Time{}
+	}
+
+	return res, *timestamp, nil
+}
+
+func (h *HeapsterMetricsClient) GetObjectMetric(metricName string, namespace string, objectRef *autoscaling.CrossVersionObjectReference) (int64, time.Time, error) {
+	return 0, time.Time{}, fmt.Errorf("object metrics are not yet supported")
+}
+
+func collapseTimeSamples(metrics heapster.MetricResult, duration time.Duration) (int64, time.Time, bool) {
+	floatSum := float64(0)
+	intSum := int64(0)
+	intSumCount := 0
+	floatSumCount := 0
+
+	var newest *heapster.MetricPoint // creation time of the newest sample for this pod
+	for i, metricPoint := range metrics.Metrics {
+		if newest == nil || newest.Timestamp.Before(metricPoint.Timestamp) {
+			newest = &metrics.Metrics[i]
+		}
+	}
+	if newest != nil {
+		for _, metricPoint := range metrics.Metrics {
+			if metricPoint.Timestamp.Add(duration).After(newest.Timestamp) {
+				intSum += int64(metricPoint.Value)
+				intSumCount++
+				if metricPoint.FloatValue != nil {
+					floatSum += *metricPoint.FloatValue
+					floatSumCount++
+				}
+			}
+		}
+
+		if newest.FloatValue != nil {
+			return int64(floatSum / float64(floatSumCount) * 1000), newest.Timestamp, true
+		} else {
+			return (intSum * 1000) / int64(intSumCount), newest.Timestamp, true
+		}
+	}
+
+	return 0, time.Time{}, false
+}

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/metrics/legacy_metrics_client_test.go

@@ -0,0 +1,365 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metrics
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/kubernetes/fake"
+	restclient "k8s.io/client-go/rest"
+	core "k8s.io/client-go/testing"
+
+	heapster "k8s.io/heapster/metrics/api/v1/types"
+	metricsapi "k8s.io/metrics/pkg/apis/metrics/v1alpha1"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var fixedTimestamp = time.Date(2015, time.November, 10, 12, 30, 0, 0, time.UTC)
+
+func (w fakeResponseWrapper) DoRaw() ([]byte, error) {
+	return w.raw, nil
+}
+
+func (w fakeResponseWrapper) Stream() (io.ReadCloser, error) {
+	return nil, nil
+}
+
+func newFakeResponseWrapper(raw []byte) fakeResponseWrapper {
+	return fakeResponseWrapper{raw: raw}
+}
+
+type fakeResponseWrapper struct {
+	raw []byte
+}
+
+// timestamp is used for establishing order on metricPoints
+type metricPoint struct {
+	level     uint64
+	timestamp int
+}
+
+type testCase struct {
+	desiredMetricValues PodMetricsInfo
+	desiredError        error
+
+	replicas              int
+	targetTimestamp       int
+	reportedMetricsPoints [][]metricPoint
+	reportedPodMetrics    [][]int64
+
+	namespace    string
+	selector     labels.Selector
+	resourceName v1.ResourceName
+	metricName   string
+}
+
+func (tc *testCase) prepareTestClient(t *testing.T) *fake.Clientset {
+	namespace := "test-namespace"
+	tc.namespace = namespace
+	podNamePrefix := "test-pod"
+	podLabels := map[string]string{"name": podNamePrefix}
+	tc.selector = labels.SelectorFromSet(podLabels)
+
+	// it's a resource test if we have a resource name
+	isResource := len(tc.resourceName) > 0
+
+	fakeClient := &fake.Clientset{}
+
+	fakeClient.AddReactor("list", "pods", func(action core.Action) (handled bool, ret runtime.Object, err error) {
+		obj := &v1.PodList{}
+		for i := 0; i < tc.replicas; i++ {
+			podName := fmt.Sprintf("%s-%d", podNamePrefix, i)
+			pod := buildPod(namespace, podName, podLabels, v1.PodRunning, "1024")
+			obj.Items = append(obj.Items, pod)
+		}
+		return true, obj, nil
+	})
+
+	if isResource {
+		fakeClient.AddProxyReactor("services", func(action core.Action) (handled bool, ret restclient.ResponseWrapper, err error) {
+			metrics := metricsapi.PodMetricsList{}
+			for i, containers := range tc.reportedPodMetrics {
+				metric := metricsapi.PodMetrics{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      fmt.Sprintf("%s-%d", podNamePrefix, i),
+						Namespace: namespace,
+					},
+					Timestamp:  metav1.Time{Time: fixedTimestamp.Add(time.Duration(tc.targetTimestamp) * time.Minute)},
+					Containers: []metricsapi.ContainerMetrics{},
+				}
+				for j, cpu := range containers {
+					cm := metricsapi.ContainerMetrics{
+						Name: fmt.Sprintf("%s-%d-container-%d", podNamePrefix, i, j),
+						Usage: v1.ResourceList{
+							v1.ResourceCPU: *resource.NewMilliQuantity(
+								cpu,
+								resource.DecimalSI),
+							v1.ResourceMemory: *resource.NewQuantity(
+								int64(1024*1024),
+								resource.BinarySI),
+						},
+					}
+					metric.Containers = append(metric.Containers, cm)
+				}
+				metrics.Items = append(metrics.Items, metric)
+			}
+			heapsterRawMemResponse, _ := json.Marshal(&metrics)
+			return true, newFakeResponseWrapper(heapsterRawMemResponse), nil
+		})
+	} else {
+		fakeClient.AddProxyReactor("services", func(action core.Action) (handled bool, ret restclient.ResponseWrapper, err error) {
+			metrics := heapster.MetricResultList{}
+			var latestTimestamp time.Time
+			for _, reportedMetricPoints := range tc.reportedMetricsPoints {
+				var heapsterMetricPoints []heapster.MetricPoint
+				for _, reportedMetricPoint := range reportedMetricPoints {
+					timestamp := fixedTimestamp.Add(time.Duration(reportedMetricPoint.timestamp) * time.Minute)
+					if latestTimestamp.Before(timestamp) {
+						latestTimestamp = timestamp
+					}
+					heapsterMetricPoint := heapster.MetricPoint{Timestamp: timestamp, Value: reportedMetricPoint.level, FloatValue: nil}
+					heapsterMetricPoints = append(heapsterMetricPoints, heapsterMetricPoint)
+				}
+				metric := heapster.MetricResult{
+					Metrics:         heapsterMetricPoints,
+					LatestTimestamp: latestTimestamp,
+				}
+				metrics.Items = append(metrics.Items, metric)
+			}
+			heapsterRawMemResponse, _ := json.Marshal(&metrics)
+			return true, newFakeResponseWrapper(heapsterRawMemResponse), nil
+		})
+	}
+
+	return fakeClient
+}
+
+func buildPod(namespace, podName string, podLabels map[string]string, phase v1.PodPhase, request string) v1.Pod {
+	return v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      podName,
+			Namespace: namespace,
+			Labels:    podLabels,
+		},
+		Spec: v1.PodSpec{
+			Containers: []v1.Container{
+				{
+					Resources: v1.ResourceRequirements{
+						Requests: v1.ResourceList{
+							v1.ResourceCPU: resource.MustParse(request),
+						},
+					},
+				},
+			},
+		},
+		Status: v1.PodStatus{
+			Phase: phase,
+			Conditions: []v1.PodCondition{
+				{
+					Type:   v1.PodReady,
+					Status: v1.ConditionTrue,
+				},
+			},
+		},
+	}
+}
+
+func (tc *testCase) verifyResults(t *testing.T, metrics PodMetricsInfo, timestamp time.Time, err error) {
+	if tc.desiredError != nil {
+		assert.Error(t, err, "there should be an error retrieving the metrics")
+		assert.Contains(t, fmt.Sprintf("%v", err), fmt.Sprintf("%v", tc.desiredError), "the error message should be eas expected")
+		return
+	}
+	assert.NoError(t, err, "there should be no error retrieving the metrics")
+	assert.NotNil(t, metrics, "there should be metrics returned")
+
+	assert.Equal(t, tc.desiredMetricValues, metrics, "the metrics values should be as expected")
+
+	targetTimestamp := fixedTimestamp.Add(time.Duration(tc.targetTimestamp) * time.Minute)
+	assert.True(t, targetTimestamp.Equal(timestamp), fmt.Sprintf("the timestamp should be as expected (%s) but was %s", targetTimestamp, timestamp))
+}
+
+func (tc *testCase) runTest(t *testing.T) {
+	testClient := tc.prepareTestClient(t)
+	metricsClient := NewHeapsterMetricsClient(testClient, DefaultHeapsterNamespace, DefaultHeapsterScheme, DefaultHeapsterService, DefaultHeapsterPort)
+	isResource := len(tc.resourceName) > 0
+	if isResource {
+		info, timestamp, err := metricsClient.GetResourceMetric(tc.resourceName, tc.namespace, tc.selector)
+		tc.verifyResults(t, info, timestamp, err)
+	} else {
+		info, timestamp, err := metricsClient.GetRawMetric(tc.metricName, tc.namespace, tc.selector)
+		tc.verifyResults(t, info, timestamp, err)
+	}
+}
+
+func TestCPU(t *testing.T) {
+	tc := testCase{
+		replicas: 3,
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 5000, "test-pod-1": 5000, "test-pod-2": 5000,
+		},
+		resourceName:       v1.ResourceCPU,
+		targetTimestamp:    1,
+		reportedPodMetrics: [][]int64{{5000}, {5000}, {5000}},
+	}
+	tc.runTest(t)
+}
+
+func TestQPS(t *testing.T) {
+	tc := testCase{
+		replicas: 3,
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 10000, "test-pod-1": 20000, "test-pod-2": 10000,
+		},
+		metricName:            "qps",
+		targetTimestamp:       1,
+		reportedMetricsPoints: [][]metricPoint{{{10, 1}}, {{20, 1}}, {{10, 1}}},
+	}
+	tc.runTest(t)
+}
+
+func TestQpsSumEqualZero(t *testing.T) {
+	tc := testCase{
+		replicas: 3,
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 0, "test-pod-1": 0, "test-pod-2": 0,
+		},
+		metricName:            "qps",
+		targetTimestamp:       0,
+		reportedMetricsPoints: [][]metricPoint{{{0, 0}}, {{0, 0}}, {{0, 0}}},
+	}
+	tc.runTest(t)
+}
+
+func TestCPUMoreMetrics(t *testing.T) {
+	tc := testCase{
+		replicas: 5,
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 5000, "test-pod-1": 5000, "test-pod-2": 5000,
+			"test-pod-3": 5000, "test-pod-4": 5000,
+		},
+		resourceName:       v1.ResourceCPU,
+		targetTimestamp:    10,
+		reportedPodMetrics: [][]int64{{1000, 2000, 2000}, {5000}, {1000, 1000, 1000, 2000}, {4000, 1000}, {5000}},
+	}
+	tc.runTest(t)
+}
+
+func TestCPUMissingMetrics(t *testing.T) {
+	tc := testCase{
+		replicas: 3,
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 4000,
+		},
+		resourceName:       v1.ResourceCPU,
+		reportedPodMetrics: [][]int64{{4000}},
+	}
+	tc.runTest(t)
+}
+
+func TestQpsMissingMetrics(t *testing.T) {
+	tc := testCase{
+		replicas:              3,
+		desiredError:          fmt.Errorf("requested metrics for 3 pods, got metrics for 1"),
+		metricName:            "qps",
+		targetTimestamp:       1,
+		reportedMetricsPoints: [][]metricPoint{{{4000, 4}}},
+	}
+	tc.runTest(t)
+}
+
+func TestQpsSuperfluousMetrics(t *testing.T) {
+	tc := testCase{
+		replicas:              3,
+		desiredError:          fmt.Errorf("requested metrics for 3 pods, got metrics for 6"),
+		metricName:            "qps",
+		reportedMetricsPoints: [][]metricPoint{{{1000, 1}}, {{2000, 4}}, {{2000, 1}}, {{4000, 5}}, {{2000, 1}}, {{4000, 4}}},
+	}
+	tc.runTest(t)
+}
+
+func TestCPUEmptyMetrics(t *testing.T) {
+	tc := testCase{
+		replicas:              3,
+		resourceName:          v1.ResourceCPU,
+		desiredError:          fmt.Errorf("no metrics returned from heapster"),
+		reportedMetricsPoints: [][]metricPoint{},
+		reportedPodMetrics:    [][]int64{},
+	}
+	tc.runTest(t)
+}
+
+func TestQpsEmptyEntries(t *testing.T) {
+	tc := testCase{
+		replicas:   3,
+		metricName: "qps",
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 4000000, "test-pod-2": 2000000,
+		},
+		targetTimestamp:       4,
+		reportedMetricsPoints: [][]metricPoint{{{4000, 4}}, {}, {{2000, 4}}},
+	}
+	tc.runTest(t)
+}
+
+func TestCPUZeroReplicas(t *testing.T) {
+	tc := testCase{
+		replicas:           0,
+		resourceName:       v1.ResourceCPU,
+		desiredError:       fmt.Errorf("no metrics returned from heapster"),
+		reportedPodMetrics: [][]int64{},
+	}
+	tc.runTest(t)
+}
+
+func TestCPUEmptyMetricsForOnePod(t *testing.T) {
+	tc := testCase{
+		replicas:     3,
+		resourceName: v1.ResourceCPU,
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 100, "test-pod-1": 700,
+		},
+		reportedPodMetrics: [][]int64{{100}, {300, 400}, {}},
+	}
+	tc.runTest(t)
+}
+
+func testCollapseTimeSamples(t *testing.T) {
+	now := time.Now()
+	metrics := heapster.MetricResult{
+		Metrics: []heapster.MetricPoint{
+			{Timestamp: now, Value: 50, FloatValue: nil},
+			{Timestamp: now.Add(-15 * time.Second), Value: 100, FloatValue: nil},
+			{Timestamp: now.Add(-60 * time.Second), Value: 100000, FloatValue: nil}},
+		LatestTimestamp: now,
+	}
+
+	val, timestamp, hadMetrics := collapseTimeSamples(metrics, time.Minute)
+	assert.True(t, hadMetrics, "should report that it received a populated list of metrics")
+	assert.InEpsilon(t, float64(75), val, 0.1, "collapsed sample value should be as expected")
+	assert.True(t, timestamp.Equal(now), "timestamp should be the current time (the newest)")
+}

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/metrics/rest_metrics_client.go

@@ -0,0 +1,141 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metrics
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/golang/glog"
+
+	autoscaling "k8s.io/api/autoscaling/v2beta1"
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	customapi "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1"
+	resourceclient "k8s.io/metrics/pkg/client/clientset_generated/clientset/typed/metrics/v1beta1"
+	customclient "k8s.io/metrics/pkg/client/custom_metrics"
+)
+
+func NewRESTMetricsClient(resourceClient resourceclient.PodMetricsesGetter, customClient customclient.CustomMetricsClient) MetricsClient {
+	return &restMetricsClient{
+		&resourceMetricsClient{resourceClient},
+		&customMetricsClient{customClient},
+	}
+}
+
+// restMetricsClient is a client which supports fetching
+// metrics from both the resource metrics API and the
+// custom metrics API.
+type restMetricsClient struct {
+	*resourceMetricsClient
+	*customMetricsClient
+}
+
+// resourceMetricsClient implements the resource-metrics-related parts of MetricsClient,
+// using data from the resource metrics API.
+type resourceMetricsClient struct {
+	client resourceclient.PodMetricsesGetter
+}
+
+// GetResourceMetric gets the given resource metric (and an associated oldest timestamp)
+// for all pods matching the specified selector in the given namespace
+func (c *resourceMetricsClient) GetResourceMetric(resource v1.ResourceName, namespace string, selector labels.Selector) (PodMetricsInfo, time.Time, error) {
+	metrics, err := c.client.PodMetricses(namespace).List(metav1.ListOptions{LabelSelector: selector.String()})
+	if err != nil {
+		return nil, time.Time{}, fmt.Errorf("unable to fetch metrics from API: %v", err)
+	}
+
+	if len(metrics.Items) == 0 {
+		return nil, time.Time{}, fmt.Errorf("no metrics returned from heapster")
+	}
+
+	res := make(PodMetricsInfo, len(metrics.Items))
+
+	for _, m := range metrics.Items {
+		podSum := int64(0)
+		missing := len(m.Containers) == 0
+		for _, c := range m.Containers {
+			resValue, found := c.Usage[v1.ResourceName(resource)]
+			if !found {
+				missing = true
+				glog.V(2).Infof("missing resource metric %v for container %s in pod %s/%s", resource, c.Name, namespace, m.Name)
+				break // containers loop
+			}
+			podSum += resValue.MilliValue()
+		}
+
+		if !missing {
+			res[m.Name] = int64(podSum)
+		}
+	}
+
+	timestamp := metrics.Items[0].Timestamp.Time
+
+	return res, timestamp, nil
+}
+
+// customMetricsClient implements the custom-metrics-related parts of MetricsClient,
+// using data from the custom metrics API.
+type customMetricsClient struct {
+	client customclient.CustomMetricsClient
+}
+
+// GetRawMetric gets the given metric (and an associated oldest timestamp)
+// for all pods matching the specified selector in the given namespace
+func (c *customMetricsClient) GetRawMetric(metricName string, namespace string, selector labels.Selector) (PodMetricsInfo, time.Time, error) {
+	metrics, err := c.client.NamespacedMetrics(namespace).GetForObjects(schema.GroupKind{Kind: "Pod"}, selector, metricName)
+	if err != nil {
+		return nil, time.Time{}, fmt.Errorf("unable to fetch metrics from API: %v", err)
+	}
+
+	if len(metrics.Items) == 0 {
+		return nil, time.Time{}, fmt.Errorf("no metrics returned from custom metrics API")
+	}
+
+	res := make(PodMetricsInfo, len(metrics.Items))
+	for _, m := range metrics.Items {
+		res[m.DescribedObject.Name] = m.Value.MilliValue()
+	}
+
+	timestamp := metrics.Items[0].Timestamp.Time
+
+	return res, timestamp, nil
+}
+
+// GetObjectMetric gets the given metric (and an associated timestamp) for the given
+// object in the given namespace
+func (c *customMetricsClient) GetObjectMetric(metricName string, namespace string, objectRef *autoscaling.CrossVersionObjectReference) (int64, time.Time, error) {
+	gvk := schema.FromAPIVersionAndKind(objectRef.APIVersion, objectRef.Kind)
+	var metricValue *customapi.MetricValue
+	var err error
+	if gvk.Kind == "Namespace" && gvk.Group == "" {
+		// handle namespace separately
+		// NB: we ignore namespace name here, since CrossVersionObjectReference isn't
+		// supposed to allow you to escape your namespace
+		metricValue, err = c.client.RootScopedMetrics().GetForObject(gvk.GroupKind(), namespace, metricName)
+	} else {
+		metricValue, err = c.client.NamespacedMetrics(namespace).GetForObject(gvk.GroupKind(), objectRef.Name, metricName)
+	}
+
+	if err != nil {
+		return 0, time.Time{}, fmt.Errorf("unable to fetch metrics from API: %v", err)
+	}
+
+	return metricValue.Value.MilliValue(), metricValue.Timestamp.Time, nil
+}

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/metrics/rest_metrics_client_test.go

@@ -0,0 +1,271 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metrics
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	autoscalingapi "k8s.io/api/autoscaling/v2beta1"
+	"k8s.io/api/core/v1"
+	kv1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	core "k8s.io/client-go/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
+	cmapi "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1"
+	metricsapi "k8s.io/metrics/pkg/apis/metrics/v1beta1"
+	metricsfake "k8s.io/metrics/pkg/client/clientset_generated/clientset/fake"
+	cmfake "k8s.io/metrics/pkg/client/custom_metrics/fake"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type restClientTestCase struct {
+	desiredMetricValues PodMetricsInfo
+	desiredError        error
+
+	// "timestamps" here are actually the offset in minutes from a base timestamp
+	targetTimestamp      int
+	reportedMetricPoints []metricPoint
+	reportedPodMetrics   [][]int64
+	singleObject         *autoscalingapi.CrossVersionObjectReference
+
+	namespace    string
+	selector     labels.Selector
+	resourceName v1.ResourceName
+	metricName   string
+}
+
+func (tc *restClientTestCase) prepareTestClient(t *testing.T) (*metricsfake.Clientset, *cmfake.FakeCustomMetricsClient) {
+	namespace := "test-namespace"
+	tc.namespace = namespace
+	podNamePrefix := "test-pod"
+	podLabels := map[string]string{"name": podNamePrefix}
+	tc.selector = labels.SelectorFromSet(podLabels)
+
+	// it's a resource test if we have a resource name
+	isResource := len(tc.resourceName) > 0
+
+	fakeMetricsClient := &metricsfake.Clientset{}
+	fakeCMClient := &cmfake.FakeCustomMetricsClient{}
+
+	if isResource {
+		fakeMetricsClient.AddReactor("list", "pods", func(action core.Action) (handled bool, ret runtime.Object, err error) {
+			metrics := &metricsapi.PodMetricsList{}
+			for i, containers := range tc.reportedPodMetrics {
+				metric := metricsapi.PodMetrics{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      fmt.Sprintf("%s-%d", podNamePrefix, i),
+						Namespace: namespace,
+						Labels:    podLabels,
+					},
+					Timestamp:  metav1.Time{Time: fixedTimestamp.Add(time.Duration(tc.targetTimestamp) * time.Minute)},
+					Containers: []metricsapi.ContainerMetrics{},
+				}
+				for j, cpu := range containers {
+					cm := metricsapi.ContainerMetrics{
+						Name: fmt.Sprintf("%s-%d-container-%d", podNamePrefix, i, j),
+						Usage: v1.ResourceList{
+							v1.ResourceCPU: *resource.NewMilliQuantity(
+								cpu,
+								resource.DecimalSI),
+							v1.ResourceMemory: *resource.NewQuantity(
+								int64(1024*1024),
+								resource.BinarySI),
+						},
+					}
+					metric.Containers = append(metric.Containers, cm)
+				}
+				metrics.Items = append(metrics.Items, metric)
+			}
+			return true, metrics, nil
+		})
+	} else {
+		fakeCMClient.AddReactor("get", "*", func(action core.Action) (handled bool, ret runtime.Object, err error) {
+			getForAction := action.(cmfake.GetForAction)
+			assert.Equal(t, tc.metricName, getForAction.GetMetricName(), "the metric requested should have matched the one specified")
+
+			if getForAction.GetName() == "*" {
+				// multiple objects
+				metrics := cmapi.MetricValueList{}
+				assert.Equal(t, "pods", getForAction.GetResource().Resource, "type of object that we requested multiple metrics for should have been pods")
+
+				for i, metricPoint := range tc.reportedMetricPoints {
+					timestamp := fixedTimestamp.Add(time.Duration(metricPoint.timestamp) * time.Minute)
+					metric := cmapi.MetricValue{
+						DescribedObject: v1.ObjectReference{
+							Kind:       "Pod",
+							APIVersion: "v1",
+							Name:       fmt.Sprintf("%s-%d", podNamePrefix, i),
+						},
+						Value:      *resource.NewMilliQuantity(int64(metricPoint.level), resource.DecimalSI),
+						Timestamp:  metav1.Time{Time: timestamp},
+						MetricName: tc.metricName,
+					}
+
+					metrics.Items = append(metrics.Items, metric)
+				}
+
+				return true, &metrics, nil
+			} else {
+				name := getForAction.GetName()
+				mapper := legacyscheme.Registry.RESTMapper()
+				assert.NotNil(t, tc.singleObject, "should have only requested a single-object metric when we asked for metrics for a single object")
+				gk := schema.FromAPIVersionAndKind(tc.singleObject.APIVersion, tc.singleObject.Kind).GroupKind()
+				mapping, err := mapper.RESTMapping(gk)
+				if err != nil {
+					return true, nil, fmt.Errorf("unable to get mapping for %s: %v", gk.String(), err)
+				}
+				groupResource := schema.GroupResource{Group: mapping.GroupVersionKind.Group, Resource: mapping.Resource}
+
+				assert.Equal(t, groupResource.String(), getForAction.GetResource().Resource, "should have requested metrics for the resource matching the GroupKind passed in")
+				assert.Equal(t, tc.singleObject.Name, name, "should have requested metrics for the object matching the name passed in")
+				metricPoint := tc.reportedMetricPoints[0]
+				timestamp := fixedTimestamp.Add(time.Duration(metricPoint.timestamp) * time.Minute)
+
+				metrics := &cmapi.MetricValueList{
+					Items: []cmapi.MetricValue{
+						{
+							DescribedObject: v1.ObjectReference{
+								Kind:       tc.singleObject.Kind,
+								APIVersion: tc.singleObject.APIVersion,
+								Name:       tc.singleObject.Name,
+							},
+							Timestamp:  metav1.Time{Time: timestamp},
+							MetricName: tc.metricName,
+							Value:      *resource.NewMilliQuantity(int64(metricPoint.level), resource.DecimalSI),
+						},
+					},
+				}
+
+				return true, metrics, nil
+			}
+		})
+	}
+
+	return fakeMetricsClient, fakeCMClient
+}
+
+func (tc *restClientTestCase) verifyResults(t *testing.T, metrics PodMetricsInfo, timestamp time.Time, err error) {
+	if tc.desiredError != nil {
+		assert.Error(t, err, "there should be an error retrieving the metrics")
+		assert.Contains(t, fmt.Sprintf("%v", err), fmt.Sprintf("%v", tc.desiredError), "the error message should be eas expected")
+		return
+	}
+	assert.NoError(t, err, "there should be no error retrieving the metrics")
+	assert.NotNil(t, metrics, "there should be metrics returned")
+
+	assert.Equal(t, tc.desiredMetricValues, metrics, "the metrics values should be as expected")
+
+	targetTimestamp := fixedTimestamp.Add(time.Duration(tc.targetTimestamp) * time.Minute)
+	assert.True(t, targetTimestamp.Equal(timestamp), fmt.Sprintf("the timestamp should be as expected (%s) but was %s", targetTimestamp, timestamp))
+}
+
+func (tc *restClientTestCase) runTest(t *testing.T) {
+	testMetricsClient, testCMClient := tc.prepareTestClient(t)
+	metricsClient := NewRESTMetricsClient(testMetricsClient.MetricsV1beta1(), testCMClient)
+	isResource := len(tc.resourceName) > 0
+	if isResource {
+		info, timestamp, err := metricsClient.GetResourceMetric(kv1.ResourceName(tc.resourceName), tc.namespace, tc.selector)
+		tc.verifyResults(t, info, timestamp, err)
+	} else if tc.singleObject == nil {
+		info, timestamp, err := metricsClient.GetRawMetric(tc.metricName, tc.namespace, tc.selector)
+		tc.verifyResults(t, info, timestamp, err)
+	} else {
+		val, timestamp, err := metricsClient.GetObjectMetric(tc.metricName, tc.namespace, tc.singleObject)
+		info := PodMetricsInfo{tc.singleObject.Name: val}
+		tc.verifyResults(t, info, timestamp, err)
+	}
+}
+
+func TestRESTClientCPU(t *testing.T) {
+	tc := restClientTestCase{
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 5000, "test-pod-1": 5000, "test-pod-2": 5000,
+		},
+		resourceName:       v1.ResourceCPU,
+		targetTimestamp:    1,
+		reportedPodMetrics: [][]int64{{5000}, {5000}, {5000}},
+	}
+	tc.runTest(t)
+}
+
+func TestRESTClientQPS(t *testing.T) {
+	tc := restClientTestCase{
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 10000, "test-pod-1": 20000, "test-pod-2": 10000,
+		},
+		metricName:           "qps",
+		targetTimestamp:      1,
+		reportedMetricPoints: []metricPoint{{10000, 1}, {20000, 1}, {10000, 1}},
+	}
+	tc.runTest(t)
+}
+
+func TestRESTClientSingleObject(t *testing.T) {
+	tc := restClientTestCase{
+		desiredMetricValues:  PodMetricsInfo{"some-dep": 10},
+		metricName:           "queue-length",
+		targetTimestamp:      1,
+		reportedMetricPoints: []metricPoint{{10, 1}},
+		singleObject: &autoscalingapi.CrossVersionObjectReference{
+			APIVersion: "extensions/v1beta1",
+			Kind:       "Deployment",
+			Name:       "some-dep",
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestRESTClientQpsSumEqualZero(t *testing.T) {
+	tc := restClientTestCase{
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 0, "test-pod-1": 0, "test-pod-2": 0,
+		},
+		metricName:           "qps",
+		targetTimestamp:      0,
+		reportedMetricPoints: []metricPoint{{0, 0}, {0, 0}, {0, 0}},
+	}
+	tc.runTest(t)
+}
+
+func TestRESTClientCPUEmptyMetrics(t *testing.T) {
+	tc := restClientTestCase{
+		resourceName:         v1.ResourceCPU,
+		desiredError:         fmt.Errorf("no metrics returned from heapster"),
+		reportedMetricPoints: []metricPoint{},
+		reportedPodMetrics:   [][]int64{},
+	}
+	tc.runTest(t)
+}
+
+func TestRESTClientCPUEmptyMetricsForOnePod(t *testing.T) {
+	tc := restClientTestCase{
+		resourceName: v1.ResourceCPU,
+		desiredMetricValues: PodMetricsInfo{
+			"test-pod-0": 100, "test-pod-1": 700,
+		},
+		reportedPodMetrics: [][]int64{{100}, {300, 400}, {}},
+	}
+	tc.runTest(t)
+}

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/metrics/utilization.go

@@ -0,0 +1,66 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metrics
+
+import (
+	"fmt"
+)
+
+// GetResourceUtilizationRatio takes in a set of metrics, a set of matching requests,
+// and a target utilization percentage, and calculates the ratio of
+// desired to actual utilization (returning that, the actual utilization, and the raw average value)
+func GetResourceUtilizationRatio(metrics PodMetricsInfo, requests map[string]int64, targetUtilization int32) (utilizationRatio float64, currentUtilization int32, rawAverageValue int64, err error) {
+	metricsTotal := int64(0)
+	requestsTotal := int64(0)
+	numEntries := 0
+
+	for podName, metricValue := range metrics {
+		request, hasRequest := requests[podName]
+		if !hasRequest {
+			// we check for missing requests elsewhere, so assuming missing requests == extraneous metrics
+			continue
+		}
+
+		metricsTotal += metricValue
+		requestsTotal += request
+		numEntries++
+	}
+
+	// if the set of requests is completely disjoint from the set of metrics,
+	// then we could have an issue where the requests total is zero
+	if requestsTotal == 0 {
+		return 0, 0, 0, fmt.Errorf("no metrics returned matched known pods")
+	}
+
+	currentUtilization = int32((metricsTotal * 100) / requestsTotal)
+
+	return float64(currentUtilization) / float64(targetUtilization), currentUtilization, metricsTotal / int64(numEntries), nil
+}
+
+// GetMetricUtilizationRatio takes in a set of metrics and a target utilization value,
+// and calcuates the ratio of desired to actual utilization
+// (returning that and the actual utilization)
+func GetMetricUtilizationRatio(metrics PodMetricsInfo, targetUtilization int64) (utilizationRatio float64, currentUtilization int64) {
+	metricsTotal := int64(0)
+	for _, metricValue := range metrics {
+		metricsTotal += metricValue
+	}
+
+	currentUtilization = metricsTotal / int64(len(metrics))
+
+	return float64(currentUtilization) / float64(targetUtilization), currentUtilization
+}

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/rate_limitters.go

@@ -0,0 +1,53 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package podautoscaler
+
+import (
+	"time"
+
+	"k8s.io/client-go/util/workqueue"
+)
+
+// FixedItemIntervalRateLimiter limits items to a fixed-rate interval
+type FixedItemIntervalRateLimiter struct {
+	interval time.Duration
+}
+
+var _ workqueue.RateLimiter = &FixedItemIntervalRateLimiter{}
+
+func NewFixedItemIntervalRateLimiter(interval time.Duration) workqueue.RateLimiter {
+	return &FixedItemIntervalRateLimiter{
+		interval: interval,
+	}
+}
+
+func (r *FixedItemIntervalRateLimiter) When(item interface{}) time.Duration {
+	return r.interval
+}
+
+func (r *FixedItemIntervalRateLimiter) NumRequeues(item interface{}) int {
+	return 1
+}
+
+func (r *FixedItemIntervalRateLimiter) Forget(item interface{}) {
+}
+
+// NewDefaultHPARateLimiter creates a rate limitter which limits overall (as per the
+// default controller rate limiter), as well as per the resync interval
+func NewDefaultHPARateLimiter(interval time.Duration) workqueue.RateLimiter {
+	return NewFixedItemIntervalRateLimiter(interval)
+}

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/replica_calculator.go

@@ -0,0 +1,288 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package podautoscaler
+
+import (
+	"fmt"
+	"math"
+	"time"
+
+	autoscaling "k8s.io/api/autoscaling/v2beta1"
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/util/sets"
+	v1coreclient "k8s.io/client-go/kubernetes/typed/core/v1"
+	podutil "k8s.io/kubernetes/pkg/api/v1/pod"
+	metricsclient "k8s.io/kubernetes/pkg/controller/podautoscaler/metrics"
+)
+
+const (
+	// defaultTestingTolerance is default value for calculating when to
+	// scale up/scale down.
+	defaultTestingTolerance = 0.1
+)
+
+type ReplicaCalculator struct {
+	metricsClient metricsclient.MetricsClient
+	podsGetter    v1coreclient.PodsGetter
+	tolerance     float64
+}
+
+func NewReplicaCalculator(metricsClient metricsclient.MetricsClient, podsGetter v1coreclient.PodsGetter, tolerance float64) *ReplicaCalculator {
+	return &ReplicaCalculator{
+		metricsClient: metricsClient,
+		podsGetter:    podsGetter,
+		tolerance:     tolerance,
+	}
+}
+
+// GetResourceReplicas calculates the desired replica count based on a target resource utilization percentage
+// of the given resource for pods matching the given selector in the given namespace, and the current replica count
+func (c *ReplicaCalculator) GetResourceReplicas(currentReplicas int32, targetUtilization int32, resource v1.ResourceName, namespace string, selector labels.Selector) (replicaCount int32, utilization int32, rawUtilization int64, timestamp time.Time, err error) {
+	metrics, timestamp, err := c.metricsClient.GetResourceMetric(resource, namespace, selector)
+	if err != nil {
+		return 0, 0, 0, time.Time{}, fmt.Errorf("unable to get metrics for resource %s: %v", resource, err)
+	}
+
+	podList, err := c.podsGetter.Pods(namespace).List(metav1.ListOptions{LabelSelector: selector.String()})
+	if err != nil {
+		return 0, 0, 0, time.Time{}, fmt.Errorf("unable to get pods while calculating replica count: %v", err)
+	}
+
+	itemsLen := len(podList.Items)
+	if itemsLen == 0 {
+		return 0, 0, 0, time.Time{}, fmt.Errorf("no pods returned by selector while calculating replica count")
+	}
+
+	requests := make(map[string]int64, itemsLen)
+	readyPodCount := 0
+	unreadyPods := sets.NewString()
+	missingPods := sets.NewString()
+
+	for _, pod := range podList.Items {
+		podSum := int64(0)
+		for _, container := range pod.Spec.Containers {
+			if containerRequest, ok := container.Resources.Requests[resource]; ok {
+				podSum += containerRequest.MilliValue()
+			} else {
+				return 0, 0, 0, time.Time{}, fmt.Errorf("missing request for %s on container %s in pod %s/%s", resource, container.Name, namespace, pod.Name)
+			}
+		}
+
+		requests[pod.Name] = podSum
+
+		if pod.Status.Phase != v1.PodRunning || !podutil.IsPodReady(&pod) {
+			// save this pod name for later, but pretend it doesn't exist for now
+			unreadyPods.Insert(pod.Name)
+			delete(metrics, pod.Name)
+			continue
+		}
+
+		if _, found := metrics[pod.Name]; !found {
+			// save this pod name for later, but pretend it doesn't exist for now
+			missingPods.Insert(pod.Name)
+			continue
+		}
+
+		readyPodCount++
+	}
+
+	if len(metrics) == 0 {
+		return 0, 0, 0, time.Time{}, fmt.Errorf("did not receive metrics for any ready pods")
+	}
+
+	usageRatio, utilization, rawUtilization, err := metricsclient.GetResourceUtilizationRatio(metrics, requests, targetUtilization)
+	if err != nil {
+		return 0, 0, 0, time.Time{}, err
+	}
+
+	rebalanceUnready := len(unreadyPods) > 0 && usageRatio > 1.0
+	if !rebalanceUnready && len(missingPods) == 0 {
+		if math.Abs(1.0-usageRatio) <= c.tolerance {
+			// return the current replicas if the change would be too small
+			return currentReplicas, utilization, rawUtilization, timestamp, nil
+		}
+
+		// if we don't have any unready or missing pods, we can calculate the new replica count now
+		return int32(math.Ceil(usageRatio * float64(readyPodCount))), utilization, rawUtilization, timestamp, nil
+	}
+
+	if len(missingPods) > 0 {
+		if usageRatio < 1.0 {
+			// on a scale-down, treat missing pods as using 100% of the resource request
+			for podName := range missingPods {
+				metrics[podName] = requests[podName]
+			}
+		} else if usageRatio > 1.0 {
+			// on a scale-up, treat missing pods as using 0% of the resource request
+			for podName := range missingPods {
+				metrics[podName] = 0
+			}
+		}
+	}
+
+	if rebalanceUnready {
+		// on a scale-up, treat unready pods as using 0% of the resource request
+		for podName := range unreadyPods {
+			metrics[podName] = 0
+		}
+	}
+
+	// re-run the utilization calculation with our new numbers
+	newUsageRatio, _, _, err := metricsclient.GetResourceUtilizationRatio(metrics, requests, targetUtilization)
+	if err != nil {
+		return 0, utilization, rawUtilization, time.Time{}, err
+	}
+
+	if math.Abs(1.0-newUsageRatio) <= c.tolerance || (usageRatio < 1.0 && newUsageRatio > 1.0) || (usageRatio > 1.0 && newUsageRatio < 1.0) {
+		// return the current replicas if the change would be too small,
+		// or if the new usage ratio would cause a change in scale direction
+		return currentReplicas, utilization, rawUtilization, timestamp, nil
+	}
+
+	// return the result, where the number of replicas considered is
+	// however many replicas factored into our calculation
+	return int32(math.Ceil(newUsageRatio * float64(len(metrics)))), utilization, rawUtilization, timestamp, nil
+}
+
+// GetRawResourceReplicas calculates the desired replica count based on a target resource utilization (as a raw milli-value)
+// for pods matching the given selector in the given namespace, and the current replica count
+func (c *ReplicaCalculator) GetRawResourceReplicas(currentReplicas int32, targetUtilization int64, resource v1.ResourceName, namespace string, selector labels.Selector) (replicaCount int32, utilization int64, timestamp time.Time, err error) {
+	metrics, timestamp, err := c.metricsClient.GetResourceMetric(resource, namespace, selector)
+	if err != nil {
+		return 0, 0, time.Time{}, fmt.Errorf("unable to get metrics for resource %s: %v", resource, err)
+	}
+
+	replicaCount, utilization, err = c.calcPlainMetricReplicas(metrics, currentReplicas, targetUtilization, namespace, selector)
+	return replicaCount, utilization, timestamp, err
+}
+
+// GetMetricReplicas calculates the desired replica count based on a target metric utilization
+// (as a milli-value) for pods matching the given selector in the given namespace, and the
+// current replica count
+func (c *ReplicaCalculator) GetMetricReplicas(currentReplicas int32, targetUtilization int64, metricName string, namespace string, selector labels.Selector) (replicaCount int32, utilization int64, timestamp time.Time, err error) {
+	metrics, timestamp, err := c.metricsClient.GetRawMetric(metricName, namespace, selector)
+	if err != nil {
+		return 0, 0, time.Time{}, fmt.Errorf("unable to get metric %s: %v", metricName, err)
+	}
+
+	replicaCount, utilization, err = c.calcPlainMetricReplicas(metrics, currentReplicas, targetUtilization, namespace, selector)
+	return replicaCount, utilization, timestamp, err
+}
+
+// calcPlainMetricReplicas calculates the desired replicas for plain (i.e. non-utilization percentage) metrics.
+func (c *ReplicaCalculator) calcPlainMetricReplicas(metrics metricsclient.PodMetricsInfo, currentReplicas int32, targetUtilization int64, namespace string, selector labels.Selector) (replicaCount int32, utilization int64, err error) {
+	podList, err := c.podsGetter.Pods(namespace).List(metav1.ListOptions{LabelSelector: selector.String()})
+	if err != nil {
+		return 0, 0, fmt.Errorf("unable to get pods while calculating replica count: %v", err)
+	}
+
+	if len(podList.Items) == 0 {
+		return 0, 0, fmt.Errorf("no pods returned by selector while calculating replica count")
+	}
+
+	readyPodCount := 0
+	unreadyPods := sets.NewString()
+	missingPods := sets.NewString()
+
+	for _, pod := range podList.Items {
+		if pod.Status.Phase != v1.PodRunning || !podutil.IsPodReady(&pod) {
+			// save this pod name for later, but pretend it doesn't exist for now
+			unreadyPods.Insert(pod.Name)
+			delete(metrics, pod.Name)
+			continue
+		}
+
+		if _, found := metrics[pod.Name]; !found {
+			// save this pod name for later, but pretend it doesn't exist for now
+			missingPods.Insert(pod.Name)
+			continue
+		}
+
+		readyPodCount++
+	}
+
+	if len(metrics) == 0 {
+		return 0, 0, fmt.Errorf("did not receive metrics for any ready pods")
+	}
+
+	usageRatio, utilization := metricsclient.GetMetricUtilizationRatio(metrics, targetUtilization)
+
+	rebalanceUnready := len(unreadyPods) > 0 && usageRatio > 1.0
+
+	if !rebalanceUnready && len(missingPods) == 0 {
+		if math.Abs(1.0-usageRatio) <= c.tolerance {
+			// return the current replicas if the change would be too small
+			return currentReplicas, utilization, nil
+		}
+
+		// if we don't have any unready or missing pods, we can calculate the new replica count now
+		return int32(math.Ceil(usageRatio * float64(readyPodCount))), utilization, nil
+	}
+
+	if len(missingPods) > 0 {
+		if usageRatio < 1.0 {
+			// on a scale-down, treat missing pods as using 100% of the resource request
+			for podName := range missingPods {
+				metrics[podName] = targetUtilization
+			}
+		} else {
+			// on a scale-up, treat missing pods as using 0% of the resource request
+			for podName := range missingPods {
+				metrics[podName] = 0
+			}
+		}
+	}
+
+	if rebalanceUnready {
+		// on a scale-up, treat unready pods as using 0% of the resource request
+		for podName := range unreadyPods {
+			metrics[podName] = 0
+		}
+	}
+
+	// re-run the utilization calculation with our new numbers
+	newUsageRatio, _ := metricsclient.GetMetricUtilizationRatio(metrics, targetUtilization)
+
+	if math.Abs(1.0-newUsageRatio) <= c.tolerance || (usageRatio < 1.0 && newUsageRatio > 1.0) || (usageRatio > 1.0 && newUsageRatio < 1.0) {
+		// return the current replicas if the change would be too small,
+		// or if the new usage ratio would cause a change in scale direction
+		return currentReplicas, utilization, nil
+	}
+
+	// return the result, where the number of replicas considered is
+	// however many replicas factored into our calculation
+	return int32(math.Ceil(newUsageRatio * float64(len(metrics)))), utilization, nil
+}
+
+// GetObjectMetricReplicas calculates the desired replica count based on a target metric utilization (as a milli-value)
+// for the given object in the given namespace, and the current replica count.
+func (c *ReplicaCalculator) GetObjectMetricReplicas(currentReplicas int32, targetUtilization int64, metricName string, namespace string, objectRef *autoscaling.CrossVersionObjectReference) (replicaCount int32, utilization int64, timestamp time.Time, err error) {
+	utilization, timestamp, err = c.metricsClient.GetObjectMetric(metricName, namespace, objectRef)
+	if err != nil {
+		return 0, 0, time.Time{}, fmt.Errorf("unable to get metric %s: %v on %s %s/%s", metricName, objectRef.Kind, namespace, objectRef.Name, err)
+	}
+
+	usageRatio := float64(utilization) / float64(targetUtilization)
+	if math.Abs(1.0-usageRatio) <= c.tolerance {
+		// return the current replicas if the change would be too small
+		return currentReplicas, utilization, timestamp, nil
+	}
+
+	return int32(math.Ceil(usageRatio * float64(currentReplicas))), utilization, timestamp, nil
+}

vendor/k8s.io/kubernetes/pkg/controller/podautoscaler/replica_calculator_test.go

@@ -0,0 +1,786 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package podautoscaler
+
+import (
+	"fmt"
+	"math"
+	"testing"
+	"time"
+
+	autoscalingv2 "k8s.io/api/autoscaling/v2beta1"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/kubernetes/fake"
+	core "k8s.io/client-go/testing"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/controller/podautoscaler/metrics"
+	cmapi "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1"
+	metricsapi "k8s.io/metrics/pkg/apis/metrics/v1beta1"
+	metricsfake "k8s.io/metrics/pkg/client/clientset_generated/clientset/fake"
+	cmfake "k8s.io/metrics/pkg/client/custom_metrics/fake"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type resourceInfo struct {
+	name     v1.ResourceName
+	requests []resource.Quantity
+	levels   []int64
+	// only applies to pod names returned from "heapster"
+	podNames []string
+
+	targetUtilization   int32
+	expectedUtilization int32
+	expectedValue       int64
+}
+
+type metricInfo struct {
+	name         string
+	levels       []int64
+	singleObject *autoscalingv2.CrossVersionObjectReference
+
+	targetUtilization   int64
+	expectedUtilization int64
+}
+
+type replicaCalcTestCase struct {
+	currentReplicas  int32
+	expectedReplicas int32
+	expectedError    error
+
+	timestamp time.Time
+
+	resource *resourceInfo
+	metric   *metricInfo
+
+	podReadiness []v1.ConditionStatus
+}
+
+const (
+	testNamespace       = "test-namespace"
+	podNamePrefix       = "test-pod"
+	numContainersPerPod = 2
+)
+
+func (tc *replicaCalcTestCase) prepareTestClient(t *testing.T) (*fake.Clientset, *metricsfake.Clientset, *cmfake.FakeCustomMetricsClient) {
+
+	fakeClient := &fake.Clientset{}
+	fakeClient.AddReactor("list", "pods", func(action core.Action) (handled bool, ret runtime.Object, err error) {
+		obj := &v1.PodList{}
+		for i := 0; i < int(tc.currentReplicas); i++ {
+			podReadiness := v1.ConditionTrue
+			if tc.podReadiness != nil {
+				podReadiness = tc.podReadiness[i]
+			}
+			podName := fmt.Sprintf("%s-%d", podNamePrefix, i)
+			pod := v1.Pod{
+				Status: v1.PodStatus{
+					Phase: v1.PodRunning,
+					Conditions: []v1.PodCondition{
+						{
+							Type:   v1.PodReady,
+							Status: podReadiness,
+						},
+					},
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      podName,
+					Namespace: testNamespace,
+					Labels: map[string]string{
+						"name": podNamePrefix,
+					},
+				},
+				Spec: v1.PodSpec{
+					Containers: []v1.Container{{}, {}},
+				},
+			}
+
+			if tc.resource != nil && i < len(tc.resource.requests) {
+				pod.Spec.Containers[0].Resources = v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						tc.resource.name: tc.resource.requests[i],
+					},
+				}
+				pod.Spec.Containers[1].Resources = v1.ResourceRequirements{
+					Requests: v1.ResourceList{
+						tc.resource.name: tc.resource.requests[i],
+					},
+				}
+			}
+			obj.Items = append(obj.Items, pod)
+		}
+		return true, obj, nil
+	})
+
+	fakeMetricsClient := &metricsfake.Clientset{}
+	// NB: we have to sound like Gollum due to gengo's inability to handle already-plural resource names
+	fakeMetricsClient.AddReactor("list", "pods", func(action core.Action) (handled bool, ret runtime.Object, err error) {
+		if tc.resource != nil {
+			metrics := &metricsapi.PodMetricsList{}
+			for i, resValue := range tc.resource.levels {
+				podName := fmt.Sprintf("%s-%d", podNamePrefix, i)
+				if len(tc.resource.podNames) > i {
+					podName = tc.resource.podNames[i]
+				}
+				// NB: the list reactor actually does label selector filtering for us,
+				// so we have to make sure our results match the label selector
+				podMetric := metricsapi.PodMetrics{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      podName,
+						Namespace: testNamespace,
+						Labels:    map[string]string{"name": podNamePrefix},
+					},
+					Timestamp:  metav1.Time{Time: tc.timestamp},
+					Containers: make([]metricsapi.ContainerMetrics, numContainersPerPod),
+				}
+
+				for i := 0; i < numContainersPerPod; i++ {
+					podMetric.Containers[i] = metricsapi.ContainerMetrics{
+						Name: fmt.Sprintf("container%v", i),
+						Usage: v1.ResourceList{
+							v1.ResourceName(tc.resource.name): *resource.NewMilliQuantity(
+								int64(resValue),
+								resource.DecimalSI),
+						},
+					}
+				}
+				metrics.Items = append(metrics.Items, podMetric)
+			}
+			return true, metrics, nil
+		}
+
+		return true, nil, fmt.Errorf("no pod resource metrics specified in test client")
+	})
+
+	fakeCMClient := &cmfake.FakeCustomMetricsClient{}
+	fakeCMClient.AddReactor("get", "*", func(action core.Action) (handled bool, ret runtime.Object, err error) {
+		getForAction, wasGetFor := action.(cmfake.GetForAction)
+		if !wasGetFor {
+			return true, nil, fmt.Errorf("expected a get-for action, got %v instead", action)
+		}
+
+		if tc.metric == nil {
+			return true, nil, fmt.Errorf("no custom metrics specified in test client")
+		}
+
+		assert.Equal(t, tc.metric.name, getForAction.GetMetricName(), "the metric requested should have matched the one specified")
+
+		if getForAction.GetName() == "*" {
+			metrics := cmapi.MetricValueList{}
+
+			// multiple objects
+			assert.Equal(t, "pods", getForAction.GetResource().Resource, "the type of object that we requested multiple metrics for should have been pods")
+
+			for i, level := range tc.metric.levels {
+				podMetric := cmapi.MetricValue{
+					DescribedObject: v1.ObjectReference{
+						Kind:      "Pod",
+						Name:      fmt.Sprintf("%s-%d", podNamePrefix, i),
+						Namespace: testNamespace,
+					},
+					Timestamp:  metav1.Time{Time: tc.timestamp},
+					MetricName: tc.metric.name,
+					Value:      *resource.NewMilliQuantity(level, resource.DecimalSI),
+				}
+				metrics.Items = append(metrics.Items, podMetric)
+			}
+
+			return true, &metrics, nil
+		}
+		name := getForAction.GetName()
+		mapper := legacyscheme.Registry.RESTMapper()
+		metrics := &cmapi.MetricValueList{}
+		assert.NotNil(t, tc.metric.singleObject, "should have only requested a single-object metric when calling GetObjectMetricReplicas")
+		gk := schema.FromAPIVersionAndKind(tc.metric.singleObject.APIVersion, tc.metric.singleObject.Kind).GroupKind()
+		mapping, err := mapper.RESTMapping(gk)
+		if err != nil {
+			return true, nil, fmt.Errorf("unable to get mapping for %s: %v", gk.String(), err)
+		}
+		groupResource := schema.GroupResource{Group: mapping.GroupVersionKind.Group, Resource: mapping.Resource}
+
+		assert.Equal(t, groupResource.String(), getForAction.GetResource().Resource, "should have requested metrics for the resource matching the GroupKind passed in")
+		assert.Equal(t, tc.metric.singleObject.Name, name, "should have requested metrics for the object matching the name passed in")
+
+		metrics.Items = []cmapi.MetricValue{
+			{
+				DescribedObject: v1.ObjectReference{
+					Kind:       tc.metric.singleObject.Kind,
+					APIVersion: tc.metric.singleObject.APIVersion,
+					Name:       name,
+				},
+				Timestamp:  metav1.Time{Time: tc.timestamp},
+				MetricName: tc.metric.name,
+				Value:      *resource.NewMilliQuantity(int64(tc.metric.levels[0]), resource.DecimalSI),
+			},
+		}
+
+		return true, metrics, nil
+	})
+
+	return fakeClient, fakeMetricsClient, fakeCMClient
+}
+
+func (tc *replicaCalcTestCase) runTest(t *testing.T) {
+	testClient, testMetricsClient, testCMClient := tc.prepareTestClient(t)
+	metricsClient := metrics.NewRESTMetricsClient(testMetricsClient.MetricsV1beta1(), testCMClient)
+
+	replicaCalc := &ReplicaCalculator{
+		metricsClient: metricsClient,
+		podsGetter:    testClient.Core(),
+		tolerance:     defaultTestingTolerance,
+	}
+
+	selector, err := metav1.LabelSelectorAsSelector(&metav1.LabelSelector{
+		MatchLabels: map[string]string{"name": podNamePrefix},
+	})
+	if err != nil {
+		require.Nil(t, err, "something went horribly wrong...")
+	}
+
+	if tc.resource != nil {
+		outReplicas, outUtilization, outRawValue, outTimestamp, err := replicaCalc.GetResourceReplicas(tc.currentReplicas, tc.resource.targetUtilization, tc.resource.name, testNamespace, selector)
+
+		if tc.expectedError != nil {
+			require.Error(t, err, "there should be an error calculating the replica count")
+			assert.Contains(t, err.Error(), tc.expectedError.Error(), "the error message should have contained the expected error message")
+			return
+		}
+		require.NoError(t, err, "there should not have been an error calculating the replica count")
+		assert.Equal(t, tc.expectedReplicas, outReplicas, "replicas should be as expected")
+		assert.Equal(t, tc.resource.expectedUtilization, outUtilization, "utilization should be as expected")
+		assert.Equal(t, tc.resource.expectedValue, outRawValue, "raw value should be as expected")
+		assert.True(t, tc.timestamp.Equal(outTimestamp), "timestamp should be as expected")
+
+	} else {
+		var outReplicas int32
+		var outUtilization int64
+		var outTimestamp time.Time
+		var err error
+		if tc.metric.singleObject != nil {
+			outReplicas, outUtilization, outTimestamp, err = replicaCalc.GetObjectMetricReplicas(tc.currentReplicas, tc.metric.targetUtilization, tc.metric.name, testNamespace, tc.metric.singleObject)
+		} else {
+			outReplicas, outUtilization, outTimestamp, err = replicaCalc.GetMetricReplicas(tc.currentReplicas, tc.metric.targetUtilization, tc.metric.name, testNamespace, selector)
+		}
+
+		if tc.expectedError != nil {
+			require.Error(t, err, "there should be an error calculating the replica count")
+			assert.Contains(t, err.Error(), tc.expectedError.Error(), "the error message should have contained the expected error message")
+			return
+		}
+		require.NoError(t, err, "there should not have been an error calculating the replica count")
+		assert.Equal(t, tc.expectedReplicas, outReplicas, "replicas should be as expected")
+		assert.Equal(t, tc.metric.expectedUtilization, outUtilization, "utilization should be as expected")
+		assert.True(t, tc.timestamp.Equal(outTimestamp), "timestamp should be as expected")
+	}
+}
+
+func TestReplicaCalcDisjointResourcesMetrics(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas: 1,
+		expectedError:   fmt.Errorf("no metrics returned matched known pods"),
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0")},
+			levels:   []int64{100},
+			podNames: []string{"an-older-pod-name"},
+
+			targetUtilization: 100,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleUp(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 5,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{300, 500, 700},
+
+			targetUtilization:   30,
+			expectedUtilization: 50,
+			expectedValue:       numContainersPerPod * 500,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleUpUnreadyLessScale(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 4,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionFalse, v1.ConditionTrue, v1.ConditionTrue},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{300, 500, 700},
+
+			targetUtilization:   30,
+			expectedUtilization: 60,
+			expectedValue:       numContainersPerPod * 600,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleUpUnreadyNoScale(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionTrue, v1.ConditionFalse, v1.ConditionFalse},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{400, 500, 700},
+
+			targetUtilization:   30,
+			expectedUtilization: 40,
+			expectedValue:       numContainersPerPod * 400,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleUpCM(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 4,
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{20000, 10000, 30000},
+			targetUtilization:   15000,
+			expectedUtilization: 20000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleUpCMUnreadyLessScale(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 4,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionTrue, v1.ConditionTrue, v1.ConditionFalse},
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{50000, 10000, 30000},
+			targetUtilization:   15000,
+			expectedUtilization: 30000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleUpCMUnreadyNoScaleWouldScaleDown(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionFalse, v1.ConditionTrue, v1.ConditionFalse},
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{50000, 15000, 30000},
+			targetUtilization:   15000,
+			expectedUtilization: 15000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleUpCMObject(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 4,
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{20000},
+			targetUtilization:   15000,
+			expectedUtilization: 20000,
+			singleObject: &autoscalingv2.CrossVersionObjectReference{
+				Kind:       "Deployment",
+				APIVersion: "extensions/v1beta1",
+				Name:       "some-deployment",
+			},
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleDown(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  5,
+		expectedReplicas: 3,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{100, 300, 500, 250, 250},
+
+			targetUtilization:   50,
+			expectedUtilization: 28,
+			expectedValue:       numContainersPerPod * 280,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleDownCM(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  5,
+		expectedReplicas: 3,
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{12000, 12000, 12000, 12000, 12000},
+			targetUtilization:   20000,
+			expectedUtilization: 12000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleDownCMObject(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  5,
+		expectedReplicas: 3,
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{12000},
+			targetUtilization:   20000,
+			expectedUtilization: 12000,
+			singleObject: &autoscalingv2.CrossVersionObjectReference{
+				Kind:       "Deployment",
+				APIVersion: "extensions/v1beta1",
+				Name:       "some-deployment",
+			},
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcScaleDownIgnoresUnreadyPods(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  5,
+		expectedReplicas: 2,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionTrue, v1.ConditionTrue, v1.ConditionTrue, v1.ConditionFalse, v1.ConditionFalse},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{100, 300, 500, 250, 250},
+
+			targetUtilization:   50,
+			expectedUtilization: 30,
+			expectedValue:       numContainersPerPod * 300,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcTolerance(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("0.9"), resource.MustParse("1.0"), resource.MustParse("1.1")},
+			levels:   []int64{1010, 1030, 1020},
+
+			targetUtilization:   100,
+			expectedUtilization: 102,
+			expectedValue:       numContainersPerPod * 1020,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcToleranceCM(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{20000, 21000, 21000},
+			targetUtilization:   20000,
+			expectedUtilization: 20666,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcToleranceCMObject(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		metric: &metricInfo{
+			name:                "qps",
+			levels:              []int64{20666},
+			targetUtilization:   20000,
+			expectedUtilization: 20666,
+			singleObject: &autoscalingv2.CrossVersionObjectReference{
+				Kind:       "Deployment",
+				APIVersion: "extensions/v1beta1",
+				Name:       "some-deployment",
+			},
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcSuperfluousMetrics(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  4,
+		expectedReplicas: 24,
+		resource: &resourceInfo{
+			name:                v1.ResourceCPU,
+			requests:            []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:              []int64{4000, 9500, 3000, 7000, 3200, 2000},
+			targetUtilization:   100,
+			expectedUtilization: 587,
+			expectedValue:       numContainersPerPod * 5875,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcMissingMetrics(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  4,
+		expectedReplicas: 3,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{400, 95},
+
+			targetUtilization:   100,
+			expectedUtilization: 24,
+			expectedValue:       495, // numContainersPerPod * 247, for sufficiently large values of 247
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcEmptyMetrics(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas: 4,
+		expectedError:   fmt.Errorf("unable to get metrics for resource cpu: no metrics returned from heapster"),
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{},
+
+			targetUtilization: 100,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcEmptyCPURequest(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas: 1,
+		expectedError:   fmt.Errorf("missing request for"),
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{},
+			levels:   []int64{200},
+
+			targetUtilization: 100,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcMissingMetricsNoChangeEq(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  2,
+		expectedReplicas: 2,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{1000},
+
+			targetUtilization:   100,
+			expectedUtilization: 100,
+			expectedValue:       numContainersPerPod * 1000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcMissingMetricsNoChangeGt(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  2,
+		expectedReplicas: 2,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{1900},
+
+			targetUtilization:   100,
+			expectedUtilization: 190,
+			expectedValue:       numContainersPerPod * 1900,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcMissingMetricsNoChangeLt(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  2,
+		expectedReplicas: 2,
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{600},
+
+			targetUtilization:   100,
+			expectedUtilization: 60,
+			expectedValue:       numContainersPerPod * 600,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcMissingMetricsUnreadyNoChange(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 3,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionFalse, v1.ConditionTrue, v1.ConditionTrue},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{100, 450},
+
+			targetUtilization:   50,
+			expectedUtilization: 45,
+			expectedValue:       numContainersPerPod * 450,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcMissingMetricsUnreadyScaleUp(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  3,
+		expectedReplicas: 4,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionFalse, v1.ConditionTrue, v1.ConditionTrue},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{100, 2000},
+
+			targetUtilization:   50,
+			expectedUtilization: 200,
+			expectedValue:       numContainersPerPod * 2000,
+		},
+	}
+	tc.runTest(t)
+}
+
+func TestReplicaCalcMissingMetricsUnreadyScaleDown(t *testing.T) {
+	tc := replicaCalcTestCase{
+		currentReplicas:  4,
+		expectedReplicas: 3,
+		podReadiness:     []v1.ConditionStatus{v1.ConditionFalse, v1.ConditionTrue, v1.ConditionTrue, v1.ConditionTrue},
+		resource: &resourceInfo{
+			name:     v1.ResourceCPU,
+			requests: []resource.Quantity{resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0"), resource.MustParse("1.0")},
+			levels:   []int64{100, 100, 100},
+
+			targetUtilization:   50,
+			expectedUtilization: 10,
+			expectedValue:       numContainersPerPod * 100,
+		},
+	}
+	tc.runTest(t)
+}
+
+// TestComputedToleranceAlgImplementation is a regression test which
+// back-calculates a minimal percentage for downscaling based on a small percentage
+// increase in pod utilization which is calibrated against the tolerance value.
+func TestReplicaCalcComputedToleranceAlgImplementation(t *testing.T) {
+
+	startPods := int32(10)
+	// 150 mCPU per pod.
+	totalUsedCPUOfAllPods := int64(startPods * 150)
+	// Each pod starts out asking for 2X what is really needed.
+	// This means we will have a 50% ratio of used/requested
+	totalRequestedCPUOfAllPods := int32(2 * totalUsedCPUOfAllPods)
+	requestedToUsed := float64(totalRequestedCPUOfAllPods / int32(totalUsedCPUOfAllPods))
+	// Spread the amount we ask over 10 pods.  We can add some jitter later in reportedLevels.
+	perPodRequested := totalRequestedCPUOfAllPods / startPods
+
+	// Force a minimal scaling event by satisfying  (tolerance < 1 - resourcesUsedRatio).
+	target := math.Abs(1/(requestedToUsed*(1-defaultTestingTolerance))) + .01
+	finalCPUPercentTarget := int32(target * 100)
+	resourcesUsedRatio := float64(totalUsedCPUOfAllPods) / float64(float64(totalRequestedCPUOfAllPods)*target)
+
+	// i.e. .60 * 20 -> scaled down expectation.
+	finalPods := int32(math.Ceil(resourcesUsedRatio * float64(startPods)))
+
+	// To breach tolerance we will create a utilization ratio difference of tolerance to usageRatioToleranceValue)
+	tc := replicaCalcTestCase{
+		currentReplicas:  startPods,
+		expectedReplicas: finalPods,
+		resource: &resourceInfo{
+			name: v1.ResourceCPU,
+			levels: []int64{
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+				totalUsedCPUOfAllPods / 10,
+			},
+			requests: []resource.Quantity{
+				resource.MustParse(fmt.Sprint(perPodRequested+100) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested-100) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested+10) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested-10) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested+2) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested-2) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested+1) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested-1) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested) + "m"),
+				resource.MustParse(fmt.Sprint(perPodRequested) + "m"),
+			},
+
+			targetUtilization:   finalCPUPercentTarget,
+			expectedUtilization: int32(totalUsedCPUOfAllPods*100) / totalRequestedCPUOfAllPods,
+			expectedValue:       numContainersPerPod * totalUsedCPUOfAllPods / 10,
+		},
+	}
+
+	tc.runTest(t)
+
+	// Reuse the data structure above, now testing "unscaling".
+	// Now, we test that no scaling happens if we are in a very close margin to the tolerance
+	target = math.Abs(1/(requestedToUsed*(1-defaultTestingTolerance))) + .004
+	finalCPUPercentTarget = int32(target * 100)
+	tc.resource.targetUtilization = finalCPUPercentTarget
+	tc.currentReplicas = startPods
+	tc.expectedReplicas = startPods
+	tc.runTest(t)
+}
+
+// TODO: add more tests