/
infraprovider_controller.go
98 lines (82 loc) · 2.53 KB
/
infraprovider_controller.go
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
94
95
96
97
98
// Copyright (c) 2019-2021 VMware, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package infraprovider
import (
goctx "context"
"reflect"
"github.com/go-logr/logr"
corev1 "k8s.io/api/core/v1"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/event"
"sigs.k8s.io/controller-runtime/pkg/manager"
"sigs.k8s.io/controller-runtime/pkg/predicate"
"github.com/vmware-tanzu/vm-operator/pkg/context"
"github.com/vmware-tanzu/vm-operator/pkg/lib"
)
type infraProvider interface {
ComputeCPUMinFrequency(ctx goctx.Context) error
}
// AddToManager adds this package's controller to the provided manager.
func AddToManager(ctx *context.ControllerManagerContext, mgr manager.Manager) error {
var (
controlledType = &corev1.Node{}
controlledTypeName = reflect.TypeOf(controlledType).Elem().Name()
)
var provider infraProvider
if lib.IsVMServiceV1Alpha2FSSEnabled() {
provider = ctx.VMProviderA2
} else {
provider = ctx.VMProvider
}
r := NewReconciler(
mgr.GetClient(),
ctrl.Log.WithName("controllers").WithName(controlledTypeName),
provider,
)
return ctrl.NewControllerManagedBy(mgr).
For(controlledType).
WithEventFilter(
// Queue a reconcile request when a new node is added or removed so we can calculate the minimum CPU frequency.
// If a new node is added to the vSphere cluster, we rely on the next sync.
predicate.Funcs{
CreateFunc: func(e event.CreateEvent) bool {
return true
},
DeleteFunc: func(e event.DeleteEvent) bool {
return true
},
UpdateFunc: func(e event.UpdateEvent) bool {
return false
},
GenericFunc: func(e event.GenericEvent) bool {
return false
},
},
).Complete(r)
}
func NewReconciler(
client client.Client,
logger logr.Logger,
provider infraProvider) *Reconciler {
return &Reconciler{
Client: client,
Logger: logger,
provider: provider,
}
}
type Reconciler struct {
client.Client
Logger logr.Logger
provider infraProvider
}
// +kubebuilder:rbac:groups="",resources=nodes,verbs=get;list;watch
func (r *Reconciler) Reconcile(ctx goctx.Context, req ctrl.Request) (ctrl.Result, error) {
r.Logger.Info("Received reconcile request", "namespace", req.Namespace, "name", req.Name)
// Update the minimum CPU frequency. This frequency is used to populate the resource allocation
// fields in the ConfigSpec for cloning the VM.
if err := r.provider.ComputeCPUMinFrequency(ctx); err != nil {
return ctrl.Result{}, err
}
return ctrl.Result{}, nil
}