From e230cb45238d5c0bb864d342336979c24e1745ef Mon Sep 17 00:00:00 2001 From: Vince Prignano Date: Wed, 22 Jul 2020 18:25:32 -0700 Subject: [PATCH] =?UTF-8?q?=E2=9A=A0=20Add=20a=20context=20to=20Reconciler?= =?UTF-8?q?=20interface?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Vince Prignano --- example_test.go | 6 +++--- examples/builtins/controller.go | 8 +++----- examples/builtins/main.go | 11 ++++++----- examples/crd/main.go | 7 +++---- pkg/builder/controller.go | 12 ++++++------ pkg/builder/controller_test.go | 8 +++++--- pkg/builder/example_test.go | 9 ++++----- pkg/controller/controller.go | 9 +++++++-- pkg/controller/controller_integration_test.go | 2 +- pkg/controller/controller_test.go | 5 +++-- pkg/controller/example_test.go | 9 +++++---- pkg/internal/controller/controller.go | 17 ++++++++++++----- pkg/internal/controller/controller_test.go | 8 ++++---- .../recorder/recorder_integration_test.go | 2 +- pkg/manager/manager.go | 1 - pkg/manager/manager_test.go | 2 +- pkg/reconcile/example_test.go | 5 +++-- pkg/reconcile/reconcile.go | 7 ++++--- pkg/reconcile/reconcile_test.go | 9 +++++---- 19 files changed, 76 insertions(+), 61 deletions(-) diff --git a/example_test.go b/example_test.go index 8a6f37eabc..0117ba02c0 100644 --- a/example_test.go +++ b/example_test.go @@ -116,17 +116,17 @@ type ReplicaSetReconciler struct { // * Read the ReplicaSet // * Read the Pods // * Set a Label on the ReplicaSet with the Pod count -func (a *ReplicaSetReconciler) Reconcile(req controllers.Request) (controllers.Result, error) { +func (a *ReplicaSetReconciler) Reconcile(ctx context.Context, req controllers.Request) (controllers.Result, error) { // Read the ReplicaSet rs := &appsv1.ReplicaSet{} - err := a.Get(context.TODO(), req.NamespacedName, rs) + err := a.Get(ctx, req.NamespacedName, rs) if err != nil { return controllers.Result{}, err } // List the Pods matching the PodTemplate Labels pods := &corev1.PodList{} - err = a.List(context.TODO(), pods, client.InNamespace(req.Namespace), client.MatchingLabels(rs.Spec.Template.Labels)) + err = a.List(ctx, pods, client.InNamespace(req.Namespace), client.MatchingLabels(rs.Spec.Template.Labels)) if err != nil { return controllers.Result{}, err } diff --git a/examples/builtins/controller.go b/examples/builtins/controller.go index 8140f7df4a..8349bcd5aa 100644 --- a/examples/builtins/controller.go +++ b/examples/builtins/controller.go @@ -20,11 +20,10 @@ import ( "context" "fmt" - "github.com/go-logr/logr" - appsv1 "k8s.io/api/apps/v1" "k8s.io/apimachinery/pkg/api/errors" "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/log" "sigs.k8s.io/controller-runtime/pkg/reconcile" ) @@ -32,15 +31,14 @@ import ( type reconcileReplicaSet struct { // client can be used to retrieve objects from the APIServer. client client.Client - log logr.Logger } // Implement reconcile.Reconciler so the controller can reconcile objects var _ reconcile.Reconciler = &reconcileReplicaSet{} -func (r *reconcileReplicaSet) Reconcile(request reconcile.Request) (reconcile.Result, error) { +func (r *reconcileReplicaSet) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error) { // set up a convenient log object so we don't have to type request over and over again - log := r.log.WithValues("request", request) + log := log.FromContext(ctx) // Fetch the ReplicaSet from the cache rs := &appsv1.ReplicaSet{} diff --git a/examples/builtins/main.go b/examples/builtins/main.go index 0456d31cf7..ff1f0dfa3b 100644 --- a/examples/builtins/main.go +++ b/examples/builtins/main.go @@ -25,7 +25,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client/config" "sigs.k8s.io/controller-runtime/pkg/controller" "sigs.k8s.io/controller-runtime/pkg/handler" - logf "sigs.k8s.io/controller-runtime/pkg/log" + "sigs.k8s.io/controller-runtime/pkg/log" "sigs.k8s.io/controller-runtime/pkg/log/zap" "sigs.k8s.io/controller-runtime/pkg/manager" "sigs.k8s.io/controller-runtime/pkg/manager/signals" @@ -33,11 +33,12 @@ import ( "sigs.k8s.io/controller-runtime/pkg/webhook" ) -var log = logf.Log.WithName("example-controller") +func init() { + log.SetLogger(zap.New()) +} func main() { - logf.SetLogger(zap.New()) - entryLog := log.WithName("entrypoint") + entryLog := log.Log.WithName("entrypoint") // Setup a Manager entryLog.Info("setting up manager") @@ -50,7 +51,7 @@ func main() { // Setup a new controller to reconcile ReplicaSets entryLog.Info("Setting up controller") c, err := controller.New("foo-controller", mgr, controller.Options{ - Reconciler: &reconcileReplicaSet{client: mgr.GetClient(), log: log.WithName("reconciler")}, + Reconciler: &reconcileReplicaSet{client: mgr.GetClient()}, }) if err != nil { entryLog.Error(err, "unable to set up individual controller") diff --git a/examples/crd/main.go b/examples/crd/main.go index 9ed77b7366..1f6cd5fac2 100644 --- a/examples/crd/main.go +++ b/examples/crd/main.go @@ -29,12 +29,12 @@ import ( ctrl "sigs.k8s.io/controller-runtime" api "sigs.k8s.io/controller-runtime/examples/crd/pkg" "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/log" "sigs.k8s.io/controller-runtime/pkg/log/zap" ) var ( setupLog = ctrl.Log.WithName("setup") - recLog = ctrl.Log.WithName("reconciler") ) type reconciler struct { @@ -42,10 +42,9 @@ type reconciler struct { scheme *runtime.Scheme } -func (r *reconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) { - log := recLog.WithValues("chaospod", req.NamespacedName) +func (r *reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { + log := log.FromContext(ctx).WithValues("chaospod", req.NamespacedName) log.V(1).Info("reconciling chaos pod") - ctx := context.Background() var chaospod api.ChaosPod if err := r.Get(ctx, req.NamespacedName, &chaospod); err != nil { diff --git a/pkg/builder/controller.go b/pkg/builder/controller.go index 178b687f2e..5c72236367 100644 --- a/pkg/builder/controller.go +++ b/pkg/builder/controller.go @@ -130,6 +130,12 @@ func (blder *Builder) WithOptions(options controller.Options) *Builder { return blder } +// WithLogger overrides the controller options's logger used. +func (blder *Builder) WithLogger(log logr.Logger) *Builder { + blder.log = log + return blder +} + // Named sets the name of the controller to the given name. The name shows up // in metrics, among other things, and thus should be a prometheus compatible name // (underscores and alphanumeric characters only). @@ -140,12 +146,6 @@ func (blder *Builder) Named(name string) *Builder { return blder } -// WithLogger overrides the controller options's logger used. -func (blder *Builder) WithLogger(log logr.Logger) *Builder { - blder.log = log - return blder -} - // Complete builds the Application ControllerManagedBy. func (blder *Builder) Complete(r reconcile.Reconciler) error { _, err := blder.Build(r) diff --git a/pkg/builder/controller_test.go b/pkg/builder/controller_test.go index b51dd2272e..2b764b16dc 100644 --- a/pkg/builder/controller_test.go +++ b/pkg/builder/controller_test.go @@ -44,7 +44,7 @@ import ( type typedNoop struct{} -func (typedNoop) Reconcile(reconcile.Request) (reconcile.Result, error) { +func (typedNoop) Reconcile(context.Context, reconcile.Request) (reconcile.Result, error) { return reconcile.Result{}, nil } @@ -60,7 +60,9 @@ var _ = Describe("application", func() { close(stop) }) - noop := reconcile.Func(func(req reconcile.Request) (reconcile.Result, error) { return reconcile.Result{}, nil }) + noop := reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) { + return reconcile.Result{}, nil + }) Describe("New", func() { It("should return success if given valid objects", func() { @@ -302,7 +304,7 @@ func doReconcileTest(nameSuffix string, stop chan struct{}, blder *Builder, mgr By("Creating the application") ch := make(chan reconcile.Request) - fn := reconcile.Func(func(req reconcile.Request) (reconcile.Result, error) { + fn := reconcile.Func(func(_ context.Context, req reconcile.Request) (reconcile.Result, error) { defer GinkgoRecover() if !strings.HasSuffix(req.Name, nameSuffix) { // From different test, ignore this request. Etcd is shared across tests. diff --git a/pkg/builder/example_test.go b/pkg/builder/example_test.go index 128f729d75..8dd7249516 100644 --- a/pkg/builder/example_test.go +++ b/pkg/builder/example_test.go @@ -79,25 +79,24 @@ type ReplicaSetReconciler struct { // * Read the ReplicaSet // * Read the Pods // * Set a Label on the ReplicaSet with the Pod count -func (a *ReplicaSetReconciler) Reconcile(req reconcile.Request) (reconcile.Result, error) { +func (a *ReplicaSetReconciler) Reconcile(ctx context.Context, req reconcile.Request) (reconcile.Result, error) { // Read the ReplicaSet rs := &appsv1.ReplicaSet{} - err := a.Get(context.TODO(), req.NamespacedName, rs) + err := a.Get(ctx, req.NamespacedName, rs) if err != nil { return reconcile.Result{}, err } // List the Pods matching the PodTemplate Labels pods := &corev1.PodList{} - err = a.List(context.TODO(), pods, client.InNamespace(req.Namespace), - client.MatchingLabels(rs.Spec.Template.Labels)) + err = a.List(ctx, pods, client.InNamespace(req.Namespace), client.MatchingLabels(rs.Spec.Template.Labels)) if err != nil { return reconcile.Result{}, err } // Update the ReplicaSet rs.Labels["pod-count"] = fmt.Sprintf("%v", len(pods.Items)) - err = a.Update(context.TODO(), rs) + err = a.Update(ctx, rs) if err != nil { return reconcile.Result{}, err } diff --git a/pkg/controller/controller.go b/pkg/controller/controller.go index b7b0f55124..4af40366f8 100644 --- a/pkg/controller/controller.go +++ b/pkg/controller/controller.go @@ -43,7 +43,8 @@ type Options struct { // The overall is a token bucket and the per-item is exponential. RateLimiter ratelimiter.RateLimiter - // Log is the logger used for this controller. + // Log is the logger used for this controller and passed to each reconciliation + // request via the context field. Log logr.Logger } @@ -91,6 +92,10 @@ func NewUnmanaged(name string, mgr manager.Manager, options Options) (Controller return nil, fmt.Errorf("must specify Name for Controller") } + if options.Log == nil { + options.Log = mgr.GetLogger() + } + if options.MaxConcurrentReconciles <= 0 { options.MaxConcurrentReconciles = 1 } @@ -117,6 +122,6 @@ func NewUnmanaged(name string, mgr manager.Manager, options Options) (Controller MaxConcurrentReconciles: options.MaxConcurrentReconciles, SetFields: mgr.SetFields, Name: name, - Log: options.Log.WithName("controller").WithValues("controller", name), + Log: options.Log.WithName("controller").WithName(name), }, nil } diff --git a/pkg/controller/controller_integration_test.go b/pkg/controller/controller_integration_test.go index 2ce40f401e..91600cb617 100644 --- a/pkg/controller/controller_integration_test.go +++ b/pkg/controller/controller_integration_test.go @@ -62,7 +62,7 @@ var _ = Describe("controller", func() { By("Creating the Controller") instance, err := controller.New("foo-controller", cm, controller.Options{ Reconciler: reconcile.Func( - func(request reconcile.Request) (reconcile.Result, error) { + func(_ context.Context, request reconcile.Request) (reconcile.Result, error) { reconciled <- request return reconcile.Result{}, nil }), diff --git a/pkg/controller/controller_test.go b/pkg/controller/controller_test.go index ff580fbfc3..677186a88d 100644 --- a/pkg/controller/controller_test.go +++ b/pkg/controller/controller_test.go @@ -17,6 +17,7 @@ limitations under the License. package controller_test import ( + "context" "fmt" rt "runtime" @@ -33,7 +34,7 @@ import ( var _ = Describe("controller.Controller", func() { var stop chan struct{} - rec := reconcile.Func(func(reconcile.Request) (reconcile.Result, error) { + rec := reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) { return reconcile.Result{}, nil }) BeforeEach(func() { @@ -123,7 +124,7 @@ var _ inject.Client = &failRec{} type failRec struct{} -func (*failRec) Reconcile(reconcile.Request) (reconcile.Result, error) { +func (*failRec) Reconcile(context.Context, reconcile.Request) (reconcile.Result, error) { return reconcile.Result{}, nil } diff --git a/pkg/controller/example_test.go b/pkg/controller/example_test.go index 19b87e81fe..4603e56940 100644 --- a/pkg/controller/example_test.go +++ b/pkg/controller/example_test.go @@ -17,6 +17,7 @@ limitations under the License. package controller_test import ( + "context" "os" corev1 "k8s.io/api/core/v1" @@ -41,7 +42,7 @@ var ( // manager.Manager will be used to Start the Controller, and will provide it a shared Cache and Client. func ExampleNew() { _, err := controller.New("pod-controller", mgr, controller.Options{ - Reconciler: reconcile.Func(func(o reconcile.Request) (reconcile.Result, error) { + Reconciler: reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) { // Your business logic to implement the API by creating, updating, deleting objects goes here. return reconcile.Result{}, nil }), @@ -59,7 +60,7 @@ func ExampleController() { // Create a new Controller that will call the provided Reconciler function in response // to events. c, err := controller.New("pod-controller", mgr, controller.Options{ - Reconciler: reconcile.Func(func(o reconcile.Request) (reconcile.Result, error) { + Reconciler: reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) { // Your business logic to implement the API by creating, updating, deleting objects goes here. return reconcile.Result{}, nil }), @@ -90,7 +91,7 @@ func ExampleController_unstructured() { // Create a new Controller that will call the provided Reconciler function in response // to events. c, err := controller.New("pod-controller", mgr, controller.Options{ - Reconciler: reconcile.Func(func(o reconcile.Request) (reconcile.Result, error) { + Reconciler: reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) { // Your business logic to implement the API by creating, updating, deleting objects goes here. return reconcile.Result{}, nil }), @@ -129,7 +130,7 @@ func ExampleNewUnmanaged() { // Configure creates a new controller but does not add it to the supplied // manager. c, err := controller.NewUnmanaged("pod-controller", mgr, controller.Options{ - Reconciler: reconcile.Func(func(_ reconcile.Request) (reconcile.Result, error) { + Reconciler: reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) { return reconcile.Result{}, nil }), }) diff --git a/pkg/internal/controller/controller.go b/pkg/internal/controller/controller.go index bb782d2fad..39b9aa30de 100644 --- a/pkg/internal/controller/controller.go +++ b/pkg/internal/controller/controller.go @@ -17,6 +17,7 @@ limitations under the License. package controller import ( + "context" "fmt" "sync" "time" @@ -27,6 +28,7 @@ import ( "k8s.io/client-go/util/workqueue" "sigs.k8s.io/controller-runtime/pkg/handler" ctrlmetrics "sigs.k8s.io/controller-runtime/pkg/internal/controller/metrics" + logf "sigs.k8s.io/controller-runtime/pkg/log" "sigs.k8s.io/controller-runtime/pkg/predicate" "sigs.k8s.io/controller-runtime/pkg/reconcile" "sigs.k8s.io/controller-runtime/pkg/runtime/inject" @@ -86,8 +88,10 @@ type watchDescription struct { } // Reconcile implements reconcile.Reconciler -func (c *Controller) Reconcile(r reconcile.Request) (reconcile.Result, error) { - return c.Do.Reconcile(r) +func (c *Controller) Reconcile(ctx context.Context, req reconcile.Request) (reconcile.Result, error) { + log := c.Log.WithValues("name", req.Name, "namespace", req.Namespace) + ctx = logf.IntoContext(ctx, log) + return c.Do.Reconcile(ctx, req) } // Watch implements controller.Controller @@ -229,12 +233,15 @@ func (c *Controller) reconcileHandler(obj interface{}) bool { } log := c.Log.WithValues("name", req.Name, "namespace", req.Namespace) + ctx := logf.IntoContext(context.Background(), log) // RunInformersAndControllers the syncHandler, passing it the namespace/Name string of the // resource to be synced. - if result, err := c.Do.Reconcile(req); err != nil { + if result, err := c.Do.Reconcile(ctx, req); err != nil { c.Queue.AddRateLimited(req) - log.Error(err, "Reconciler error") + if log.V(3).Enabled() { + log.Error(err, "Reconciler error") + } ctrlmetrics.ReconcileErrors.WithLabelValues(c.Name).Inc() ctrlmetrics.ReconcileTotal.WithLabelValues(c.Name, "error").Inc() return false @@ -258,7 +265,7 @@ func (c *Controller) reconcileHandler(obj interface{}) bool { c.Queue.Forget(obj) // TODO(directxman12): What does 1 mean? Do we want level constants? Do we want levels at all? - log.V(1).Info("Successfully Reconciled") + log.V(5).Info("Successfully Reconciled") ctrlmetrics.ReconcileTotal.WithLabelValues(c.Name, "success").Inc() // Return true, don't take a break diff --git a/pkg/internal/controller/controller_test.go b/pkg/internal/controller/controller_test.go index b57c542770..e4e0228976 100644 --- a/pkg/internal/controller/controller_test.go +++ b/pkg/internal/controller/controller_test.go @@ -78,10 +78,10 @@ var _ = Describe("controller", func() { Describe("Reconciler", func() { It("should call the Reconciler function", func() { - ctrl.Do = reconcile.Func(func(reconcile.Request) (reconcile.Result, error) { + ctrl.Do = reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) { return reconcile.Result{Requeue: true}, nil }) - result, err := ctrl.Reconcile( + result, err := ctrl.Reconcile(context.Background(), reconcile.Request{NamespacedName: types.NamespacedName{Namespace: "foo", Name: "bar"}}) Expect(err).NotTo(HaveOccurred()) Expect(result).To(Equal(reconcile.Result{Requeue: true})) @@ -304,7 +304,7 @@ var _ = Describe("controller", func() { }) It("should continue to process additional queue items after the first", func(done Done) { - ctrl.Do = reconcile.Func(func(reconcile.Request) (reconcile.Result, error) { + ctrl.Do = reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) { defer GinkgoRecover() Fail("Reconciler should not have been called") return reconcile.Result{}, nil @@ -766,7 +766,7 @@ func (f *fakeReconciler) AddResult(res reconcile.Result, err error) { f.results <- fakeReconcileResultPair{Result: res, Err: err} } -func (f *fakeReconciler) Reconcile(r reconcile.Request) (reconcile.Result, error) { +func (f *fakeReconciler) Reconcile(_ context.Context, r reconcile.Request) (reconcile.Result, error) { res := <-f.results if f.Requests != nil { f.Requests <- r diff --git a/pkg/internal/recorder/recorder_integration_test.go b/pkg/internal/recorder/recorder_integration_test.go index 94b05b9856..34606be438 100644 --- a/pkg/internal/recorder/recorder_integration_test.go +++ b/pkg/internal/recorder/recorder_integration_test.go @@ -58,7 +58,7 @@ var _ = Describe("recorder", func() { recorder := cm.GetEventRecorderFor("test-recorder") instance, err := controller.New("foo-controller", cm, controller.Options{ Reconciler: reconcile.Func( - func(request reconcile.Request) (reconcile.Result, error) { + func(ctx context.Context, request reconcile.Request) (reconcile.Result, error) { dp, err := clientset.AppsV1().Deployments(request.Namespace).Get(ctx, request.Name, metav1.GetOptions{}) Expect(err).NotTo(HaveOccurred()) recorder.Event(dp, corev1.EventTypeNormal, "test-reason", "test-msg") diff --git a/pkg/manager/manager.go b/pkg/manager/manager.go index a97d507ff5..c9483a4e8f 100644 --- a/pkg/manager/manager.go +++ b/pkg/manager/manager.go @@ -23,7 +23,6 @@ import ( "time" "github.com/go-logr/logr" - "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/runtime" "k8s.io/client-go/kubernetes/scheme" diff --git a/pkg/manager/manager_test.go b/pkg/manager/manager_test.go index a54e9f6d77..2326bd06a5 100644 --- a/pkg/manager/manager_test.go +++ b/pkg/manager/manager_test.go @@ -1275,7 +1275,7 @@ var _ inject.Client = &failRec{} type failRec struct{} -func (*failRec) Reconcile(reconcile.Request) (reconcile.Result, error) { +func (*failRec) Reconcile(context.Context, reconcile.Request) (reconcile.Result, error) { return reconcile.Result{}, nil } diff --git a/pkg/reconcile/example_test.go b/pkg/reconcile/example_test.go index 1e3893c022..1d380112c9 100644 --- a/pkg/reconcile/example_test.go +++ b/pkg/reconcile/example_test.go @@ -17,6 +17,7 @@ limitations under the License. package reconcile_test import ( + "context" "fmt" "time" @@ -27,13 +28,13 @@ import ( // This example implements a simple no-op reconcile function that prints the object to be Reconciled. func ExampleFunc() { - r := reconcile.Func(func(o reconcile.Request) (reconcile.Result, error) { + r := reconcile.Func(func(_ context.Context, o reconcile.Request) (reconcile.Result, error) { // Create your business logic to create, update, delete objects here. fmt.Printf("Name: %s, Namespace: %s", o.Name, o.Namespace) return reconcile.Result{}, nil }) - res, err := r.Reconcile(reconcile.Request{NamespacedName: types.NamespacedName{Namespace: "default", Name: "test"}}) + res, err := r.Reconcile(context.Background(), reconcile.Request{NamespacedName: types.NamespacedName{Namespace: "default", Name: "test"}}) if err != nil || res.Requeue || res.RequeueAfter != time.Duration(0) { fmt.Printf("got requeue request: %v, %v\n", err, res) } diff --git a/pkg/reconcile/reconcile.go b/pkg/reconcile/reconcile.go index c6f7f64a65..b2159c531f 100644 --- a/pkg/reconcile/reconcile.go +++ b/pkg/reconcile/reconcile.go @@ -17,6 +17,7 @@ limitations under the License. package reconcile import ( + "context" "time" "k8s.io/apimachinery/pkg/types" @@ -89,13 +90,13 @@ type Reconciler interface { // Reconciler performs a full reconciliation for the object referred to by the Request. // The Controller will requeue the Request to be processed again if an error is non-nil or // Result.Requeue is true, otherwise upon completion it will remove the work from the queue. - Reconcile(Request) (Result, error) + Reconcile(context.Context, Request) (Result, error) } // Func is a function that implements the reconcile interface. -type Func func(Request) (Result, error) +type Func func(context.Context, Request) (Result, error) var _ Reconciler = Func(nil) // Reconcile implements Reconciler. -func (r Func) Reconcile(o Request) (Result, error) { return r(o) } +func (r Func) Reconcile(ctx context.Context, o Request) (Result, error) { return r(ctx, o) } diff --git a/pkg/reconcile/reconcile_test.go b/pkg/reconcile/reconcile_test.go index 88b4af7475..26924c8fa9 100644 --- a/pkg/reconcile/reconcile_test.go +++ b/pkg/reconcile/reconcile_test.go @@ -17,6 +17,7 @@ limitations under the License. package reconcile_test import ( + "context" "fmt" "time" @@ -57,13 +58,13 @@ var _ = Describe("reconcile", func() { Requeue: true, } - instance := reconcile.Func(func(r reconcile.Request) (reconcile.Result, error) { + instance := reconcile.Func(func(_ context.Context, r reconcile.Request) (reconcile.Result, error) { defer GinkgoRecover() Expect(r).To(Equal(request)) return result, nil }) - actualResult, actualErr := instance.Reconcile(request) + actualResult, actualErr := instance.Reconcile(context.Background(), request) Expect(actualResult).To(Equal(result)) Expect(actualErr).NotTo(HaveOccurred()) }) @@ -77,13 +78,13 @@ var _ = Describe("reconcile", func() { } err := fmt.Errorf("hello world") - instance := reconcile.Func(func(r reconcile.Request) (reconcile.Result, error) { + instance := reconcile.Func(func(_ context.Context, r reconcile.Request) (reconcile.Result, error) { defer GinkgoRecover() Expect(r).To(Equal(request)) return result, err }) - actualResult, actualErr := instance.Reconcile(request) + actualResult, actualErr := instance.Reconcile(context.Background(), request) Expect(actualResult).To(Equal(result)) Expect(actualErr).To(Equal(err)) })