origin/pkg/cmd/server/origin/controller/quota.go at v3.7.0-alpha.1 · openshift/origin · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
package controller

import (
	"math/rand"
	"time"

	"github.com/openshift/origin/pkg/cmd/server/bootstrappolicy"
	quotacontroller "github.com/openshift/origin/pkg/quota/controller"
	"github.com/openshift/origin/pkg/quota/controller/clusterquotamapping"
	"github.com/openshift/origin/pkg/quota/controller/clusterquotareconciliation"
	"k8s.io/kubernetes/pkg/controller"
	kresourcequota "k8s.io/kubernetes/pkg/controller/resourcequota"

	"github.com/openshift/origin/pkg/quota"
)

func RunResourceQuotaManager(ctx ControllerContext) (bool, error) {
	concurrentResourceQuotaSyncs := int(ctx.KubeControllerContext.Options.ConcurrentResourceQuotaSyncs)
	resourceQuotaSyncPeriod := ctx.KubeControllerContext.Options.ResourceQuotaSyncPeriod.Duration
	replenishmentSyncPeriodFunc := calculateResyncPeriod(ctx.KubeControllerContext.Options.MinResyncPeriod.Duration)
	saName := "resourcequota-controller"

	resourceQuotaRegistry := quota.NewOriginQuotaRegistry(
		ctx.ImageInformers.Image().InternalVersion().ImageStreams(),
		ctx.ClientBuilder.DeprecatedOpenshiftClientOrDie(saName),
	)

	resourceQuotaControllerOptions := &kresourcequota.ResourceQuotaControllerOptions{
		QuotaClient:           ctx.ClientBuilder.ClientOrDie(saName).Core(),
		ResourceQuotaInformer: ctx.ExternalKubeInformers.Core().V1().ResourceQuotas(),
		ResyncPeriod:          controller.StaticResyncPeriodFunc(resourceQuotaSyncPeriod),
		Registry:              resourceQuotaRegistry,
		GroupKindsToReplenish: quota.AllEvaluatedGroupKinds,
		ControllerFactory: quotacontroller.NewAllResourceReplenishmentControllerFactory(
			ctx.ExternalKubeInformers,
			ctx.ImageInformers.Image().InternalVersion().ImageStreams(),
			ctx.ClientBuilder.DeprecatedOpenshiftClientOrDie(saName),
		),
		ReplenishmentResyncPeriod: replenishmentSyncPeriodFunc,
	}
	go kresourcequota.NewResourceQuotaController(resourceQuotaControllerOptions).Run(concurrentResourceQuotaSyncs, ctx.Stop)

	return true, nil
}

type ClusterQuotaReconciliationControllerConfig struct {
	DefaultResyncPeriod            time.Duration
	DefaultReplenishmentSyncPeriod time.Duration
}

func (c *ClusterQuotaReconciliationControllerConfig) RunController(ctx ControllerContext) (bool, error) {
	saName := bootstrappolicy.InfraClusterQuotaReconciliationControllerServiceAccountName
	resourceQuotaRegistry := quota.NewAllResourceQuotaRegistry(
		ctx.ExternalKubeInformers,
		ctx.ImageInformers.Image().InternalVersion().ImageStreams(),
		ctx.ClientBuilder.DeprecatedOpenshiftClientOrDie(saName),
		ctx.ClientBuilder.ClientOrDie(saName),
	)
	groupKindsToReplenish := quota.AllEvaluatedGroupKinds

	clusterQuotaMappingController := clusterquotamapping.NewClusterQuotaMappingController(
		ctx.ExternalKubeInformers.Core().V1().Namespaces(),
		ctx.QuotaInformers.Quota().InternalVersion().ClusterResourceQuotas())
	options := clusterquotareconciliation.ClusterQuotaReconcilationControllerOptions{
		ClusterQuotaInformer: ctx.QuotaInformers.Quota().InternalVersion().ClusterResourceQuotas(),
		ClusterQuotaMapper:   clusterQuotaMappingController.GetClusterQuotaMapper(),
		ClusterQuotaClient:   ctx.ClientBuilder.DeprecatedOpenshiftClientOrDie(saName),

		Registry:     resourceQuotaRegistry,
		ResyncPeriod: c.DefaultResyncPeriod,
		ControllerFactory: quotacontroller.NewAllResourceReplenishmentControllerFactory(
			ctx.ExternalKubeInformers,
			ctx.ImageInformers.Image().InternalVersion().ImageStreams(),
			ctx.ClientBuilder.DeprecatedOpenshiftClientOrDie(saName),
		),
		ReplenishmentResyncPeriod: controller.StaticResyncPeriodFunc(c.DefaultReplenishmentSyncPeriod),
		GroupKindsToReplenish:     groupKindsToReplenish,
	}
	clusterQuotaReconciliationController := clusterquotareconciliation.NewClusterQuotaReconcilationController(options)
	clusterQuotaMappingController.GetClusterQuotaMapper().AddListener(clusterQuotaReconciliationController)

	go clusterQuotaMappingController.Run(5, ctx.Stop)
	go clusterQuotaReconciliationController.Run(5, ctx.Stop)

	return true, nil
}

func calculateResyncPeriod(period time.Duration) func() time.Duration {
	return func() time.Duration {
		factor := rand.Float64() + 1
		return time.Duration(float64(period.Nanoseconds()) * factor)
	}
}