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 <automation@knative.team>

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
 )

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=

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.

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{

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) {

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.

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}}{

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
-//}
 `

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 {

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{}
 

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/<repo>/pkg/client/injection/reconciler/<clientgroup>
 Controller related artifacts:
 
 - `NewImpl` - gets an injection based client and lister for `<kind>`, sets up
-  Kubernetes Event recorders, and delegates to `controller.NewImpl` for queue
+  Kubernetes Event recorders, and delegates to `controller.NewContext` for queue
   management.
 
 ```go

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