From 0af7ed4d93039078cccaa3289081bb9ae789b123 Mon Sep 17 00:00:00 2001 From: knative-automation Date: Sun, 22 Aug 2021 23:25:35 -0700 Subject: [PATCH] upgrade to latest dependencies (#514) bumping knative.dev/pkg 7b5ecbc...3bed4dc: > 3bed4dc Make the configmap update logging Debugf (# 2226) > 44fffc8 This implements the EventExpansion needed to emit K8s events. (# 2224) > 6ef763d Remove long deprecated NewImplWithStats (# 2223) > 9c7fd8e Introduce `NewContext`, deprecate `NewImplFull`. (# 2222) > 766b8f7 Have the addressable resolver take a tracker. (# 2220) > 9b9bc2a Run codegen (# 2221) > 52d2a0d Deprecate ReadOnlyFinalizer interface over OnDeletionInterface (# 2212) > 44fc074 Update community files (# 2219) > bda81c0 upgrade to latest dependencies (# 2218) Signed-off-by: Knative Automation --- go.mod | 2 +- go.sum | 5 +- .../caching/v1alpha1/image/controller.go | 4 +- .../caching/v1alpha1/image/reconciler.go | 5 +- .../injection/kube/client/client_expansion.go | 68 +++++++++++++++---- .../generators/reconciler_controller.go | 8 +-- .../generators/reconciler_reconciler.go | 5 +- .../generators/reconciler_reconciler_stub.go | 15 ---- vendor/knative.dev/pkg/configmap/store.go | 3 +- .../knative.dev/pkg/controller/controller.go | 47 +++++++++++-- vendor/knative.dev/pkg/injection/README.md | 12 +++- vendor/modules.txt | 2 +- 12 files changed, 125 insertions(+), 51 deletions(-) diff --git a/go.mod b/go.mod index 836c5b35..336ac060 100644 --- a/go.mod +++ b/go.mod @@ -19,5 +19,5 @@ require ( k8s.io/code-generator v0.20.7 k8s.io/kube-openapi v0.0.0-20201113171705-d219536bb9fd knative.dev/hack v0.0.0-20210806075220-815cd312d65c - knative.dev/pkg v0.0.0-20210818135208-7b5ecbc0e477 + knative.dev/pkg v0.0.0-20210822203034-3bed4dcf179c ) diff --git a/go.sum b/go.sum index 27c4b53b..4ba4a528 100644 --- a/go.sum +++ b/go.sum @@ -1060,11 +1060,10 @@ k8s.io/kube-openapi v0.0.0-20201113171705-d219536bb9fd h1:sOHNzJIkytDF6qadMNKhhD k8s.io/kube-openapi v0.0.0-20201113171705-d219536bb9fd/go.mod h1:WOJ3KddDSol4tAGcJo0Tvi+dK12EcqSLqcWsryKMpfM= k8s.io/utils v0.0.0-20201110183641-67b214c5f920 h1:CbnUZsM497iRC5QMVkHwyl8s2tB3g7yaSHkYPkpgelw= k8s.io/utils v0.0.0-20201110183641-67b214c5f920/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= -knative.dev/hack v0.0.0-20210622141627-e28525d8d260/go.mod h1:PHt8x8yX5Z9pPquBEfIj0X66f8iWkWfR0S/sarACJrI= knative.dev/hack v0.0.0-20210806075220-815cd312d65c h1:nOXoDWAAItwr4o0dp3nHr6skgpVD4IvME/UX84YNl5k= knative.dev/hack v0.0.0-20210806075220-815cd312d65c/go.mod h1:PHt8x8yX5Z9pPquBEfIj0X66f8iWkWfR0S/sarACJrI= -knative.dev/pkg v0.0.0-20210818135208-7b5ecbc0e477 h1:oHKwxMz8dV5pKXTAUOMbmZA0kgLkXKR11ISysegU/L8= -knative.dev/pkg v0.0.0-20210818135208-7b5ecbc0e477/go.mod h1:RPk5txNA3apR9X40D4MpUOP9/VqOG8CrtABWfOwGVS4= +knative.dev/pkg v0.0.0-20210822203034-3bed4dcf179c h1:NkyMXoVVe1J9eqBoh30ETHXr74O4b011OV+8/0LQ044= +knative.dev/pkg v0.0.0-20210822203034-3bed4dcf179c/go.mod h1:t6WzDPywQloi+AbOtiOejfpem1mLfKeuV+sjXGQLGN8= pgregory.net/rapid v0.3.3/go.mod h1:UYpPVyjFHzYBGHIxLFoupi8vwk6rXNzRY9OMvVxFIOU= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= diff --git a/pkg/client/injection/reconciler/caching/v1alpha1/image/controller.go b/pkg/client/injection/reconciler/caching/v1alpha1/image/controller.go index 787a11dd..0ed52c92 100644 --- a/pkg/client/injection/reconciler/caching/v1alpha1/image/controller.go +++ b/pkg/client/injection/reconciler/caching/v1alpha1/image/controller.go @@ -50,7 +50,7 @@ const ( // NewImpl returns a controller.Impl that handles queuing and feeding work from // the queue through an implementation of controller.Reconciler, delegating to // the provided Interface and optional Finalizer methods. OptionsFn is used to return -// controller.Options to be used by the internal reconciler. +// controller.ControllerOptions to be used by the internal reconciler. func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsFn) *controller.Impl { logger := logging.FromContext(ctx) @@ -101,7 +101,7 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF zap.String(logkey.Kind, "caching.internal.knative.dev.Image"), ) - impl := controller.NewImpl(rec, logger, ctrTypeName) + impl := controller.NewContext(ctx, rec, controller.ControllerOptions{WorkQueueName: ctrTypeName, Logger: logger}) agentName := defaultControllerAgentName // Pass impl to the options. Save any optional results. diff --git a/pkg/client/injection/reconciler/caching/v1alpha1/image/reconciler.go b/pkg/client/injection/reconciler/caching/v1alpha1/image/reconciler.go index 8dbd772b..a52af19d 100644 --- a/pkg/client/injection/reconciler/caching/v1alpha1/image/reconciler.go +++ b/pkg/client/injection/reconciler/caching/v1alpha1/image/reconciler.go @@ -77,9 +77,13 @@ type ReadOnlyInterface interface { // controller finalizing v1alpha1.Image if they want to process tombstoned resources // even when they are not the leader. Due to the nature of how finalizers are handled // there are no guarantees that this will be called. +// +// Deprecated: Use reconciler.OnDeletionInterface instead. type ReadOnlyFinalizer interface { // ObserveFinalizeKind implements custom logic to observe the final state of v1alpha1.Image. // This method should not write to the API. + // + // Deprecated: Use reconciler.ObserveDeletion instead. ObserveFinalizeKind(ctx context.Context, o *v1alpha1.Image) reconciler.Event } @@ -132,7 +136,6 @@ func NewReconciler(ctx context.Context, logger *zap.SugaredLogger, client versio if _, ok := r.(reconciler.LeaderAware); ok { logger.Fatalf("%T implements the incorrect LeaderAware interface. Promote() should not take an argument as genreconciler handles the enqueuing automatically.", r) } - // TODO: Consider validating when folks implement ReadOnlyFinalizer, but not Finalizer. rec := &reconcilerImpl{ LeaderAwareFuncs: reconciler.LeaderAwareFuncs{ diff --git a/vendor/knative.dev/pkg/client/injection/kube/client/client_expansion.go b/vendor/knative.dev/pkg/client/injection/kube/client/client_expansion.go index feb358db..622d9f36 100644 --- a/vendor/knative.dev/pkg/client/injection/kube/client/client_expansion.go +++ b/vendor/knative.dev/pkg/client/injection/kube/client/client_expansion.go @@ -18,6 +18,7 @@ package client import ( context "context" + fmt "fmt" certificatesv1beta1 "k8s.io/api/certificates/v1beta1" corev1 "k8s.io/api/core/v1" @@ -27,6 +28,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/fields" "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/types" restclient "k8s.io/client-go/rest" ) @@ -38,28 +40,70 @@ func (*wrapCoreV1ServiceImpl) ProxyGet(string, string, string, string, map[strin panic("NYI") } -func (*wrapEventsV1beta1EventImpl) CreateWithEventNamespace(*eventsv1beta1.Event) (*eventsv1beta1.Event, error) { - panic("NYI") +func (e *wrapEventsV1beta1EventImpl) CreateWithEventNamespace(event *eventsv1beta1.Event) (*eventsv1beta1.Event, error) { + if e.namespace != "" && event.Namespace != e.namespace { + return nil, fmt.Errorf("can't create an event with namespace '%v' in namespace '%v'", event.Namespace, e.namespace) + } + ne := &wrapEventsV1beta1EventImpl{ + dyn: e.dyn, + namespace: event.Namespace, + } + return ne.Create(context.TODO(), event, metav1.CreateOptions{}) } -func (*wrapEventsV1beta1EventImpl) UpdateWithEventNamespace(*eventsv1beta1.Event) (*eventsv1beta1.Event, error) { - panic("NYI") +func (e *wrapEventsV1beta1EventImpl) UpdateWithEventNamespace(event *eventsv1beta1.Event) (*eventsv1beta1.Event, error) { + if e.namespace != "" && event.Namespace != e.namespace { + return nil, fmt.Errorf("can't update an event with namespace '%v' in namespace '%v'", event.Namespace, e.namespace) + } + ne := &wrapEventsV1beta1EventImpl{ + dyn: e.dyn, + namespace: event.Namespace, + } + return ne.Update(context.TODO(), event, metav1.UpdateOptions{}) } -func (*wrapEventsV1beta1EventImpl) PatchWithEventNamespace(*eventsv1beta1.Event, []byte) (*eventsv1beta1.Event, error) { - panic("NYI") +func (e *wrapEventsV1beta1EventImpl) PatchWithEventNamespace(event *eventsv1beta1.Event, bytes []byte) (*eventsv1beta1.Event, error) { + if e.namespace != "" && event.Namespace != e.namespace { + return nil, fmt.Errorf("can't patch an event with namespace '%v' in namespace '%v'", event.Namespace, e.namespace) + } + ne := &wrapEventsV1beta1EventImpl{ + dyn: e.dyn, + namespace: event.Namespace, + } + return ne.Patch(context.TODO(), event.Name, types.StrategicMergePatchType, bytes, metav1.PatchOptions{}) } -func (*wrapCoreV1EventImpl) CreateWithEventNamespace(*corev1.Event) (*corev1.Event, error) { - panic("NYI") +func (e *wrapCoreV1EventImpl) CreateWithEventNamespace(event *corev1.Event) (*corev1.Event, error) { + if e.namespace != "" && event.Namespace != e.namespace { + return nil, fmt.Errorf("can't create an event with namespace '%v' in namespace '%v'", event.Namespace, e.namespace) + } + ne := &wrapCoreV1EventImpl{ + dyn: e.dyn, + namespace: event.Namespace, + } + return ne.Create(context.TODO(), event, metav1.CreateOptions{}) } -func (*wrapCoreV1EventImpl) UpdateWithEventNamespace(*corev1.Event) (*corev1.Event, error) { - panic("NYI") +func (e *wrapCoreV1EventImpl) UpdateWithEventNamespace(event *corev1.Event) (*corev1.Event, error) { + if e.namespace != "" && event.Namespace != e.namespace { + return nil, fmt.Errorf("can't update an event with namespace '%v' in namespace '%v'", event.Namespace, e.namespace) + } + ne := &wrapCoreV1EventImpl{ + dyn: e.dyn, + namespace: event.Namespace, + } + return ne.Update(context.TODO(), event, metav1.UpdateOptions{}) } -func (*wrapCoreV1EventImpl) PatchWithEventNamespace(*corev1.Event, []byte) (*corev1.Event, error) { - panic("NYI") +func (e *wrapCoreV1EventImpl) PatchWithEventNamespace(event *corev1.Event, bytes []byte) (*corev1.Event, error) { + if e.namespace != "" && event.Namespace != e.namespace { + return nil, fmt.Errorf("can't patch an event with namespace '%v' in namespace '%v'", event.Namespace, e.namespace) + } + ne := &wrapCoreV1EventImpl{ + dyn: e.dyn, + namespace: event.Namespace, + } + return ne.Patch(context.TODO(), event.Name, types.StrategicMergePatchType, bytes, metav1.PatchOptions{}) } func (*wrapCoreV1EventImpl) Search(*runtime.Scheme, runtime.Object) (*corev1.EventList, error) { diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_controller.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_controller.go index c97f8108..a624275a 100644 --- a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_controller.go +++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_controller.go @@ -80,9 +80,9 @@ func (g *reconcilerControllerGenerator) GenerateType(c *generator.Context, t *ty Package: "knative.dev/pkg/controller", Name: "Reconciler", }), - "controllerNewImpl": c.Universe.Function(types.Name{ + "controllerNewContext": c.Universe.Function(types.Name{ Package: "knative.dev/pkg/controller", - Name: "NewImpl", + Name: "NewContext", }), "loggingFromContext": c.Universe.Function(types.Name{ Package: "knative.dev/pkg/logging", @@ -134,7 +134,7 @@ func (g *reconcilerControllerGenerator) GenerateType(c *generator.Context, t *ty }), "controllerOptions": c.Universe.Type(types.Name{ Package: "knative.dev/pkg/controller", - Name: "Options", + Name: "ControllerOptions", }), "controllerOptionsFn": c.Universe.Type(types.Name{ Package: "knative.dev/pkg/controller", @@ -257,7 +257,7 @@ func NewImpl(ctx {{.contextContext|raw}}, r Interface{{if .hasClass}}, classValu ) - impl := {{.controllerNewImpl|raw}}(rec, logger, ctrTypeName) + impl := {{.controllerNewContext|raw}}(ctx, rec, {{ .controllerOptions|raw }}{WorkQueueName: ctrTypeName, Logger: logger}) agentName := defaultControllerAgentName // Pass impl to the options. Save any optional results. diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_reconciler.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_reconciler.go index 50602cd0..1781a60e 100644 --- a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_reconciler.go +++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_reconciler.go @@ -268,9 +268,13 @@ type ReadOnlyInterface interface { // controller finalizing {{.type|raw}} if they want to process tombstoned resources // even when they are not the leader. Due to the nature of how finalizers are handled // there are no guarantees that this will be called. +// +// Deprecated: Use reconciler.OnDeletionInterface instead. type ReadOnlyFinalizer interface { // ObserveFinalizeKind implements custom logic to observe the final state of {{.type|raw}}. // This method should not write to the API. + // + // Deprecated: Use reconciler.ObserveDeletion instead. ObserveFinalizeKind(ctx {{.contextContext|raw}}, o *{{.type|raw}}) {{.reconcilerEvent|raw}} } @@ -332,7 +336,6 @@ func NewReconciler(ctx {{.contextContext|raw}}, logger *{{.zapSugaredLogger|raw} if _, ok := r.({{.reconcilerLeaderAware|raw}}); ok { logger.Fatalf("%T implements the incorrect LeaderAware interface. Promote() should not take an argument as genreconciler handles the enqueuing automatically.", r) } - // TODO: Consider validating when folks implement ReadOnlyFinalizer, but not Finalizer. rec := &reconcilerImpl{ LeaderAwareFuncs: {{.reconcilerLeaderAwareFuncs|raw}}{ diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_reconciler_stub.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_reconciler_stub.go index c55ecf80..197afe9d 100644 --- a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_reconciler_stub.go +++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler_reconciler_stub.go @@ -81,10 +81,6 @@ func (g *reconcilerReconcilerStubGenerator) GenerateType(c *generator.Context, t Package: g.reconcilerPkg, Name: "ReadOnlyInterface", }), - "reconcilerReadOnlyFinalizer": c.Universe.Type(types.Name{ - Package: g.reconcilerPkg, - Name: "ReadOnlyFinalizer", - }), "corev1EventTypeNormal": c.Universe.Type(types.Name{ Package: "k8s.io/api/core/v1", Name: "EventTypeNormal", @@ -124,11 +120,6 @@ var _ {{.reconcilerInterface|raw}} = (*Reconciler)(nil) // Implement this to observe resources even when we are not the leader. //var _ {{.reconcilerReadOnlyInterface|raw}} = (*Reconciler)(nil) -// Optionally check that our Reconciler implements ReadOnlyFinalizer -// Implement this to observe tombstoned resources even when we are not -// the leader (best effort). -//var _ {{.reconcilerReadOnlyFinalizer|raw}} = (*Reconciler)(nil) - // ReconcileKind implements Interface.ReconcileKind. func (r *Reconciler) ReconcileKind(ctx {{.contextContext|raw}}, o *{{.type|raw}}) {{.reconcilerEvent|raw}} { {{if not .isKRShaped}}// TODO: use this if the resource implements InitializeConditions. @@ -156,10 +147,4 @@ func (r *Reconciler) ReconcileKind(ctx {{.contextContext|raw}}, o *{{.type|raw}} // // TODO: add custom observation logic here. // return nil // } - -// Optionally, use ObserveFinalizeKind to observe resources being finalized when we are no the leader. -//func (r *Reconciler) ObserveFinalizeKind(ctx {{.contextContext|raw}}, o *{{.type|raw}}) {{.reconcilerEvent|raw}} { -// // TODO: add custom observation logic here. -// return nil -//} ` diff --git a/vendor/knative.dev/pkg/configmap/store.go b/vendor/knative.dev/pkg/configmap/store.go index 8b94ab74..ffe9ad8c 100644 --- a/vendor/knative.dev/pkg/configmap/store.go +++ b/vendor/knative.dev/pkg/configmap/store.go @@ -26,6 +26,7 @@ import ( // Logger is the interface that UntypedStore expects its logger to conform to. // UntypedStore will log when updates succeed or fail. type Logger interface { + Debugf(string, ...interface{}) Infof(string, ...interface{}) Fatalf(string, ...interface{}) Errorf(string, ...interface{}) @@ -151,7 +152,7 @@ func (s *UntypedStore) OnConfigChanged(c *corev1.ConfigMap) { return } - s.logger.Infof("%s config %q config was added or updated: %#v", s.name, name, result) + s.logger.Debugf("%s config %q config was added or updated: %#v", s.name, name, result) storage.Store(result) for _, f := range s.onAfterStore { diff --git a/vendor/knative.dev/pkg/controller/controller.go b/vendor/knative.dev/pkg/controller/controller.go index d3cec2dd..dc7881ee 100644 --- a/vendor/knative.dev/pkg/controller/controller.go +++ b/vendor/knative.dev/pkg/controller/controller.go @@ -41,6 +41,7 @@ import ( "knative.dev/pkg/logging" "knative.dev/pkg/logging/logkey" "knative.dev/pkg/reconciler" + "knative.dev/pkg/tracker" ) const ( @@ -216,6 +217,10 @@ type Impl struct { // StatsReporter is used to send common controller metrics. statsReporter StatsReporter + + // Tracker allows reconcilers to associate a reference with particular key, + // such that when the reference changes the key is queued for reconciliation. + Tracker tracker.Interface } // ControllerOptions encapsulates options for creating a new controller, @@ -235,14 +240,15 @@ func NewImpl(r Reconciler, logger *zap.SugaredLogger, workQueueName string) *Imp return NewImplFull(r, ControllerOptions{WorkQueueName: workQueueName, Logger: logger}) } -// NewImplWithStats creates a controller.Impl with stats reporter. -// Deprecated: use NewImplFull. -func NewImplWithStats(r Reconciler, logger *zap.SugaredLogger, workQueueName string, reporter StatsReporter) *Impl { - return NewImplFull(r, ControllerOptions{WorkQueueName: workQueueName, Logger: logger, Reporter: reporter}) +// NewImplFull accepts the full set of options available to all controllers. +// Deprecated: use NewContext instead. +func NewImplFull(r Reconciler, options ControllerOptions) *Impl { + return NewContext(context.TODO(), r, options) } -// NewImplFull accepts the full set of options available to all controllers. -func NewImplFull(r Reconciler, options ControllerOptions) *Impl { +// NewContext instantiates an instance of our controller that will feed work to the +// provided Reconciler as it is enqueued. +func NewContext(ctx context.Context, r Reconciler, options ControllerOptions) *Impl { if options.RateLimiter == nil { options.RateLimiter = workqueue.DefaultControllerRateLimiter() } @@ -252,7 +258,7 @@ func NewImplFull(r Reconciler, options ControllerOptions) *Impl { if options.Concurrency == 0 { options.Concurrency = DefaultThreadsPerController } - return &Impl{ + i := &Impl{ Name: options.WorkQueueName, Reconciler: r, workQueue: newTwoLaneWorkQueue(options.WorkQueueName, options.RateLimiter), @@ -260,6 +266,14 @@ func NewImplFull(r Reconciler, options ControllerOptions) *Impl { statsReporter: options.Reporter, Concurrency: options.Concurrency, } + + if t := GetTracker(ctx); t != nil { + i.Tracker = t + } else { + i.Tracker = tracker.New(i.EnqueueKey, GetTrackerLease(ctx)) + } + + return i } // WorkQueue permits direct access to the work queue. @@ -816,6 +830,25 @@ func GetTrackerLease(ctx context.Context) time.Duration { return 3 * GetResyncPeriod(ctx) } +// trackerKey is used to associate tracker.Interface with contexts. +type trackerKey struct{} + +// WithTracker attaches the given tracker.Interface to the provided context +// in the returned context. +func WithTracker(ctx context.Context, t tracker.Interface) context.Context { + return context.WithValue(ctx, trackerKey{}, t) +} + +// GetTracker attempts to look up the tracker.Interface on a given context. +// It may return null if none is found. +func GetTracker(ctx context.Context) tracker.Interface { + untyped := ctx.Value(trackerKey{}) + if untyped == nil { + return nil + } + return untyped.(tracker.Interface) +} + // erKey is used to associate record.EventRecorders with contexts. type erKey struct{} diff --git a/vendor/knative.dev/pkg/injection/README.md b/vendor/knative.dev/pkg/injection/README.md index 0373d53a..d7c80ada 100644 --- a/vendor/knative.dev/pkg/injection/README.md +++ b/vendor/knative.dev/pkg/injection/README.md @@ -58,7 +58,10 @@ Update `NewController` as follows: ```go "knative.dev/pkg/controller" ... -impl := controller.NewImpl(c, logger, "NameOfController") +impl := controller.NewContext(ctx, c, controller.ControllerOptions{ + Logger: logger, + WorkQueueName: "NameOfController", +}) ``` becomes @@ -139,7 +142,10 @@ func NewController(ctx context.Context, cmw configmap.Watcher) *controller.Impl ServiceLister: svcInformer.Lister(), } logger = logger.Named("NameOfController") - impl := controller.NewImpl(c, logger, "NameOfController") + impl := controller.NewContext(ctx, c, controller.ControllerOptions{ + Logger: logger, + WorkQueueName: "NameOfController", + }) // Set up event handlers. svcInformer.Informer().AddEventHandler(...) @@ -421,7 +427,7 @@ kindreconciler "knative.dev//pkg/client/injection/reconciler/ Controller related artifacts: - `NewImpl` - gets an injection based client and lister for ``, sets up - Kubernetes Event recorders, and delegates to `controller.NewImpl` for queue + Kubernetes Event recorders, and delegates to `controller.NewContext` for queue management. ```go diff --git a/vendor/modules.txt b/vendor/modules.txt index a269b17a..125a72ae 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -578,7 +578,7 @@ k8s.io/utils/trace # knative.dev/hack v0.0.0-20210806075220-815cd312d65c ## explicit knative.dev/hack -# knative.dev/pkg v0.0.0-20210818135208-7b5ecbc0e477 +# knative.dev/pkg v0.0.0-20210822203034-3bed4dcf179c ## explicit knative.dev/pkg/apis knative.dev/pkg/apis/duck