@@ -22,93 +22,97 @@ import (
2222
2323 "github.com/kubernetes-sigs/controller-runtime/pkg/client"
2424 "github.com/kubernetes-sigs/controller-runtime/pkg/client/apiutil"
25+ "github.com/kubernetes-sigs/controller-runtime/pkg/client/config"
2526 "github.com/kubernetes-sigs/controller-runtime/pkg/controller"
2627 "github.com/kubernetes-sigs/controller-runtime/pkg/handler"
28+ internalcontroller "github.com/kubernetes-sigs/controller-runtime/pkg/internal/controller"
2729 "github.com/kubernetes-sigs/controller-runtime/pkg/manager"
2830 "github.com/kubernetes-sigs/controller-runtime/pkg/reconcile"
2931 "github.com/kubernetes-sigs/controller-runtime/pkg/runtime/signals"
3032 "github.com/kubernetes-sigs/controller-runtime/pkg/source"
3133 "k8s.io/apimachinery/pkg/runtime"
32- "k8s.io/apimachinery/pkg/runtime/schema"
33- "k8s.io/client-go/rest"
3434)
3535
3636// Operator is a very simple Controller that embeds a Manager.
3737type Operator struct {
3838 mrg manager.Manager
3939 stopFn func () <- chan struct {}
40-
41- // Allow deps to be mocked out for testing
42- newController func (name string , mrg manager.Manager , options controller.Options ) (controller.Controller , error )
43- getGvk func (obj runtime.Object , scheme * runtime.Scheme ) (schema.GroupVersionKind , error )
40+ ctrl * internalcontroller.Controller
4441}
4542
46- // New returns a new Operator
47- func New (config * rest.Config ) (* Operator , error ) {
48- mrg , err := manager .New (config , manager.Options {})
49- if err != nil {
50- return nil , err
51- }
43+ var noop = reconcile .Func (func (reconcile.Request ) (reconcile.Result , error ) {
44+ return reconcile.Result {}, nil
45+ })
5246
53- o := & Operator {
54- mrg : mrg ,
55- stopFn : signals .SetupSignalHandler ,
56- newController : controller .New ,
57- getGvk : apiutil .GVKForObject ,
58- }
59- return o , nil
60- }
47+ var getConfig = config .GetConfig
48+ var newController = controller .New
49+ var newManager = manager .New
50+ var getGvk = apiutil .GVKForObject
6151
62- // HandleType configures the Operator for a Kubernetes Resource type.
52+ // New returns a new Operator for a Kubernetes Resource type.
6353//
6454// * Watch for changes (e.g. create,update,delete operations) to objects of the Resource type
6555//
6656// * Watch for changes to objects created or managed by the Resource type.
6757//
6858// * Reconcile the object that was changed or that owns the changed objects.
6959//
70- // impl: the Reconcile implementation. reconcile.Reconcile is a function that may be called at anytime with the
71- // name / Namespace of an object. When called, it will ensure that the state of the system matches what is
72- // specified in the object at the time reconcile is called.
73- //
7460// reconcileObject: the type of the Kubernetes object that will be Watched and Reconciled - e.g. &v1.ReplicaSet{}
7561//
7662// ownedTypes: list of types of objects that may be created or managed by the reconcileObject. These
7763// objects must have the OwnersReference set to the owning object in the ObjectMeta - e.g. &v1.Pod{}
78- func (o * Operator ) HandleType (impl reconcile.Reconcile ,
79- reconcileObject runtime.Object , ownedTypes ... runtime.Object ) error {
64+ func New (reconcileObject runtime.Object , ownedTypes ... runtime.Object ) (* Operator , error ) {
65+ c , err := getConfig ()
66+ if err != nil {
67+ return nil , err
68+ }
69+ mrg , err := newManager (c , manager.Options {})
70+ if err != nil {
71+ return nil , err
72+ }
8073
81- gvk , err := o .getGvk (reconcileObject , o .mrg .GetScheme ())
74+ o := & Operator {
75+ mrg : mrg ,
76+ stopFn : signals .SetupSignalHandler ,
77+ }
78+
79+ gvk , err := getGvk (reconcileObject , o .mrg .GetScheme ())
8280 if err != nil {
83- return err
81+ return nil , err
8482 }
8583
8684 // Create the controller
8785 name := fmt .Sprintf ("%s-operator" , strings .ToLower (gvk .Kind ))
88- c , err := o . newController (name , o . mrg , controller.Options {Reconcile : impl })
86+ ctrl , err := newController (name , mrg , controller.Options {Reconcile : noop })
8987 if err != nil {
90- return err
88+ return nil , err
9189 }
90+ o .ctrl = ctrl .(* internalcontroller.Controller )
9291
9392 // Reconcile type
94- err = c .Watch (& source.Kind {Type : reconcileObject }, & handler.Enqueue {})
93+ err = o . ctrl .Watch (& source.Kind {Type : reconcileObject }, & handler.Enqueue {})
9594 if err != nil {
96- return err
95+ return nil , err
9796 }
9897
9998 // Watch the managed types
10099 for _ , t := range ownedTypes {
101- err = c .Watch (& source.Kind {Type : t }, & handler.EnqueueOwner {OwnerType : reconcileObject , IsController : true })
100+ err = o . ctrl .Watch (& source.Kind {Type : t }, & handler.EnqueueOwner {OwnerType : reconcileObject , IsController : true })
102101 if err != nil {
103- return err
102+ return nil , err
104103 }
105104 }
106105
107- return err
106+ return o , nil
108107}
109108
110109// Start starts the Operator and blocks until the program is shutdown.
111- func (o * Operator ) Start () error {
110+ //
111+ // call: the Reconcile implementation. reconcile.Reconcile is a function that may be called at anytime with the
112+ // name / Namespace of an object. When called, it will ensure that the state of the system matches what is
113+ // specified in the object at the time reconcile is called.
114+ func (o * Operator ) Start (call reconcile.Reconcile ) error {
115+ o .ctrl .Do = call
112116 return o .mrg .Start (o .stopFn ())
113117}
114118
0 commit comments