// RunUnidlingController starts the unidling controller
func (c *MasterConfig) RunUnidlingController() {
oc, kc := c.UnidlingControllerClients()
resyncPeriod := 2 * time.Hour
scaleNamespacer := osclient.NewDelegatingScaleNamespacer(oc, kc.Extensions())
dcCoreClient := deployclient.New(oc.RESTClient)
cont := unidlingcontroller.NewUnidlingController(scaleNamespacer, kc.Core(), kc.Core(), dcCoreClient, kc.Core(), resyncPeriod)
cont.Run(utilwait.NeverStop)
}
// RunUnidlingController starts the unidling controller
func (c *MasterConfig) RunUnidlingController() {
oc, kc := c.UnidlingControllerClients()
resyncPeriod := 2 * time.Hour
scaleNamespacer := osclient.NewDelegatingScaleNamespacer(oc, kc)
coreClient := clientadapter.FromUnversionedClient(kc).Core()
dcCoreClient := deployclient.New(oc.RESTClient)
cont := unidlingcontroller.NewUnidlingController(scaleNamespacer, coreClient, coreClient, dcCoreClient, coreClient, resyncPeriod)
cont.Run(utilwait.NeverStop)
}
// RunHPAController starts the Kubernetes hpa controller sync loop
func (c *MasterConfig) RunHPAController(oc *osclient.Client, kc *kclientset.Clientset, heapsterNamespace string) {
delegatingScaleNamespacer := osclient.NewDelegatingScaleNamespacer(oc, kc)
podautoscaler := podautoscalercontroller.NewHorizontalController(
kc,
delegatingScaleNamespacer,
kc,
metrics.NewHeapsterMetricsClient(kc, heapsterNamespace, "https", "heapster", ""),
c.ControllerManager.HorizontalPodAutoscalerSyncPeriod.Duration,
)
go podautoscaler.Run(utilwait.NeverStop)
}
// RunHPAController starts the Kubernetes hpa controller sync loop
func (c *MasterConfig) RunHPAController(oc *osclient.Client, kc *client.Client, heapsterNamespace string) {
clientsetClient := internalclientset.FromUnversionedClient(kc)
delegatingScaleNamespacer := osclient.NewDelegatingScaleNamespacer(oc, kc)
podautoscaler := podautoscalercontroller.NewHorizontalController(
coreunversioned.EventsGetter(clientsetClient),
extensionsunversioned.ScalesGetter(delegatingScaleNamespacer),
extensionsunversioned.HorizontalPodAutoscalersGetter(clientsetClient),
metrics.NewHeapsterMetricsClient(clientsetClient, heapsterNamespace, "https", "heapster", ""),
c.ControllerManager.HorizontalPodAutoscalerSyncPeriod.Duration,
)
go podautoscaler.Run(utilwait.NeverStop)
}
// RunHPAController starts the Kubernetes hpa controller sync loop
func (c *MasterConfig) RunHPAController(oc *osclient.Client, kc *client.Client, heapsterNamespace string) {
delegScaleNamespacer := osclient.NewDelegatingScaleNamespacer(oc, kc)
podautoscaler := podautoscalercontroller.NewHorizontalController(kc, delegScaleNamespacer, kc, metrics.NewHeapsterMetricsClient(kc, heapsterNamespace, "https", "heapster", ""))
podautoscaler.Run(c.ControllerManager.HorizontalPodAutoscalerSyncPeriod)
}
// RunIdle runs the idling command logic, taking a list of resources or services in a file, scaling the associated
// scalable resources to zero, and annotating the associated endpoints objects with the scalable resources to unidle
// when they receive traffic.
func (o *IdleOptions) RunIdle(f *clientcmd.Factory) error {
hadError := false
nowTime := time.Now().UTC()
// figure out which endpoints and resources we need to idle
byService, byScalable, err := o.calculateIdlableAnnotationsByService(f)
if err != nil {
if len(byService) == 0 || len(byScalable) == 0 {
return fmt.Errorf("no valid scalable resources found to idle: %v", err)
}
fmt.Fprintf(o.errOut, "warning: continuing on for valid scalable resources, but an error occurred while finding scalable resources to idle: %v", err)
}
oclient, _, kclient, err := f.Clients()
if err != nil {
return err
}
delegScaleGetter := osclient.NewDelegatingScaleNamespacer(oclient, kclient.Extensions())
dcGetter := deployclient.New(oclient.RESTClient)
scaleAnnotater := utilunidling.NewScaleAnnotater(delegScaleGetter, dcGetter, kclient.Core(), func(currentReplicas int32, annotations map[string]string) {
annotations[unidlingapi.IdledAtAnnotation] = nowTime.UTC().Format(time.RFC3339)
annotations[unidlingapi.PreviousScaleAnnotation] = fmt.Sprintf("%v", currentReplicas)
})
replicas := make(map[unidlingapi.CrossGroupObjectReference]int32, len(byScalable))
toScale := make(map[unidlingapi.CrossGroupObjectReference]scaleInfo)
mapper, typer := f.Object(false)
// first, collect the scale info
for scaleRef, svcName := range byScalable {
obj, scale, err := scaleAnnotater.GetObjectWithScale(svcName.Namespace, scaleRef)
if err != nil {
fmt.Fprintf(o.errOut, "error: unable to get scale for %s %s/%s, not marking that scalable as idled: %v\n", scaleRef.Kind, svcName.Namespace, scaleRef.Name, err)
svcInfo := byService[svcName]
delete(svcInfo.scaleRefs, scaleRef)
hadError = true
continue
}
replicas[scaleRef] = scale.Spec.Replicas
toScale[scaleRef] = scaleInfo{scale: scale, obj: obj, namespace: svcName.Namespace}
}
// annotate the endpoints objects to indicate which scalable resources need to be unidled on traffic
for serviceName, info := range byService {
if info.obj.Annotations == nil {
info.obj.Annotations = make(map[string]string)
}
refsWithScale, err := pairScalesWithScaleRefs(serviceName, info.obj.Annotations, info.scaleRefs, replicas)
if err != nil {
fmt.Fprintf(o.errOut, "error: unable to mark service %s as idled: %v", serviceName.String(), err)
continue
}
if !o.dryRun {
if len(info.scaleRefs) == 0 {
fmt.Fprintf(o.errOut, "error: no scalable resources marked as idled for service %s, not marking as idled\n", serviceName.String())
hadError = true
continue
}
metadata, err := meta.Accessor(info.obj)
if err != nil {
fmt.Fprintf(o.errOut, "error: unable to mark service %s as idled: %v", serviceName.String(), err)
hadError = true
continue
}
gvks, _, err := typer.ObjectKinds(info.obj)
if err != nil {
fmt.Fprintf(o.errOut, "error: unable to mark service %s as idled: %v", serviceName.String(), err)
hadError = true
continue
}
oldData, err := json.Marshal(info.obj)
if err != nil {
fmt.Fprintf(o.errOut, "error: unable to mark service %s as idled: %v", serviceName.String(), err)
hadError = true
continue
}
mapping, err := mapper.RESTMapping(gvks[0].GroupKind(), gvks[0].Version)
if err != nil {
fmt.Fprintf(o.errOut, "error: unable to mark service %s as idled: %v", serviceName.String(), err)
hadError = true
continue
}
if err = setIdleAnnotations(serviceName, info.obj.Annotations, refsWithScale, nowTime); err != nil {
fmt.Fprintf(o.errOut, "error: unable to mark service %s as idled: %v", serviceName.String(), err)
hadError = true
continue
}
if _, err := patchObj(info.obj, metadata, oldData, mapping, f); err != nil {
fmt.Fprintf(o.errOut, "error: unable to mark service %s as idled: %v", serviceName.String(), err)
hadError = true
continue
}
}
for _, scaleRef := range refsWithScale {
fmt.Fprintf(o.out, "Marked service %s to unidle resource %s %s/%s (unidle to %v replicas)\n", serviceName.String(), scaleRef.Kind, serviceName.Namespace, scaleRef.Name, scaleRef.Replicas)
}
}
// actually "idle" the scalable resources by scaling them down to zero
// (scale down to zero *after* we've applied the annotation so that we don't miss any traffic)
for scaleRef, info := range toScale {
idled := ""
if !o.dryRun {
info.scale.Spec.Replicas = 0
scaleUpdater := utilunidling.NewScaleUpdater(f.JSONEncoder(), info.namespace, dcGetter, kclient.Core())
if err := scaleAnnotater.UpdateObjectScale(scaleUpdater, info.namespace, scaleRef, info.obj, info.scale); err != nil {
fmt.Fprintf(o.errOut, "error: unable to scale %s %s/%s to 0, but still listed as target for unidling: %v\n", scaleRef.Kind, info.namespace, scaleRef.Name, err)
hadError = true
continue
}
} else {
idled = "(dry run)"
}
fmt.Fprintf(o.out, "Idled %s %s/%s %s\n", scaleRef.Kind, info.namespace, scaleRef.Name, idled)
}
if hadError {
return cmdutil.ErrExit
}
return nil
}
// RunHPAController starts the Kubernetes hpa controller sync loop
func (c *MasterConfig) RunHPAController(oc *osclient.Client, kc *client.Client, heapsterNamespace string) {
clientsetClient := internalclientset.FromUnversionedClient(kc)
delegScaleNamespacer := osclient.NewDelegatingScaleNamespacer(oc, kc)
podautoscaler := podautoscalercontroller.NewHorizontalController(clientsetClient, delegScaleNamespacer, clientsetClient, metrics.NewHeapsterMetricsClient(clientsetClient, heapsterNamespace, "https", "heapster", ""))
podautoscaler.Run(c.ControllerManager.HorizontalPodAutoscalerSyncPeriod)
}