Repository: knative-sandbox/eventing-kafka
Pull request #321 (2021-01-20 18:32:23)

make space for mt source
<!-- Please include the 'why' behind your changes if no issue exists -->

## Proposed Changes

- Make space for the multi-tenant source
-
-

<!--
If this change has user-visible impact, follow the instructions below.
Examples include:

- 🎁 Add new feature
- 🐛 Fix bug
- 🧽 Update or clean up current behavior
- 🗑️ Remove feature or internal logic

Otherwise delete the rest of this template.
-->

**Release Note**

<!--
🗒️ If this change has user-visible impact, write a release note in the block
below. Include the string "action required" if additional action is required of
users switching to the new release, for example in case of a breaking change.

Write as if you are speaking to users, not other Knative contributors. If this
change has no user-visible impact, no release-note is needed.
-->

```release-note

```

**Docs**

<!--
📖 If this change has user-visible impact, link to an issue or PR in
https://github.com/knative/docs.
-->


knative-prow-robot: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/knative-sandbox/eventing-kafka/pull/321#" title="Author self-approved">lionelvillard</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=knative-sandbox%2Feventing-kafka).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/knative-sandbox/eventing-kafka/blob/master/OWNERS)~~ [lionelvillard]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->
codecov[bot]: # [Codecov](https://codecov.io/gh/knative-sandbox/eventing-kafka/pull/321?src=pr&el=h1) Report
> Merging [#321](https://codecov.io/gh/knative-sandbox/eventing-kafka/pull/321?src=pr&el=desc) (908aeb4) into [master](https://codecov.io/gh/knative-sandbox/eventing-kafka/commit/fd7895c7f431deba9a4f37e49bd97d0a36e94795?el=desc) (fd7895c) will **decrease** coverage by `0.15%`.
> The diff coverage is `n/a`.

[![Impacted file tree graph](https://codecov.io/gh/knative-sandbox/eventing-kafka/pull/321/graphs/tree.svg?width=650&height=150&src=pr&token=W765CT93QC)](https://codecov.io/gh/knative-sandbox/eventing-kafka/pull/321?src=pr&el=tree)

```diff
@@            Coverage Diff             @@
##           master     #321      +/-   ##
==========================================
- Coverage   76.08%   75.92%   -0.16%     
==========================================
  Files         114      114              
  Lines        4391     4391              
==========================================
- Hits         3341     3334       -7     
- Misses        851      858       +7     
  Partials      199      199              
```


| [Impacted Files](https://codecov.io/gh/knative-sandbox/eventing-kafka/pull/321?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [...el/distributed/dispatcher/dispatcher/dispatcher.go](https://codecov.io/gh/knative-sandbox/eventing-kafka/pull/321/diff?src=pr&el=tree#diff-cGtnL2NoYW5uZWwvZGlzdHJpYnV0ZWQvZGlzcGF0Y2hlci9kaXNwYXRjaGVyL2Rpc3BhdGNoZXIuZ28=) | `66.05% <0.00%> (-6.43%)` | :arrow_down: |

------

[Continue to review full report at Codecov](https://codecov.io/gh/knative-sandbox/eventing-kafka/pull/321?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/knative-sandbox/eventing-kafka/pull/321?src=pr&el=footer). Last update [fd7895c...908aeb4](https://codecov.io/gh/knative-sandbox/eventing-kafka/pull/321?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).

knative-prow-robot: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/knative-sandbox/eventing-kafka/pull/321#" title="Author self-approved">lionelvillard</a>*, *<a href="https://github.com/knative-sandbox/eventing-kafka/pull/321#pullrequestreview-574333624" title="Approved">steven0711dong</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=knative-sandbox%2Feventing-kafka).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/knative-sandbox/eventing-kafka/blob/master/OWNERS)~~ [lionelvillard]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->

Patch:
diff --git a/config/source/200-serviceaccount.yaml b/config/source/single/200-serviceaccount.yaml
similarity index 100%
rename from config/source/200-serviceaccount.yaml
rename to config/source/single/200-serviceaccount.yaml
diff --git a/config/source/201-clusterrole.yaml b/config/source/single/201-clusterrole.yaml
similarity index 100%
rename from config/source/201-clusterrole.yaml
rename to config/source/single/201-clusterrole.yaml
diff --git a/config/source/202-clusterrolebinding.yaml b/config/source/single/202-clusterrolebinding.yaml
similarity index 100%
rename from config/source/202-clusterrolebinding.yaml
rename to config/source/single/202-clusterrolebinding.yaml
diff --git a/config/source/300-kafkabinding.yaml b/config/source/single/300-kafkabinding.yaml
similarity index 100%
rename from config/source/300-kafkabinding.yaml
rename to config/source/single/300-kafkabinding.yaml
diff --git a/config/source/300-kafkasource.yaml b/config/source/single/300-kafkasource.yaml
similarity index 100%
rename from config/source/300-kafkasource.yaml
rename to config/source/single/300-kafkasource.yaml
diff --git a/config/source/400-controller-service.yaml b/config/source/single/400-controller-service.yaml
similarity index 100%
rename from config/source/400-controller-service.yaml
rename to config/source/single/400-controller-service.yaml
diff --git a/config/source/500-controller.yaml b/config/source/single/500-controller.yaml
similarity index 100%
rename from config/source/500-controller.yaml
rename to config/source/single/500-controller.yaml
diff --git a/config/source/500-webhook-configuration.yaml b/config/source/single/500-webhook-configuration.yaml
similarity index 100%
rename from config/source/500-webhook-configuration.yaml
rename to config/source/single/500-webhook-configuration.yaml
diff --git a/config/source/README.md b/config/source/single/README.md
similarity index 100%
rename from config/source/README.md
rename to config/source/single/README.md
diff --git a/config/source/deployments/controller-service.yaml b/config/source/single/deployments/controller-service.yaml
similarity index 100%
rename from config/source/deployments/controller-service.yaml
rename to config/source/single/deployments/controller-service.yaml
diff --git a/config/source/deployments/controller.yaml b/config/source/single/deployments/controller.yaml
similarity index 100%
rename from config/source/deployments/controller.yaml
rename to config/source/single/deployments/controller.yaml
diff --git a/config/source/resources/kafkabinding.yaml b/config/source/single/resources/kafkabinding.yaml
similarity index 100%
rename from config/source/resources/kafkabinding.yaml
rename to config/source/single/resources/kafkabinding.yaml
diff --git a/config/source/resources/kafkasource.yaml b/config/source/single/resources/kafkasource.yaml
similarity index 100%
rename from config/source/resources/kafkasource.yaml
rename to config/source/single/resources/kafkasource.yaml
diff --git a/config/source/roles/clusterrole.yaml b/config/source/single/roles/clusterrole.yaml
similarity index 100%
rename from config/source/roles/clusterrole.yaml
rename to config/source/single/roles/clusterrole.yaml
diff --git a/config/source/webhooks/kafka.yaml b/config/source/single/webhooks/kafka.yaml
similarity index 100%
rename from config/source/webhooks/kafka.yaml
rename to config/source/single/webhooks/kafka.yaml
diff --git a/go.mod b/go.mod
index 008ec1854..862683ae8 100644
--- a/go.mod
+++ b/go.mod
@@ -28,13 +28,13 @@ require (
 	go.uber.org/zap v1.16.0
 	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 // indirect
 	golang.org/x/sync v0.0.0-20201207232520-09787c993a3a
-	k8s.io/api v0.18.12
-	k8s.io/apimachinery v0.18.12
+	k8s.io/api v0.19.7
+	k8s.io/apimachinery v0.19.7
 	k8s.io/client-go v11.0.1-0.20190805182717-6502b5e7b1b5+incompatible
 	k8s.io/utils v0.0.0-20200603063816-c1c6865ac451
-	knative.dev/eventing v0.20.1-0.20210115015220-1c94ef83b6b5
-	knative.dev/hack v0.0.0-20210114150620-4422dcadb3c8
-	knative.dev/pkg v0.0.0-20210114223020-f0ea5e6b9c4e
+	knative.dev/eventing v0.20.1-0.20210125061954-340f07f40bda
+	knative.dev/hack v0.0.0-20210120165453-8d623a0af457
+	knative.dev/pkg v0.0.0-20210124203454-7101e9d4f6c6
 )
 
 replace (
diff --git a/go.sum b/go.sum
index 801e16600..1a5e63a0d 100644
--- a/go.sum
+++ b/go.sum
@@ -1232,6 +1232,8 @@ k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8
 k8s.io/gengo v0.0.0-20200114144118-36b2048a9120/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
 k8s.io/gengo v0.0.0-20200205140755-e0e292d8aa12 h1:pZzawYyz6VRNPVYpqGv61LWCimQv1BihyeqFrp50/G4=
 k8s.io/gengo v0.0.0-20200205140755-e0e292d8aa12/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
+k8s.io/gengo v0.0.0-20200428234225-8167cfdcfc14 h1:t4L10Qfx/p7ASH3gXCdIUtPbbIuegCoUJf3TMSFekjw=
+k8s.io/gengo v0.0.0-20200428234225-8167cfdcfc14/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
 k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
 k8s.io/klog v0.3.0/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
 k8s.io/klog v1.0.0 h1:Pt+yjF5aB1xDSVbau4VsWe+dQNzA0qv1LlXdC2dF6Q8=
@@ -1244,21 +1246,19 @@ k8s.io/kube-openapi v0.0.0-20200410145947-bcb3869e6f29/go.mod h1:F+5wygcW0wmRTnM
 k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew=
 k8s.io/utils v0.0.0-20200603063816-c1c6865ac451 h1:v8ud2Up6QK1lNOKFgiIVrZdMg7MpmSnvtrOieolJKoE=
 k8s.io/utils v0.0.0-20200603063816-c1c6865ac451/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
-knative.dev/eventing v0.20.1-0.20210115015220-1c94ef83b6b5 h1:Gb18mayz8CukHpC6SFXUVDbd2YVdgrkUbJ50zdNX140=
-knative.dev/eventing v0.20.1-0.20210115015220-1c94ef83b6b5/go.mod h1:HdS7UgtDbKQuCuEwgS3+jxtHvpm+PPp/eEsjaQwfWl8=
+knative.dev/eventing v0.20.1-0.20210125061954-340f07f40bda h1:P1na4giLTOS/qvnApNqvXulHNaZ1XmgDW+rzcnubK8M=
+knative.dev/eventing v0.20.1-0.20210125061954-340f07f40bda/go.mod h1:g0n5XSKZTeGfPP6sBdU3o9yd5ZFXTW/kWe75QebITI4=
 knative.dev/hack v0.0.0-20201214230143-4ed1ecb8db24 h1:kIztWfvnIFV8Lhlea02K3YO2mIzcDyQNzrBLn0Oq9sA=
 knative.dev/hack v0.0.0-20201214230143-4ed1ecb8db24/go.mod h1:PHt8x8yX5Z9pPquBEfIj0X66f8iWkWfR0S/sarACJrI=
-knative.dev/hack v0.0.0-20210112093330-d946d2557383 h1:YDYKfHaplhMelgOVP8eRvHlYf5elgZveo36GBDFfDqA=
-knative.dev/hack v0.0.0-20210112093330-d946d2557383/go.mod h1:PHt8x8yX5Z9pPquBEfIj0X66f8iWkWfR0S/sarACJrI=
 knative.dev/hack v0.0.0-20210114150620-4422dcadb3c8 h1:N/Kt6C5zZzTtFcTntRThB+vEJ7WcLKaZ5Q2Jm7b23vw=
 knative.dev/hack v0.0.0-20210114150620-4422dcadb3c8/go.mod h1:PHt8x8yX5Z9pPquBEfIj0X66f8iWkWfR0S/sarACJrI=
-knative.dev/pkg v0.0.0-20210107022335-51c72e24c179 h1:lkrgrv69iUk2qhOG9symy15kJUaJZmMybSloi7C3gIw=
-knative.dev/pkg v0.0.0-20210107022335-51c72e24c179/go.mod h1:hckgW978SdzPA2H5EDvRPY8xsnPuDZLJLbPf8Jte7Q0=
-knative.dev/pkg v0.0.0-20210112143930-acbf2af596cf h1:6/VyHMk6pa395xWho0KLfVj+7NNrmlO7Ki9jLbVjoaI=
-knative.dev/pkg v0.0.0-20210112143930-acbf2af596cf/go.mod h1:hckgW978SdzPA2H5EDvRPY8xsnPuDZLJLbPf8Jte7Q0=
+knative.dev/hack v0.0.0-20210120165453-8d623a0af457 h1:jEBITgx/lQydGncM0uetpv/ZqawRzb2aSfEaYoMeDjM=
+knative.dev/hack v0.0.0-20210120165453-8d623a0af457/go.mod h1:PHt8x8yX5Z9pPquBEfIj0X66f8iWkWfR0S/sarACJrI=
 knative.dev/pkg v0.0.0-20210114223020-f0ea5e6b9c4e h1:3k5tzvlM9VGZFiXRj8UKc3CUpMGpqBlEbIY0Dp3F3NU=
 knative.dev/pkg v0.0.0-20210114223020-f0ea5e6b9c4e/go.mod h1:hckgW978SdzPA2H5EDvRPY8xsnPuDZLJLbPf8Jte7Q0=
-knative.dev/reconciler-test v0.0.0-20210111135237-9b251467ccb6/go.mod h1:rmQpZseeqDpg6/ToFzIeV5hTRkOJujaXBCK7iYL7M4E=
+knative.dev/pkg v0.0.0-20210124203454-7101e9d4f6c6 h1:jMwOlw2AZx9KlfIExLCFjcpM5jxL4huwfhHvRPqrTSI=
+knative.dev/pkg v0.0.0-20210124203454-7101e9d4f6c6/go.mod h1:X4NPrCo8NK3hbDVan9Vm7mf5io3ZoINakAdrpSXVB08=
+knative.dev/reconciler-test v0.0.0-20210115075620-6fe6ef693370/go.mod h1:A5ZaQo+1lWGw2OoSc06wSyReX6huzBPJ2ra/R48s1yo=
 pgregory.net/rapid v0.3.3 h1:jCjBsY4ln4Atz78QoBWxUEvAHaFyNDQg9+WU62aCn1U=
 pgregory.net/rapid v0.3.3/go.mod h1:UYpPVyjFHzYBGHIxLFoupi8vwk6rXNzRY9OMvVxFIOU=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
diff --git a/hack/release.sh b/hack/release.sh
index 4ab5b20b8..0f264fd76 100755
--- a/hack/release.sh
+++ b/hack/release.sh
@@ -26,7 +26,7 @@ declare -A COMPONENTS
 COMPONENTS=(
   ["channel-consolidated.yaml"]="config/channel/consolidated"
   ["channel-distributed.yaml"]="config/channel/distributed"
-  ["source.yaml"]="config/source"
+  ["source.yaml"]="config/source/single"
 )
 readonly COMPONENTS
 
diff --git a/pkg/channel/consolidated/README.md b/pkg/channel/consolidated/README.md
index da453612d..432d4cfcd 100644
--- a/pkg/channel/consolidated/README.md
+++ b/pkg/channel/consolidated/README.md
@@ -173,20 +173,23 @@ data:
       RequiredAcks: -1  # -1 = WaitForAll, Most stringent option for "at-least-once" delivery.
 ```
 
-Settings defined here are used as the defaults by the KafkaChannel. The additional settings defined in the
-channel CR, such as authentication, are applied on top of these defaults.
-
-Also, some Sarama settings are required for the channel to work, such as `Consumer.Return.Errors`
-and `Producer.Return.Successes`, so the value for these in the `config-kafka` is ignored.
-
-Value of the `sarama` key must be valid YAML string. The string is marshalled into a
-[Sarama config struct](https://github.com/Shopify/sarama/blob/master/config.go), with a few
-exceptions (`Version` and certificates).
-
-To specify a certificate, you can use the following format
-where you should make sure to use the YAML string syntax of "|-" in order to
-prevent trailing linefeed. The indentation of the PEM content is also important
-and must be aligned as shown.
+Settings defined here are used as the defaults by the KafkaChannel. The
+additional settings defined in the channel CR, such as authentication, are
+applied on top of these defaults.
+
+Also, some Sarama settings are required for the channel to work, such as
+`Consumer.Return.Errors` and `Producer.Return.Successes`, so the value for these
+in the `config-kafka` is ignored.
+
+Value of the `sarama` key must be valid YAML string. The string is marshalled
+into a
+[Sarama config struct](https://github.com/Shopify/sarama/blob/master/config.go),
+with a few exceptions (`Version` and certificates).
+
+To specify a certificate, you can use the following format where you should make
+sure to use the YAML string syntax of "|-" in order to prevent trailing
+linefeed. The indentation of the PEM content is also important and must be
+aligned as shown.
 
 ```yaml
 apiVersion: v1
diff --git a/pkg/client/injection/informers/bindings/v1alpha1/kafkabinding/filtered/fake/fake.go b/pkg/client/injection/informers/bindings/v1alpha1/kafkabinding/filtered/fake/fake.go
new file mode 100644
index 000000000..a5f553e7b
--- /dev/null
+++ b/pkg/client/injection/informers/bindings/v1alpha1/kafkabinding/filtered/fake/fake.go
@@ -0,0 +1,52 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	context "context"
+
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/bindings/v1alpha1/kafkabinding/filtered"
+	factoryfiltered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+var Get = filtered.Get
+
+func init() {
+	injection.Fake.RegisterFilteredInformers(withInformer)
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(factoryfiltered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := factoryfiltered.Get(ctx, selector)
+		inf := f.Bindings().V1alpha1().KafkaBindings()
+		ctx = context.WithValue(ctx, filtered.Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
diff --git a/pkg/client/injection/informers/bindings/v1alpha1/kafkabinding/filtered/kafkabinding.go b/pkg/client/injection/informers/bindings/v1alpha1/kafkabinding/filtered/kafkabinding.go
new file mode 100644
index 000000000..7971f68b4
--- /dev/null
+++ b/pkg/client/injection/informers/bindings/v1alpha1/kafkabinding/filtered/kafkabinding.go
@@ -0,0 +1,65 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package filtered
+
+import (
+	context "context"
+
+	v1alpha1 "knative.dev/eventing-kafka/pkg/client/informers/externalversions/bindings/v1alpha1"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+func init() {
+	injection.Default.RegisterFilteredInformers(withInformer)
+}
+
+// Key is used for associating the Informer inside the context.Context.
+type Key struct {
+	Selector string
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(filtered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := filtered.Get(ctx, selector)
+		inf := f.Bindings().V1alpha1().KafkaBindings()
+		ctx = context.WithValue(ctx, Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
+
+// Get extracts the typed informer from the context.
+func Get(ctx context.Context, selector string) v1alpha1.KafkaBindingInformer {
+	untyped := ctx.Value(Key{Selector: selector})
+	if untyped == nil {
+		logging.FromContext(ctx).Panicf(
+			"Unable to fetch knative.dev/eventing-kafka/pkg/client/informers/externalversions/bindings/v1alpha1.KafkaBindingInformer with selector %s from context.", selector)
+	}
+	return untyped.(v1alpha1.KafkaBindingInformer)
+}
diff --git a/pkg/client/injection/informers/bindings/v1beta1/kafkabinding/filtered/fake/fake.go b/pkg/client/injection/informers/bindings/v1beta1/kafkabinding/filtered/fake/fake.go
new file mode 100644
index 000000000..806d684b9
--- /dev/null
+++ b/pkg/client/injection/informers/bindings/v1beta1/kafkabinding/filtered/fake/fake.go
@@ -0,0 +1,52 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	context "context"
+
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/bindings/v1beta1/kafkabinding/filtered"
+	factoryfiltered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+var Get = filtered.Get
+
+func init() {
+	injection.Fake.RegisterFilteredInformers(withInformer)
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(factoryfiltered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := factoryfiltered.Get(ctx, selector)
+		inf := f.Bindings().V1beta1().KafkaBindings()
+		ctx = context.WithValue(ctx, filtered.Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
diff --git a/pkg/client/injection/informers/bindings/v1beta1/kafkabinding/filtered/kafkabinding.go b/pkg/client/injection/informers/bindings/v1beta1/kafkabinding/filtered/kafkabinding.go
new file mode 100644
index 000000000..89791ec60
--- /dev/null
+++ b/pkg/client/injection/informers/bindings/v1beta1/kafkabinding/filtered/kafkabinding.go
@@ -0,0 +1,65 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package filtered
+
+import (
+	context "context"
+
+	v1beta1 "knative.dev/eventing-kafka/pkg/client/informers/externalversions/bindings/v1beta1"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+func init() {
+	injection.Default.RegisterFilteredInformers(withInformer)
+}
+
+// Key is used for associating the Informer inside the context.Context.
+type Key struct {
+	Selector string
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(filtered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := filtered.Get(ctx, selector)
+		inf := f.Bindings().V1beta1().KafkaBindings()
+		ctx = context.WithValue(ctx, Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
+
+// Get extracts the typed informer from the context.
+func Get(ctx context.Context, selector string) v1beta1.KafkaBindingInformer {
+	untyped := ctx.Value(Key{Selector: selector})
+	if untyped == nil {
+		logging.FromContext(ctx).Panicf(
+			"Unable to fetch knative.dev/eventing-kafka/pkg/client/informers/externalversions/bindings/v1beta1.KafkaBindingInformer with selector %s from context.", selector)
+	}
+	return untyped.(v1beta1.KafkaBindingInformer)
+}
diff --git a/pkg/client/injection/informers/factory/filtered/fake/fake_filtered_factory.go b/pkg/client/injection/informers/factory/filtered/fake/fake_filtered_factory.go
new file mode 100644
index 000000000..5dff766aa
--- /dev/null
+++ b/pkg/client/injection/informers/factory/filtered/fake/fake_filtered_factory.go
@@ -0,0 +1,59 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package fakeFilteredFactory
+
+import (
+	context "context"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	externalversions "knative.dev/eventing-kafka/pkg/client/informers/externalversions"
+	fake "knative.dev/eventing-kafka/pkg/client/injection/client/fake"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+var Get = filtered.Get
+
+func init() {
+	injection.Fake.RegisterInformerFactory(withInformerFactory)
+}
+
+func withInformerFactory(ctx context.Context) context.Context {
+	c := fake.Get(ctx)
+	opts := []externalversions.SharedInformerOption{}
+	if injection.HasNamespaceScope(ctx) {
+		opts = append(opts, externalversions.WithNamespace(injection.GetNamespaceScope(ctx)))
+	}
+	untyped := ctx.Value(filtered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	for _, selector := range labelSelectors {
+		thisOpts := append(opts, externalversions.WithTweakListOptions(func(l *v1.ListOptions) {
+			l.LabelSelector = selector
+		}))
+		ctx = context.WithValue(ctx, filtered.Key{Selector: selector},
+			externalversions.NewSharedInformerFactoryWithOptions(c, controller.GetResyncPeriod(ctx), thisOpts...))
+	}
+	return ctx
+}
diff --git a/pkg/client/injection/informers/factory/filtered/filtered_factory.go b/pkg/client/injection/informers/factory/filtered/filtered_factory.go
new file mode 100644
index 000000000..9d3c92063
--- /dev/null
+++ b/pkg/client/injection/informers/factory/filtered/filtered_factory.go
@@ -0,0 +1,77 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package filteredFactory
+
+import (
+	context "context"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	externalversions "knative.dev/eventing-kafka/pkg/client/informers/externalversions"
+	client "knative.dev/eventing-kafka/pkg/client/injection/client"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+func init() {
+	injection.Default.RegisterInformerFactory(withInformerFactory)
+}
+
+// Key is used as the key for associating information with a context.Context.
+type Key struct {
+	Selector string
+}
+
+type LabelKey struct{}
+
+func WithSelectors(ctx context.Context, selector ...string) context.Context {
+	return context.WithValue(ctx, LabelKey{}, selector)
+}
+
+func withInformerFactory(ctx context.Context) context.Context {
+	c := client.Get(ctx)
+	opts := []externalversions.SharedInformerOption{}
+	if injection.HasNamespaceScope(ctx) {
+		opts = append(opts, externalversions.WithNamespace(injection.GetNamespaceScope(ctx)))
+	}
+	untyped := ctx.Value(LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	for _, selector := range labelSelectors {
+		thisOpts := append(opts, externalversions.WithTweakListOptions(func(l *v1.ListOptions) {
+			l.LabelSelector = selector
+		}))
+		ctx = context.WithValue(ctx, Key{Selector: selector},
+			externalversions.NewSharedInformerFactoryWithOptions(c, controller.GetResyncPeriod(ctx), thisOpts...))
+	}
+	return ctx
+}
+
+// Get extracts the InformerFactory from the context.
+func Get(ctx context.Context, selector string) externalversions.SharedInformerFactory {
+	untyped := ctx.Value(Key{Selector: selector})
+	if untyped == nil {
+		logging.FromContext(ctx).Panicf(
+			"Unable to fetch knative.dev/eventing-kafka/pkg/client/informers/externalversions.SharedInformerFactory with selector %s from context.", selector)
+	}
+	return untyped.(externalversions.SharedInformerFactory)
+}
diff --git a/pkg/client/injection/informers/messaging/v1alpha1/kafkachannel/filtered/fake/fake.go b/pkg/client/injection/informers/messaging/v1alpha1/kafkachannel/filtered/fake/fake.go
new file mode 100644
index 000000000..7d5fe721b
--- /dev/null
+++ b/pkg/client/injection/informers/messaging/v1alpha1/kafkachannel/filtered/fake/fake.go
@@ -0,0 +1,52 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	context "context"
+
+	factoryfiltered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/messaging/v1alpha1/kafkachannel/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+var Get = filtered.Get
+
+func init() {
+	injection.Fake.RegisterFilteredInformers(withInformer)
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(factoryfiltered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := factoryfiltered.Get(ctx, selector)
+		inf := f.Messaging().V1alpha1().KafkaChannels()
+		ctx = context.WithValue(ctx, filtered.Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
diff --git a/pkg/client/injection/informers/messaging/v1alpha1/kafkachannel/filtered/kafkachannel.go b/pkg/client/injection/informers/messaging/v1alpha1/kafkachannel/filtered/kafkachannel.go
new file mode 100644
index 000000000..9cc546d7d
--- /dev/null
+++ b/pkg/client/injection/informers/messaging/v1alpha1/kafkachannel/filtered/kafkachannel.go
@@ -0,0 +1,65 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package filtered
+
+import (
+	context "context"
+
+	v1alpha1 "knative.dev/eventing-kafka/pkg/client/informers/externalversions/messaging/v1alpha1"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+func init() {
+	injection.Default.RegisterFilteredInformers(withInformer)
+}
+
+// Key is used for associating the Informer inside the context.Context.
+type Key struct {
+	Selector string
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(filtered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := filtered.Get(ctx, selector)
+		inf := f.Messaging().V1alpha1().KafkaChannels()
+		ctx = context.WithValue(ctx, Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
+
+// Get extracts the typed informer from the context.
+func Get(ctx context.Context, selector string) v1alpha1.KafkaChannelInformer {
+	untyped := ctx.Value(Key{Selector: selector})
+	if untyped == nil {
+		logging.FromContext(ctx).Panicf(
+			"Unable to fetch knative.dev/eventing-kafka/pkg/client/informers/externalversions/messaging/v1alpha1.KafkaChannelInformer with selector %s from context.", selector)
+	}
+	return untyped.(v1alpha1.KafkaChannelInformer)
+}
diff --git a/pkg/client/injection/informers/messaging/v1beta1/kafkachannel/filtered/fake/fake.go b/pkg/client/injection/informers/messaging/v1beta1/kafkachannel/filtered/fake/fake.go
new file mode 100644
index 000000000..64164b00a
--- /dev/null
+++ b/pkg/client/injection/informers/messaging/v1beta1/kafkachannel/filtered/fake/fake.go
@@ -0,0 +1,52 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	context "context"
+
+	factoryfiltered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/messaging/v1beta1/kafkachannel/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+var Get = filtered.Get
+
+func init() {
+	injection.Fake.RegisterFilteredInformers(withInformer)
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(factoryfiltered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := factoryfiltered.Get(ctx, selector)
+		inf := f.Messaging().V1beta1().KafkaChannels()
+		ctx = context.WithValue(ctx, filtered.Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
diff --git a/pkg/client/injection/informers/messaging/v1beta1/kafkachannel/filtered/kafkachannel.go b/pkg/client/injection/informers/messaging/v1beta1/kafkachannel/filtered/kafkachannel.go
new file mode 100644
index 000000000..7e0893f12
--- /dev/null
+++ b/pkg/client/injection/informers/messaging/v1beta1/kafkachannel/filtered/kafkachannel.go
@@ -0,0 +1,65 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package filtered
+
+import (
+	context "context"
+
+	v1beta1 "knative.dev/eventing-kafka/pkg/client/informers/externalversions/messaging/v1beta1"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+func init() {
+	injection.Default.RegisterFilteredInformers(withInformer)
+}
+
+// Key is used for associating the Informer inside the context.Context.
+type Key struct {
+	Selector string
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(filtered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := filtered.Get(ctx, selector)
+		inf := f.Messaging().V1beta1().KafkaChannels()
+		ctx = context.WithValue(ctx, Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
+
+// Get extracts the typed informer from the context.
+func Get(ctx context.Context, selector string) v1beta1.KafkaChannelInformer {
+	untyped := ctx.Value(Key{Selector: selector})
+	if untyped == nil {
+		logging.FromContext(ctx).Panicf(
+			"Unable to fetch knative.dev/eventing-kafka/pkg/client/informers/externalversions/messaging/v1beta1.KafkaChannelInformer with selector %s from context.", selector)
+	}
+	return untyped.(v1beta1.KafkaChannelInformer)
+}
diff --git a/pkg/client/injection/informers/sources/v1alpha1/kafkasource/filtered/fake/fake.go b/pkg/client/injection/informers/sources/v1alpha1/kafkasource/filtered/fake/fake.go
new file mode 100644
index 000000000..778c46f01
--- /dev/null
+++ b/pkg/client/injection/informers/sources/v1alpha1/kafkasource/filtered/fake/fake.go
@@ -0,0 +1,52 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	context "context"
+
+	factoryfiltered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/sources/v1alpha1/kafkasource/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+var Get = filtered.Get
+
+func init() {
+	injection.Fake.RegisterFilteredInformers(withInformer)
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(factoryfiltered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := factoryfiltered.Get(ctx, selector)
+		inf := f.Sources().V1alpha1().KafkaSources()
+		ctx = context.WithValue(ctx, filtered.Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
diff --git a/pkg/client/injection/informers/sources/v1alpha1/kafkasource/filtered/kafkasource.go b/pkg/client/injection/informers/sources/v1alpha1/kafkasource/filtered/kafkasource.go
new file mode 100644
index 000000000..316eb495a
--- /dev/null
+++ b/pkg/client/injection/informers/sources/v1alpha1/kafkasource/filtered/kafkasource.go
@@ -0,0 +1,65 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package filtered
+
+import (
+	context "context"
+
+	v1alpha1 "knative.dev/eventing-kafka/pkg/client/informers/externalversions/sources/v1alpha1"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+func init() {
+	injection.Default.RegisterFilteredInformers(withInformer)
+}
+
+// Key is used for associating the Informer inside the context.Context.
+type Key struct {
+	Selector string
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(filtered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := filtered.Get(ctx, selector)
+		inf := f.Sources().V1alpha1().KafkaSources()
+		ctx = context.WithValue(ctx, Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
+
+// Get extracts the typed informer from the context.
+func Get(ctx context.Context, selector string) v1alpha1.KafkaSourceInformer {
+	untyped := ctx.Value(Key{Selector: selector})
+	if untyped == nil {
+		logging.FromContext(ctx).Panicf(
+			"Unable to fetch knative.dev/eventing-kafka/pkg/client/informers/externalversions/sources/v1alpha1.KafkaSourceInformer with selector %s from context.", selector)
+	}
+	return untyped.(v1alpha1.KafkaSourceInformer)
+}
diff --git a/pkg/client/injection/informers/sources/v1beta1/kafkasource/filtered/fake/fake.go b/pkg/client/injection/informers/sources/v1beta1/kafkasource/filtered/fake/fake.go
new file mode 100644
index 000000000..fe4abc3be
--- /dev/null
+++ b/pkg/client/injection/informers/sources/v1beta1/kafkasource/filtered/fake/fake.go
@@ -0,0 +1,52 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	context "context"
+
+	factoryfiltered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/sources/v1beta1/kafkasource/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+var Get = filtered.Get
+
+func init() {
+	injection.Fake.RegisterFilteredInformers(withInformer)
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(factoryfiltered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := factoryfiltered.Get(ctx, selector)
+		inf := f.Sources().V1beta1().KafkaSources()
+		ctx = context.WithValue(ctx, filtered.Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
diff --git a/pkg/client/injection/informers/sources/v1beta1/kafkasource/filtered/kafkasource.go b/pkg/client/injection/informers/sources/v1beta1/kafkasource/filtered/kafkasource.go
new file mode 100644
index 000000000..a9d3d90d9
--- /dev/null
+++ b/pkg/client/injection/informers/sources/v1beta1/kafkasource/filtered/kafkasource.go
@@ -0,0 +1,65 @@
+/*
+Copyright 2020 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by injection-gen. DO NOT EDIT.
+
+package filtered
+
+import (
+	context "context"
+
+	v1beta1 "knative.dev/eventing-kafka/pkg/client/informers/externalversions/sources/v1beta1"
+	filtered "knative.dev/eventing-kafka/pkg/client/injection/informers/factory/filtered"
+	controller "knative.dev/pkg/controller"
+	injection "knative.dev/pkg/injection"
+	logging "knative.dev/pkg/logging"
+)
+
+func init() {
+	injection.Default.RegisterFilteredInformers(withInformer)
+}
+
+// Key is used for associating the Informer inside the context.Context.
+type Key struct {
+	Selector string
+}
+
+func withInformer(ctx context.Context) (context.Context, []controller.Informer) {
+	untyped := ctx.Value(filtered.LabelKey{})
+	if untyped == nil {
+		logging.FromContext(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []controller.Informer{}
+	for _, selector := range labelSelectors {
+		f := filtered.Get(ctx, selector)
+		inf := f.Sources().V1beta1().KafkaSources()
+		ctx = context.WithValue(ctx, Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
+
+// Get extracts the typed informer from the context.
+func Get(ctx context.Context, selector string) v1beta1.KafkaSourceInformer {
+	untyped := ctx.Value(Key{Selector: selector})
+	if untyped == nil {
+		logging.FromContext(ctx).Panicf(
+			"Unable to fetch knative.dev/eventing-kafka/pkg/client/informers/externalversions/sources/v1beta1.KafkaSourceInformer with selector %s from context.", selector)
+	}
+	return untyped.(v1beta1.KafkaSourceInformer)
+}
diff --git a/pkg/client/injection/reconciler/bindings/v1alpha1/kafkabinding/controller.go b/pkg/client/injection/reconciler/bindings/v1alpha1/kafkabinding/controller.go
index 4b28b0157..c842d03b5 100644
--- a/pkg/client/injection/reconciler/bindings/v1alpha1/kafkabinding/controller.go
+++ b/pkg/client/injection/reconciler/bindings/v1alpha1/kafkabinding/controller.go
@@ -24,6 +24,7 @@ import (
 	reflect "reflect"
 	strings "strings"
 
+	zap "go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	labels "k8s.io/apimachinery/pkg/labels"
 	types "k8s.io/apimachinery/pkg/types"
@@ -37,6 +38,7 @@ import (
 	kubeclient "knative.dev/pkg/client/injection/kube/client"
 	controller "knative.dev/pkg/controller"
 	logging "knative.dev/pkg/logging"
+	logkey "knative.dev/pkg/logging/logkey"
 	reconciler "knative.dev/pkg/reconciler"
 )
 
@@ -84,10 +86,16 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF
 		finalizerName: defaultFinalizerName,
 	}
 
-	t := reflect.TypeOf(r).Elem()
-	queueName := fmt.Sprintf("%s.%s", strings.ReplaceAll(t.PkgPath(), "/", "-"), t.Name())
+	ctrType := reflect.TypeOf(r).Elem()
+	ctrTypeName := fmt.Sprintf("%s.%s", ctrType.PkgPath(), ctrType.Name())
+	ctrTypeName = strings.ReplaceAll(ctrTypeName, "/", ".")
 
-	impl := controller.NewImpl(rec, logger, queueName)
+	logger = logger.With(
+		zap.String(logkey.ControllerType, ctrTypeName),
+		zap.String(logkey.Kind, "bindings.knative.dev.KafkaBinding"),
+	)
+
+	impl := controller.NewImpl(rec, logger, ctrTypeName)
 	agentName := defaultControllerAgentName
 
 	// Pass impl to the options. Save any optional results.
diff --git a/pkg/client/injection/reconciler/bindings/v1beta1/kafkabinding/controller.go b/pkg/client/injection/reconciler/bindings/v1beta1/kafkabinding/controller.go
index ec350f6f4..5f8d56992 100644
--- a/pkg/client/injection/reconciler/bindings/v1beta1/kafkabinding/controller.go
+++ b/pkg/client/injection/reconciler/bindings/v1beta1/kafkabinding/controller.go
@@ -24,6 +24,7 @@ import (
 	reflect "reflect"
 	strings "strings"
 
+	zap "go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	labels "k8s.io/apimachinery/pkg/labels"
 	types "k8s.io/apimachinery/pkg/types"
@@ -37,6 +38,7 @@ import (
 	kubeclient "knative.dev/pkg/client/injection/kube/client"
 	controller "knative.dev/pkg/controller"
 	logging "knative.dev/pkg/logging"
+	logkey "knative.dev/pkg/logging/logkey"
 	reconciler "knative.dev/pkg/reconciler"
 )
 
@@ -84,10 +86,16 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF
 		finalizerName: defaultFinalizerName,
 	}
 
-	t := reflect.TypeOf(r).Elem()
-	queueName := fmt.Sprintf("%s.%s", strings.ReplaceAll(t.PkgPath(), "/", "-"), t.Name())
+	ctrType := reflect.TypeOf(r).Elem()
+	ctrTypeName := fmt.Sprintf("%s.%s", ctrType.PkgPath(), ctrType.Name())
+	ctrTypeName = strings.ReplaceAll(ctrTypeName, "/", ".")
 
-	impl := controller.NewImpl(rec, logger, queueName)
+	logger = logger.With(
+		zap.String(logkey.ControllerType, ctrTypeName),
+		zap.String(logkey.Kind, "bindings.knative.dev.KafkaBinding"),
+	)
+
+	impl := controller.NewImpl(rec, logger, ctrTypeName)
 	agentName := defaultControllerAgentName
 
 	// Pass impl to the options. Save any optional results.
diff --git a/pkg/client/injection/reconciler/messaging/v1alpha1/kafkachannel/controller.go b/pkg/client/injection/reconciler/messaging/v1alpha1/kafkachannel/controller.go
index f60d87799..d63dacc3c 100644
--- a/pkg/client/injection/reconciler/messaging/v1alpha1/kafkachannel/controller.go
+++ b/pkg/client/injection/reconciler/messaging/v1alpha1/kafkachannel/controller.go
@@ -24,6 +24,7 @@ import (
 	reflect "reflect"
 	strings "strings"
 
+	zap "go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	labels "k8s.io/apimachinery/pkg/labels"
 	types "k8s.io/apimachinery/pkg/types"
@@ -37,6 +38,7 @@ import (
 	kubeclient "knative.dev/pkg/client/injection/kube/client"
 	controller "knative.dev/pkg/controller"
 	logging "knative.dev/pkg/logging"
+	logkey "knative.dev/pkg/logging/logkey"
 	reconciler "knative.dev/pkg/reconciler"
 )
 
@@ -84,10 +86,16 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF
 		finalizerName: defaultFinalizerName,
 	}
 
-	t := reflect.TypeOf(r).Elem()
-	queueName := fmt.Sprintf("%s.%s", strings.ReplaceAll(t.PkgPath(), "/", "-"), t.Name())
+	ctrType := reflect.TypeOf(r).Elem()
+	ctrTypeName := fmt.Sprintf("%s.%s", ctrType.PkgPath(), ctrType.Name())
+	ctrTypeName = strings.ReplaceAll(ctrTypeName, "/", ".")
 
-	impl := controller.NewImpl(rec, logger, queueName)
+	logger = logger.With(
+		zap.String(logkey.ControllerType, ctrTypeName),
+		zap.String(logkey.Kind, "messaging.knative.dev.KafkaChannel"),
+	)
+
+	impl := controller.NewImpl(rec, logger, ctrTypeName)
 	agentName := defaultControllerAgentName
 
 	// Pass impl to the options. Save any optional results.
diff --git a/pkg/client/injection/reconciler/messaging/v1beta1/kafkachannel/controller.go b/pkg/client/injection/reconciler/messaging/v1beta1/kafkachannel/controller.go
index 8414133f8..9e09a0769 100644
--- a/pkg/client/injection/reconciler/messaging/v1beta1/kafkachannel/controller.go
+++ b/pkg/client/injection/reconciler/messaging/v1beta1/kafkachannel/controller.go
@@ -24,6 +24,7 @@ import (
 	reflect "reflect"
 	strings "strings"
 
+	zap "go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	labels "k8s.io/apimachinery/pkg/labels"
 	types "k8s.io/apimachinery/pkg/types"
@@ -37,6 +38,7 @@ import (
 	kubeclient "knative.dev/pkg/client/injection/kube/client"
 	controller "knative.dev/pkg/controller"
 	logging "knative.dev/pkg/logging"
+	logkey "knative.dev/pkg/logging/logkey"
 	reconciler "knative.dev/pkg/reconciler"
 )
 
@@ -84,10 +86,16 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF
 		finalizerName: defaultFinalizerName,
 	}
 
-	t := reflect.TypeOf(r).Elem()
-	queueName := fmt.Sprintf("%s.%s", strings.ReplaceAll(t.PkgPath(), "/", "-"), t.Name())
+	ctrType := reflect.TypeOf(r).Elem()
+	ctrTypeName := fmt.Sprintf("%s.%s", ctrType.PkgPath(), ctrType.Name())
+	ctrTypeName = strings.ReplaceAll(ctrTypeName, "/", ".")
 
-	impl := controller.NewImpl(rec, logger, queueName)
+	logger = logger.With(
+		zap.String(logkey.ControllerType, ctrTypeName),
+		zap.String(logkey.Kind, "messaging.knative.dev.KafkaChannel"),
+	)
+
+	impl := controller.NewImpl(rec, logger, ctrTypeName)
 	agentName := defaultControllerAgentName
 
 	// Pass impl to the options. Save any optional results.
diff --git a/pkg/client/injection/reconciler/sources/v1alpha1/kafkasource/controller.go b/pkg/client/injection/reconciler/sources/v1alpha1/kafkasource/controller.go
index 98a600f22..bf6184d17 100644
--- a/pkg/client/injection/reconciler/sources/v1alpha1/kafkasource/controller.go
+++ b/pkg/client/injection/reconciler/sources/v1alpha1/kafkasource/controller.go
@@ -24,6 +24,7 @@ import (
 	reflect "reflect"
 	strings "strings"
 
+	zap "go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	labels "k8s.io/apimachinery/pkg/labels"
 	types "k8s.io/apimachinery/pkg/types"
@@ -37,6 +38,7 @@ import (
 	kubeclient "knative.dev/pkg/client/injection/kube/client"
 	controller "knative.dev/pkg/controller"
 	logging "knative.dev/pkg/logging"
+	logkey "knative.dev/pkg/logging/logkey"
 	reconciler "knative.dev/pkg/reconciler"
 )
 
@@ -84,10 +86,16 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF
 		finalizerName: defaultFinalizerName,
 	}
 
-	t := reflect.TypeOf(r).Elem()
-	queueName := fmt.Sprintf("%s.%s", strings.ReplaceAll(t.PkgPath(), "/", "-"), t.Name())
+	ctrType := reflect.TypeOf(r).Elem()
+	ctrTypeName := fmt.Sprintf("%s.%s", ctrType.PkgPath(), ctrType.Name())
+	ctrTypeName = strings.ReplaceAll(ctrTypeName, "/", ".")
 
-	impl := controller.NewImpl(rec, logger, queueName)
+	logger = logger.With(
+		zap.String(logkey.ControllerType, ctrTypeName),
+		zap.String(logkey.Kind, "sources.knative.dev.KafkaSource"),
+	)
+
+	impl := controller.NewImpl(rec, logger, ctrTypeName)
 	agentName := defaultControllerAgentName
 
 	// Pass impl to the options. Save any optional results.
diff --git a/pkg/client/injection/reconciler/sources/v1beta1/kafkasource/controller.go b/pkg/client/injection/reconciler/sources/v1beta1/kafkasource/controller.go
index 3b82ed5e4..d9d60929b 100644
--- a/pkg/client/injection/reconciler/sources/v1beta1/kafkasource/controller.go
+++ b/pkg/client/injection/reconciler/sources/v1beta1/kafkasource/controller.go
@@ -24,6 +24,7 @@ import (
 	reflect "reflect"
 	strings "strings"
 
+	zap "go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	labels "k8s.io/apimachinery/pkg/labels"
 	types "k8s.io/apimachinery/pkg/types"
@@ -37,6 +38,7 @@ import (
 	kubeclient "knative.dev/pkg/client/injection/kube/client"
 	controller "knative.dev/pkg/controller"
 	logging "knative.dev/pkg/logging"
+	logkey "knative.dev/pkg/logging/logkey"
 	reconciler "knative.dev/pkg/reconciler"
 )
 
@@ -84,10 +86,16 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF
 		finalizerName: defaultFinalizerName,
 	}
 
-	t := reflect.TypeOf(r).Elem()
-	queueName := fmt.Sprintf("%s.%s", strings.ReplaceAll(t.PkgPath(), "/", "-"), t.Name())
+	ctrType := reflect.TypeOf(r).Elem()
+	ctrTypeName := fmt.Sprintf("%s.%s", ctrType.PkgPath(), ctrType.Name())
+	ctrTypeName = strings.ReplaceAll(ctrTypeName, "/", ".")
 
-	impl := controller.NewImpl(rec, logger, queueName)
+	logger = logger.With(
+		zap.String(logkey.ControllerType, ctrTypeName),
+		zap.String(logkey.Kind, "sources.knative.dev.KafkaSource"),
+	)
+
+	impl := controller.NewImpl(rec, logger, ctrTypeName)
 	agentName := defaultControllerAgentName
 
 	// Pass impl to the options. Save any optional results.
diff --git a/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go b/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go
index 40f1306d5..68b81d47e 100644
--- a/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go
+++ b/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go
@@ -29,7 +29,7 @@ import (
 	"k8s.io/gengo/namer"
 	"k8s.io/gengo/types"
 
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 // CustomArgs is used tby the go2idl framework to pass args specific to this
diff --git a/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go b/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go
index 9ee7b79f5..5861fcfed 100644
--- a/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go
+++ b/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go
@@ -29,7 +29,7 @@ import (
 	"k8s.io/gengo/namer"
 	"k8s.io/gengo/types"
 
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 // CustomArgs is used tby the go2idl framework to pass args specific to this
diff --git a/vendor/k8s.io/gengo/examples/import-boss/generators/import_restrict.go b/vendor/k8s.io/gengo/examples/import-boss/generators/import_restrict.go
index 308bb6b8d..7232f5e6b 100644
--- a/vendor/k8s.io/gengo/examples/import-boss/generators/import_restrict.go
+++ b/vendor/k8s.io/gengo/examples/import-boss/generators/import_restrict.go
@@ -35,7 +35,7 @@ import (
 	"k8s.io/gengo/types"
 	"sigs.k8s.io/yaml"
 
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 const (
diff --git a/vendor/k8s.io/gengo/examples/set-gen/generators/sets.go b/vendor/k8s.io/gengo/examples/set-gen/generators/sets.go
index 8ddce7e3a..ab9fc7f1e 100644
--- a/vendor/k8s.io/gengo/examples/set-gen/generators/sets.go
+++ b/vendor/k8s.io/gengo/examples/set-gen/generators/sets.go
@@ -25,7 +25,7 @@ import (
 	"k8s.io/gengo/namer"
 	"k8s.io/gengo/types"
 
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 // NameSystems returns the name system used by the generators in this package.
diff --git a/vendor/k8s.io/gengo/examples/set-gen/generators/tags.go b/vendor/k8s.io/gengo/examples/set-gen/generators/tags.go
index bb3b4d257..52e876771 100644
--- a/vendor/k8s.io/gengo/examples/set-gen/generators/tags.go
+++ b/vendor/k8s.io/gengo/examples/set-gen/generators/tags.go
@@ -18,7 +18,7 @@ package generators
 
 import (
 	"k8s.io/gengo/types"
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 // extractBoolTagOrDie gets the comment-tags for the key and asserts that, if
diff --git a/vendor/k8s.io/gengo/generator/execute.go b/vendor/k8s.io/gengo/generator/execute.go
index d1b12258c..e489fd3f0 100644
--- a/vendor/k8s.io/gengo/generator/execute.go
+++ b/vendor/k8s.io/gengo/generator/execute.go
@@ -29,7 +29,7 @@ import (
 	"k8s.io/gengo/namer"
 	"k8s.io/gengo/types"
 
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 func errs2strings(errors []error) []string {
diff --git a/vendor/k8s.io/gengo/generator/import_tracker.go b/vendor/k8s.io/gengo/generator/import_tracker.go
index 5d87de4ff..60c899ac4 100644
--- a/vendor/k8s.io/gengo/generator/import_tracker.go
+++ b/vendor/k8s.io/gengo/generator/import_tracker.go
@@ -20,7 +20,7 @@ import (
 	"go/token"
 	"strings"
 
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 
 	"k8s.io/gengo/namer"
 	"k8s.io/gengo/types"
diff --git a/vendor/k8s.io/gengo/parser/parse.go b/vendor/k8s.io/gengo/parser/parse.go
index f3abe57cc..497f4615b 100644
--- a/vendor/k8s.io/gengo/parser/parse.go
+++ b/vendor/k8s.io/gengo/parser/parse.go
@@ -33,7 +33,7 @@ import (
 	"strings"
 
 	"k8s.io/gengo/types"
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 // This clarifies when a pkg path has been canonicalized.
@@ -589,7 +589,7 @@ func (b *Builder) importWithMode(dir string, mode build.ImportMode) (*build.Pack
 	if err != nil {
 		return nil, fmt.Errorf("unable to get current directory: %v", err)
 	}
-	buildPkg, err := b.context.Import(dir, cwd, mode)
+	buildPkg, err := b.context.Import(filepath.ToSlash(dir), cwd, mode)
 	if err != nil {
 		return nil, err
 	}
@@ -763,7 +763,8 @@ func (b *Builder) walkType(u types.Universe, useName *types.Name, in tc.Type) *t
 				out.Methods = map[string]*types.Type{}
 			}
 			method := t.Method(i)
-			mt := b.walkType(u, nil, method.Type())
+			name := tcNameToName(method.String())
+			mt := b.walkType(u, &name, method.Type())
 			mt.CommentLines = splitLines(b.priorCommentLines(method.Pos(), 1).Text())
 			out.Methods[method.Name()] = mt
 		}
@@ -798,7 +799,8 @@ func (b *Builder) walkType(u types.Universe, useName *types.Name, in tc.Type) *t
 					out.Methods = map[string]*types.Type{}
 				}
 				method := t.Method(i)
-				mt := b.walkType(u, nil, method.Type())
+				name := tcNameToName(method.String())
+				mt := b.walkType(u, &name, method.Type())
 				mt.CommentLines = splitLines(b.priorCommentLines(method.Pos(), 1).Text())
 				out.Methods[method.Name()] = mt
 			}
diff --git a/vendor/knative.dev/eventing/pkg/apis/messaging/v1/channel_template_types.go b/vendor/knative.dev/eventing/pkg/apis/messaging/v1/channel_template_types.go
index 6ef23d809..ffa0f4195 100644
--- a/vendor/knative.dev/eventing/pkg/apis/messaging/v1/channel_template_types.go
+++ b/vendor/knative.dev/eventing/pkg/apis/messaging/v1/channel_template_types.go
@@ -17,13 +17,8 @@ limitations under the License.
 package v1
 
 import (
-	"encoding/json"
-
-	"k8s.io/apimachinery/pkg/api/equality"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
-
-	v1 "knative.dev/eventing/pkg/apis/duck/v1"
 )
 
 // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
@@ -35,77 +30,3 @@ type ChannelTemplateSpec struct {
 	// +optional
 	Spec *runtime.RawExtension `json:"spec,omitempty"`
 }
-
-// ChannelTemplateSpecInternal is an internal only version that includes ObjectMeta so that
-// we can easily create new Channels off of it.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type ChannelTemplateSpecInternal struct {
-	metav1.TypeMeta `json:",inline"`
-
-	// +optional
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	// Spec includes the Channel CR ChannelableSpec and the physical channel spec.
-	// In order to create a new ChannelTemplateSpecInternalSpec, you must use NewChannelTemplateSpecInternalSpec
-	Spec *ChannelTemplateSpecInternalSpec `json:"spec,omitempty"`
-}
-
-// ChannelTemplateSpecInternalSpec merges the "general" spec from Channel CR and the template of the physical channel spec.
-// Note that this struct properly implements only Marshalling, unmarshalling doesn't work!
-type ChannelTemplateSpecInternalSpec struct {
-	// ChannelableSpec includes the fields from the Channel Spec section
-	v1.ChannelableSpec
-
-	// PhysicalChannelSpec includes the fields from the physical channel Spec. Passed
-	// in verbatim to the Channel CRD as Spec section.
-	// +optional
-	PhysicalChannelSpec *runtime.RawExtension
-}
-
-// NewChannelTemplateSpecInternalSpec creates a new ChannelTemplateSpecInternalSpec, returning nil if channelableSpec is empty and physicalChannelSpec is nil.
-func NewChannelTemplateSpecInternalSpec(channelableSpec v1.ChannelableSpec, physicalChannelSpec *runtime.RawExtension) *ChannelTemplateSpecInternalSpec {
-	if physicalChannelSpec == nil && equality.Semantic.DeepEqual(channelableSpec, v1.ChannelableSpec{}) {
-		return nil
-	}
-	return &ChannelTemplateSpecInternalSpec{
-		ChannelableSpec:     channelableSpec,
-		PhysicalChannelSpec: physicalChannelSpec,
-	}
-}
-
-func (s ChannelTemplateSpecInternalSpec) MarshalJSON() ([]byte, error) {
-	// Check if empty
-	if s.PhysicalChannelSpec == nil && equality.Semantic.DeepEqual(s.ChannelableSpec, v1.ChannelableSpec{}) {
-		return []byte{}, nil
-	}
-
-	// Let's merge the channel template spec and the channelable spec from channel
-	channelableSpec := make(map[string]interface{})
-	physicalChannelTemplateSpec := make(map[string]interface{})
-
-	rawChannelSpec, err := json.Marshal(s.ChannelableSpec)
-	if err != nil {
-		return nil, err
-	}
-	if err := json.Unmarshal(rawChannelSpec, &channelableSpec); err != nil {
-		return nil, err
-	}
-
-	if s.PhysicalChannelSpec != nil {
-		rawPhysicalChannelTemplateSpec, err := json.Marshal(s.PhysicalChannelSpec)
-		if err != nil {
-			return nil, err
-		}
-		if err := json.Unmarshal(rawPhysicalChannelTemplateSpec, &physicalChannelTemplateSpec); err != nil {
-			return nil, err
-		}
-	}
-
-	// Merge the two maps into channelableSpec
-	for k, v := range physicalChannelTemplateSpec {
-		channelableSpec[k] = v
-	}
-
-	// Just return the merged map marshalled
-	return json.Marshal(channelableSpec)
-}
diff --git a/vendor/knative.dev/eventing/pkg/apis/messaging/v1/zz_generated.deepcopy.go b/vendor/knative.dev/eventing/pkg/apis/messaging/v1/zz_generated.deepcopy.go
index 90d160a32..0bdfc4e75 100644
--- a/vendor/knative.dev/eventing/pkg/apis/messaging/v1/zz_generated.deepcopy.go
+++ b/vendor/knative.dev/eventing/pkg/apis/messaging/v1/zz_generated.deepcopy.go
@@ -162,59 +162,6 @@ func (in *ChannelTemplateSpec) DeepCopyObject() runtime.Object {
 	return nil
 }
 
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *ChannelTemplateSpecInternal) DeepCopyInto(out *ChannelTemplateSpecInternal) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
-	if in.Spec != nil {
-		in, out := &in.Spec, &out.Spec
-		*out = new(ChannelTemplateSpecInternalSpec)
-		(*in).DeepCopyInto(*out)
-	}
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ChannelTemplateSpecInternal.
-func (in *ChannelTemplateSpecInternal) DeepCopy() *ChannelTemplateSpecInternal {
-	if in == nil {
-		return nil
-	}
-	out := new(ChannelTemplateSpecInternal)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *ChannelTemplateSpecInternal) DeepCopyObject() runtime.Object {
-	if c := in.DeepCopy(); c != nil {
-		return c
-	}
-	return nil
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *ChannelTemplateSpecInternalSpec) DeepCopyInto(out *ChannelTemplateSpecInternalSpec) {
-	*out = *in
-	in.ChannelableSpec.DeepCopyInto(&out.ChannelableSpec)
-	if in.PhysicalChannelSpec != nil {
-		in, out := &in.PhysicalChannelSpec, &out.PhysicalChannelSpec
-		*out = new(runtime.RawExtension)
-		(*in).DeepCopyInto(*out)
-	}
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ChannelTemplateSpecInternalSpec.
-func (in *ChannelTemplateSpecInternalSpec) DeepCopy() *ChannelTemplateSpecInternalSpec {
-	if in == nil {
-		return nil
-	}
-	out := new(ChannelTemplateSpecInternalSpec)
-	in.DeepCopyInto(out)
-	return out
-}
-
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *InMemoryChannel) DeepCopyInto(out *InMemoryChannel) {
 	*out = *in
diff --git a/vendor/knative.dev/eventing/pkg/apis/messaging/v1beta1/channel_template_types.go b/vendor/knative.dev/eventing/pkg/apis/messaging/v1beta1/channel_template_types.go
index 02a5581b1..699fc40c2 100644
--- a/vendor/knative.dev/eventing/pkg/apis/messaging/v1beta1/channel_template_types.go
+++ b/vendor/knative.dev/eventing/pkg/apis/messaging/v1beta1/channel_template_types.go
@@ -30,18 +30,3 @@ type ChannelTemplateSpec struct {
 	// +optional
 	Spec *runtime.RawExtension `json:"spec,omitempty"`
 }
-
-// ChannelTemplateSpecInternal is an internal only version that includes ObjectMeta so that
-// we can easily create new Channels off of it.
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-type ChannelTemplateSpecInternal struct {
-	metav1.TypeMeta `json:",inline"`
-
-	// +optional
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	// Spec defines the Spec to use for each channel created. Passed
-	// in verbatim to the Channel CRD as Spec section.
-	// +optional
-	Spec *runtime.RawExtension `json:"spec,omitempty"`
-}
diff --git a/vendor/knative.dev/eventing/pkg/apis/messaging/v1beta1/zz_generated.deepcopy.go b/vendor/knative.dev/eventing/pkg/apis/messaging/v1beta1/zz_generated.deepcopy.go
index 8d4631b7f..df2dcad7f 100644
--- a/vendor/knative.dev/eventing/pkg/apis/messaging/v1beta1/zz_generated.deepcopy.go
+++ b/vendor/knative.dev/eventing/pkg/apis/messaging/v1beta1/zz_generated.deepcopy.go
@@ -162,37 +162,6 @@ func (in *ChannelTemplateSpec) DeepCopyObject() runtime.Object {
 	return nil
 }
 
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *ChannelTemplateSpecInternal) DeepCopyInto(out *ChannelTemplateSpecInternal) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
-	if in.Spec != nil {
-		in, out := &in.Spec, &out.Spec
-		*out = new(runtime.RawExtension)
-		(*in).DeepCopyInto(*out)
-	}
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ChannelTemplateSpecInternal.
-func (in *ChannelTemplateSpecInternal) DeepCopy() *ChannelTemplateSpecInternal {
-	if in == nil {
-		return nil
-	}
-	out := new(ChannelTemplateSpecInternal)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *ChannelTemplateSpecInternal) DeepCopyObject() runtime.Object {
-	if c := in.DeepCopy(); c != nil {
-		return c
-	}
-	return nil
-}
-
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *InMemoryChannel) DeepCopyInto(out *InMemoryChannel) {
 	*out = *in
diff --git a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/controller.go b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/controller.go
index eafcd40a4..74dea84cd 100644
--- a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/controller.go
+++ b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/controller.go
@@ -24,6 +24,7 @@ import (
 	reflect "reflect"
 	strings "strings"
 
+	zap "go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	labels "k8s.io/apimachinery/pkg/labels"
 	types "k8s.io/apimachinery/pkg/types"
@@ -37,6 +38,7 @@ import (
 	kubeclient "knative.dev/pkg/client/injection/kube/client"
 	controller "knative.dev/pkg/controller"
 	logging "knative.dev/pkg/logging"
+	logkey "knative.dev/pkg/logging/logkey"
 	reconciler "knative.dev/pkg/reconciler"
 )
 
@@ -88,10 +90,16 @@ func NewImpl(ctx context.Context, r Interface, classValue string, optionsFns ...
 		classValue:    classValue,
 	}
 
-	t := reflect.TypeOf(r).Elem()
-	queueName := fmt.Sprintf("%s.%s", strings.ReplaceAll(t.PkgPath(), "/", "-"), t.Name())
+	ctrType := reflect.TypeOf(r).Elem()
+	ctrTypeName := fmt.Sprintf("%s.%s", ctrType.PkgPath(), ctrType.Name())
+	ctrTypeName = strings.ReplaceAll(ctrTypeName, "/", ".")
 
-	impl := controller.NewImpl(rec, logger, queueName)
+	logger = logger.With(
+		zap.String(logkey.ControllerType, ctrTypeName),
+		zap.String(logkey.Kind, "eventing.knative.dev.Broker"),
+	)
+
+	impl := controller.NewImpl(rec, logger, ctrTypeName)
 	agentName := defaultControllerAgentName
 
 	// Pass impl to the options. Save any optional results.
diff --git a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/reconciler.go b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/reconciler.go
index 0dd556f70..4b777b492 100644
--- a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/reconciler.go
+++ b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/reconciler.go
@@ -195,7 +195,7 @@ func (r *reconcilerImpl) Reconcile(ctx context.Context, key string) error {
 	// If we are not the leader, and we don't implement either ReadOnly
 	// observer interfaces, then take a fast-path out.
 	if s.isNotLeaderNorObserver() {
-		return nil
+		return controller.NewSkipKey(key)
 	}
 
 	// If configStore is set, attach the frozen configuration to the context.
diff --git a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1beta1/broker/controller.go b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1beta1/broker/controller.go
index 1a521f093..19a4a4454 100644
--- a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1beta1/broker/controller.go
+++ b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1beta1/broker/controller.go
@@ -24,6 +24,7 @@ import (
 	reflect "reflect"
 	strings "strings"
 
+	zap "go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	labels "k8s.io/apimachinery/pkg/labels"
 	types "k8s.io/apimachinery/pkg/types"
@@ -37,6 +38,7 @@ import (
 	kubeclient "knative.dev/pkg/client/injection/kube/client"
 	controller "knative.dev/pkg/controller"
 	logging "knative.dev/pkg/logging"
+	logkey "knative.dev/pkg/logging/logkey"
 	reconciler "knative.dev/pkg/reconciler"
 )
 
@@ -88,10 +90,16 @@ func NewImpl(ctx context.Context, r Interface, classValue string, optionsFns ...
 		classValue:    classValue,
 	}
 
-	t := reflect.TypeOf(r).Elem()
-	queueName := fmt.Sprintf("%s.%s", strings.ReplaceAll(t.PkgPath(), "/", "-"), t.Name())
+	ctrType := reflect.TypeOf(r).Elem()
+	ctrTypeName := fmt.Sprintf("%s.%s", ctrType.PkgPath(), ctrType.Name())
+	ctrTypeName = strings.ReplaceAll(ctrTypeName, "/", ".")
 
-	impl := controller.NewImpl(rec, logger, queueName)
+	logger = logger.With(
+		zap.String(logkey.ControllerType, ctrTypeName),
+		zap.String(logkey.Kind, "eventing.knative.dev.Broker"),
+	)
+
+	impl := controller.NewImpl(rec, logger, ctrTypeName)
 	agentName := defaultControllerAgentName
 
 	// Pass impl to the options. Save any optional results.
diff --git a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1beta1/broker/reconciler.go b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1beta1/broker/reconciler.go
index e13d2d663..164866f22 100644
--- a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1beta1/broker/reconciler.go
+++ b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1beta1/broker/reconciler.go
@@ -195,7 +195,7 @@ func (r *reconcilerImpl) Reconcile(ctx context.Context, key string) error {
 	// If we are not the leader, and we don't implement either ReadOnly
 	// observer interfaces, then take a fast-path out.
 	if s.isNotLeaderNorObserver() {
-		return nil
+		return controller.NewSkipKey(key)
 	}
 
 	// If configStore is set, attach the frozen configuration to the context.
diff --git a/vendor/knative.dev/eventing/pkg/duck/channel.go b/vendor/knative.dev/eventing/pkg/duck/channel.go
new file mode 100644
index 000000000..4c4604cd5
--- /dev/null
+++ b/vendor/knative.dev/eventing/pkg/duck/channel.go
@@ -0,0 +1,165 @@
+/*
+Copyright 2021 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package duck
+
+import (
+	"encoding/json"
+
+	"k8s.io/apimachinery/pkg/api/equality"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+
+	duckv1 "knative.dev/eventing/pkg/apis/duck/v1"
+)
+
+// channelTemplateSpecInternal is an internal only version that includes ObjectMeta so that
+// we can easily create new Channels off of it.
+type channelTemplateSpecInternal struct {
+	metav1.TypeMeta `json:",inline"`
+
+	// +optional
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	// Spec includes the Channel CR ChannelableSpec and the physical channel spec.
+	// In order to create a new channelTemplateSpecInternalSpec, you must use NewChannelTemplateSpecInternalSpec
+	// +optional
+	Spec *channelTemplateSpecInternalSpec `json:"spec,omitempty"`
+}
+
+// channelTemplateSpecInternalSpec merges the "general" spec from Channel CR and the template of the physical channel spec.
+// Note that this struct properly implements only Marshalling, unmarshalling doesn't work!
+type channelTemplateSpecInternalSpec struct {
+	// channelableSpec includes the fields from the Channel Spec section
+	channelableSpec *duckv1.ChannelableSpec
+
+	// physicalChannelSpec includes the fields from the physical channel Spec. Passed
+	// in verbatim to the Channel CRD as Spec section.
+	// +optional
+	physicalChannelSpec *runtime.RawExtension
+}
+
+func (s *channelTemplateSpecInternalSpec) MarshalJSON() ([]byte, error) {
+	// Let's merge the channel template spec and the channelable spec from channel
+	channelableSpec := make(map[string]interface{})
+	physicalChannelTemplateSpec := make(map[string]interface{})
+
+	var cs duckv1.ChannelableSpec
+	if s.channelableSpec != nil {
+		cs = *s.channelableSpec
+	} else {
+		cs = duckv1.ChannelableSpec{}
+	}
+
+	rawChannelSpec, err := json.Marshal(cs)
+	if err != nil {
+		return nil, err
+	}
+	if err := json.Unmarshal(rawChannelSpec, &channelableSpec); err != nil {
+		return nil, err
+	}
+
+	if s.physicalChannelSpec != nil {
+		rawPhysicalChannelTemplateSpec, err := json.Marshal(s.physicalChannelSpec)
+		if err != nil {
+			return nil, err
+		}
+		if err := json.Unmarshal(rawPhysicalChannelTemplateSpec, &physicalChannelTemplateSpec); err != nil {
+			return nil, err
+		}
+	}
+
+	// Merge the two maps into channelableSpec
+	for k, v := range physicalChannelTemplateSpec {
+		channelableSpec[k] = v
+	}
+
+	// Just return the merged map marshalled
+	return json.Marshal(channelableSpec)
+}
+
+// PhysicalChannelOption represents an option for NewPhysicalChannel.
+type PhysicalChannelOption func(*channelTemplateSpecInternal)
+
+// WithChannelableSpec sets the ChannelableSpec of the physical channel.
+func WithChannelableSpec(channelableSpec duckv1.ChannelableSpec) PhysicalChannelOption {
+	return func(internal *channelTemplateSpecInternal) {
+		if equality.Semantic.DeepEqual(channelableSpec, duckv1.ChannelableSpec{}) {
+			// No need to set it
+			return
+		}
+		if internal.Spec == nil {
+			internal.Spec = &channelTemplateSpecInternalSpec{}
+		}
+		internal.Spec.channelableSpec = &channelableSpec
+	}
+}
+
+// WithPhysicalChannelSpec sets the ChannelableSpec of the physical channel.
+func WithPhysicalChannelSpec(physicalChannelSpec *runtime.RawExtension) PhysicalChannelOption {
+	return func(internal *channelTemplateSpecInternal) {
+		if physicalChannelSpec == nil {
+			// No need to set it
+			return
+		}
+		if internal.Spec == nil {
+			internal.Spec = &channelTemplateSpecInternalSpec{}
+		}
+		internal.Spec.physicalChannelSpec = physicalChannelSpec
+	}
+}
+
+// NewPhysicalChannel returns a new physical channel as unstructured.Unstructured, starting from the provided meta and ducks.
+// When developing components that needs to spawn underlying (physical) channels (e.g. the Channel type, brokers backed by channels, parallel, sequence)
+// you should use this function to create the underlying channels.
+// Any physical channel CRD is composed by TypeMeta, ObjectMeta and a Spec, which includes
+// a ChannelableSpec and optionally additional fields (e.g. like KafkaChannel includes partitionCount).
+// You can set the ChannelableSpec using WithChannelableSpec and you can set all the additional fields using WithPhysicalChannelSpec
+// This function returns the channel with the provided TypeMeta and ObjectMeta and with the additional provided options.
+//
+// For example, providing the TypeMeta of an InMemoryChannel and a ChannelableSpec with delivery configured, the return value will look like:
+//
+// apiVersion: messaging.knative.dev/v1
+// kind: InMemoryChannel
+// metadata:
+//   name: "hello"
+//   namespace: "world"
+// spec:
+//   delivery:
+//     retry: 3
+func NewPhysicalChannel(typeMeta metav1.TypeMeta, objMeta metav1.ObjectMeta, opts ...PhysicalChannelOption) (*unstructured.Unstructured, error) {
+	// Set the name of the resource we're creating as well as the namespace, etc.
+	template := channelTemplateSpecInternal{
+		TypeMeta:   typeMeta,
+		ObjectMeta: objMeta,
+	}
+
+	for _, opt := range opts {
+		opt(&template)
+	}
+
+	raw, err := json.Marshal(template)
+	if err != nil {
+		return nil, err
+	}
+	u := &unstructured.Unstructured{}
+	err = json.Unmarshal(raw, u)
+	if err != nil {
+		return nil, err
+	}
+	return u, nil
+}
diff --git a/vendor/knative.dev/eventing/pkg/duck/listable.go b/vendor/knative.dev/eventing/pkg/duck/listable.go
new file mode 100644
index 000000000..95bea2d68
--- /dev/null
+++ b/vendor/knative.dev/eventing/pkg/duck/listable.go
@@ -0,0 +1,203 @@
+/*
+Copyright 2019 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package duck
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/pkg/errors"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/tools/cache"
+	"knative.dev/pkg/apis/duck"
+	duckv1 "knative.dev/pkg/apis/duck/v1"
+	"knative.dev/pkg/controller"
+	"knative.dev/pkg/tracker"
+)
+
+// ListableTracker is a tracker capable of tracking any object that implements the apis.Listable interface.
+type ListableTracker interface {
+	// TrackInNamespace returns a function that can be used to watch arbitrary apis.Listable resources in the same
+	// namespace as obj. Any change will cause a callback for obj.
+	TrackInNamespace(ctx context.Context, obj metav1.Object) Track
+	// TrackInNamespaceKReference returns a function that can be used to watch arbitrary apis.Listable resources
+	// in the same namespace as obj. Any change will cause a callback for obj.
+	TrackInNamespaceKReference(ctx context.Context, obj metav1.Object) TrackKReference
+	// ListerFor returns the lister for the object reference. It returns an error if the lister does not exist.
+	ListerFor(ref corev1.ObjectReference) (cache.GenericLister, error)
+	// InformerFor returns the informer for the object reference. It returns an error if the informer does not exist.
+	InformerFor(ref corev1.ObjectReference) (cache.SharedIndexInformer, error)
+	// ListerFor returns the lister for the KReference. It returns an error if the lister does not exist.
+	ListerForKReference(ref duckv1.KReference) (cache.GenericLister, error)
+	// InformerFor returns the informer for the KReference. It returns an error if the informer does not exist.
+	InformerForKReference(ref duckv1.KReference) (cache.SharedIndexInformer, error)
+}
+
+type Track func(corev1.ObjectReference) error
+type TrackKReference func(duckv1.KReference) error
+
+// NewListableTracker creates a new ListableTracker, backed by a TypedInformerFactory.
+func NewListableTracker(ctx context.Context, getter func(context.Context) duck.InformerFactory, callback func(types.NamespacedName), lease time.Duration) ListableTracker {
+	return &listableTracker{
+		informerFactory: getter(ctx),
+		tracker:         tracker.New(callback, lease),
+		concrete:        map[schema.GroupVersionResource]informerListerPair{},
+	}
+}
+
+type listableTracker struct {
+	informerFactory duck.InformerFactory
+	tracker         tracker.Interface
+
+	concrete     map[schema.GroupVersionResource]informerListerPair
+	concreteLock sync.RWMutex
+}
+
+type informerListerPair struct {
+	informer cache.SharedIndexInformer
+	lister   cache.GenericLister
+}
+
+// ensureTracking ensures that there is an informer watching and sending events to tracker for the
+// concrete GVK. It also ensures that there is the corresponding lister for that informer.
+func (t *listableTracker) ensureTracking(ctx context.Context, ref corev1.ObjectReference) error {
+	if equality.Semantic.DeepEqual(ref, &corev1.ObjectReference{}) {
+		return errors.New("cannot track empty object ref")
+	}
+	gvk := ref.GroupVersionKind()
+	gvr, _ := meta.UnsafeGuessKindToResource(gvk)
+
+	t.concreteLock.RLock()
+	_, present := t.concrete[gvr]
+	t.concreteLock.RUnlock()
+	if present {
+		// There is already an informer running for this GVR, we don't need or want to make
+		// a second one.
+		return nil
+	}
+	// Tracking has not been setup for this GVR.
+	t.concreteLock.Lock()
+	defer t.concreteLock.Unlock()
+	// Now that we have acquired the write lock, make sure no one has added tracking handlers.
+	if _, present = t.concrete[gvr]; present {
+		return nil
+	}
+	informer, lister, err := t.informerFactory.Get(ctx, gvr)
+	if err != nil {
+		return err
+	}
+	informer.AddEventHandler(controller.HandleAll(
+		// Call the tracker's OnChanged method, but we've seen the objects coming through
+		// this path missing TypeMeta, so ensure it is properly populated.
+		controller.EnsureTypeMeta(
+			t.tracker.OnChanged,
+			gvk,
+		),
+	))
+	t.concrete[gvr] = informerListerPair{informer: informer, lister: lister}
+	return nil
+}
+
+// TrackInNamespace satisfies the ListableTracker interface.
+func (t *listableTracker) TrackInNamespace(ctx context.Context, obj metav1.Object) Track {
+	return func(ref corev1.ObjectReference) error {
+		// This is often used by Trigger and Subscription, both of which pass in refs that do not
+		// specify the namespace.
+		ref.Namespace = obj.GetNamespace()
+		if err := t.ensureTracking(ctx, ref); err != nil {
+			return err
+		}
+
+		return t.tracker.TrackReference(tracker.Reference{
+			APIVersion: ref.APIVersion,
+			Kind:       ref.Kind,
+			Namespace:  obj.GetNamespace(),
+			Name:       ref.Name,
+		}, obj)
+	}
+}
+
+// TrackInNamespaceKReference satisfies the ListableTracker interface.
+func (t *listableTracker) TrackInNamespaceKReference(ctx context.Context, obj metav1.Object) TrackKReference {
+	return func(ref duckv1.KReference) error {
+		// This is often used by Trigger and Subscription, both of which pass in refs that do not
+		// specify the namespace.
+		ref.Namespace = obj.GetNamespace()
+		coreRef := corev1.ObjectReference{APIVersion: ref.APIVersion, Kind: ref.Kind, Name: ref.Name, Namespace: ref.Namespace}
+		if err := t.ensureTracking(ctx, coreRef); err != nil {
+			return err
+		}
+
+		return t.tracker.TrackReference(tracker.Reference{
+			APIVersion: ref.APIVersion,
+			Kind:       ref.Kind,
+			Namespace:  obj.GetNamespace(),
+			Name:       ref.Name,
+		}, obj)
+	}
+}
+
+// ListerForKReference satisfies the ListableTracker interface.
+func (t *listableTracker) ListerForKReference(ref duckv1.KReference) (cache.GenericLister, error) {
+	return t.ListerFor(corev1.ObjectReference{APIVersion: ref.APIVersion, Kind: ref.Kind, Name: ref.Name, Namespace: ref.Namespace})
+}
+
+// ListerFor satisfies the ListableTracker interface.
+func (t *listableTracker) ListerFor(ref corev1.ObjectReference) (cache.GenericLister, error) {
+	if equality.Semantic.DeepEqual(ref, &corev1.ObjectReference{}) {
+		return nil, errors.New("cannot get lister for empty object ref")
+	}
+	gvk := ref.GroupVersionKind()
+	gvr, _ := meta.UnsafeGuessKindToResource(gvk)
+
+	t.concreteLock.RLock()
+	defer t.concreteLock.RUnlock()
+	informerListerPair, present := t.concrete[gvr]
+	if !present {
+		return nil, fmt.Errorf("no lister available for GVR %s", gvr.String())
+	}
+	return informerListerPair.lister, nil
+}
+
+// InformerForKReference satisfies the ListableTracker interface.
+func (t *listableTracker) InformerForKReference(ref duckv1.KReference) (cache.SharedIndexInformer, error) {
+	return t.InformerFor(corev1.ObjectReference{APIVersion: ref.APIVersion, Kind: ref.Kind, Name: ref.Name, Namespace: ref.Namespace})
+}
+
+// InformerFor satisfies the ListableTracker interface.
+func (t *listableTracker) InformerFor(ref corev1.ObjectReference) (cache.SharedIndexInformer, error) {
+	if equality.Semantic.DeepEqual(ref, &corev1.ObjectReference{}) {
+		return nil, errors.New("cannot get informer for empty object ref")
+	}
+	gvk := ref.GroupVersionKind()
+	gvr, _ := meta.UnsafeGuessKindToResource(gvk)
+
+	t.concreteLock.RLock()
+	defer t.concreteLock.RUnlock()
+	informerListerPair, present := t.concrete[gvr]
+	if !present {
+		return nil, fmt.Errorf("no informer available for GVR %s", gvr.String())
+	}
+	return informerListerPair.informer, nil
+}
diff --git a/vendor/knative.dev/eventing/pkg/duck/subscriber.go b/vendor/knative.dev/eventing/pkg/duck/subscriber.go
new file mode 100644
index 000000000..8b7c2a91f
--- /dev/null
+++ b/vendor/knative.dev/eventing/pkg/duck/subscriber.go
@@ -0,0 +1,64 @@
+/*
+Copyright 2019 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package duck
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+
+	"go.uber.org/zap"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/dynamic"
+
+	duckapis "knative.dev/pkg/apis"
+	"knative.dev/pkg/logging"
+)
+
+// DomainToURL converts a domain into an HTTP URL.
+func DomainToURL(domain string) string {
+	u := url.URL{
+		Scheme: "http",
+		Host:   domain,
+		Path:   "/",
+	}
+	return u.String()
+}
+
+// ResourceInterface creates a resource interface for the given ObjectReference.
+func ResourceInterface(dynamicClient dynamic.Interface, namespace string, gvk schema.GroupVersionKind) (dynamic.ResourceInterface, error) {
+	rc := dynamicClient.Resource(duckapis.KindToResource(gvk))
+
+	if rc == nil {
+		return nil, fmt.Errorf("failed to create dynamic client resource")
+	}
+	return rc.Namespace(namespace), nil
+}
+
+// ObjectReference resolves an object based on an ObjectReference.
+func ObjectReference(ctx context.Context, dynamicClient dynamic.Interface, namespace string, ref *corev1.ObjectReference) (json.Marshaler, error) {
+	resourceClient, err := ResourceInterface(dynamicClient, namespace, ref.GroupVersionKind())
+	if err != nil {
+		logging.FromContext(ctx).Warnw("Failed to create dynamic resource client", zap.Error(err))
+		return nil, err
+	}
+
+	return resourceClient.Get(ctx, ref.Name, metav1.GetOptions{})
+}
diff --git a/vendor/knative.dev/hack/library.sh b/vendor/knative.dev/hack/library.sh
index aad6d47a9..cf56962a8 100644
--- a/vendor/knative.dev/hack/library.sh
+++ b/vendor/knative.dev/hack/library.sh
@@ -794,11 +794,32 @@ function shellcheck_new_files() {
 }
 
 function latest_version() {
-  local semver=$(git describe --match "v[0-9]*" --abbrev=0)
-  local major_minor=$(echo "$semver" | cut -d. -f1-2)
+  # This function works "best effort" and works on Prow but not necessarily locally.
+  # The problem is finding the latest release. If a release occurs on the same commit which
+  # was branched from master, then the tag will be an ancestor to any commit derived from master.
+  # That was the original logic. Additionally in a release branch, the tag is always an ancestor.
+  # However, if the release commit ends up not the first commit from master, then the tag is not
+  # an ancestor of master, so we can't use `git describe` to find the most recent versioned tag. So
+  # we just sort all the tags and find the newest versioned one.
+  # But when running locally, we cannot(?) know if the current branch is a fork of master or a fork
+  # of a release branch. That's where this function will malfunction when the last release did not
+  # occur on the first commit -- it will try to run the upgrade tests from an older version instead
+  # of the most recent release.
+  # Workarounds include:
+  # Tag the first commit of the release branch. Say release-0.75 released v0.75.0 from the second commit
+  # Then tag the first commit in common between master and release-0.75 with `v0.75`.
+  # Always name your local fork master or main.
+  if [ $(current_branch) = "master" ] || [ $(current_branch) = "main" ]; then
+    # For main branch, simply use git tag without major version, this will work even
+    # if the release tag is not in the main
+    git tag -l "v[0-9]*" | sort -r --version-sort | head -n1
+  else
+    local semver=$(git describe --match "v[0-9]*" --abbrev=0)
+    local major_minor=$(echo "$semver" | cut -d. -f1-2)
 
-  # Get the latest patch release for the major minor
-  git tag -l "${major_minor}*" | sort -r --version-sort | head -n1
+    # Get the latest patch release for the major minor
+    git tag -l "${major_minor}*" | sort -r --version-sort | head -n1
+  fi
 }
 
 # Initializations that depend on previous functions.
diff --git a/vendor/knative.dev/pkg/apis/duck/ABOUT.md b/vendor/knative.dev/pkg/apis/duck/ABOUT.md
index 0c6edabde..98ffc9424 100644
--- a/vendor/knative.dev/pkg/apis/duck/ABOUT.md
+++ b/vendor/knative.dev/pkg/apis/duck/ABOUT.md
@@ -301,7 +301,8 @@ is used with duck types:
                 Base:             reconciler.NewBase(opt, controllerAgentName),
                 ...
         }
-        impl := controller.NewImpl(c, c.Logger, "Revisions")
+        logger := c.Logger.Named("Revisions")
+        impl := controller.NewImpl(c, logger, "Revisions")
 
         // Calls to Track create a 30 minute lease before they must be renewed.
         // Coordinate this value with controller resync periods.
diff --git a/vendor/knative.dev/pkg/apis/duck/v1/addressable_types.go b/vendor/knative.dev/pkg/apis/duck/v1/addressable_types.go
index db39ab862..83e746a00 100644
--- a/vendor/knative.dev/pkg/apis/duck/v1/addressable_types.go
+++ b/vendor/knative.dev/pkg/apis/duck/v1/addressable_types.go
@@ -22,9 +22,11 @@ import (
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 
 	"knative.dev/pkg/apis"
 	"knative.dev/pkg/apis/duck/ducktypes"
+	"knative.dev/pkg/kmeta"
 )
 
 // +genduck
@@ -67,6 +69,7 @@ type AddressStatus struct {
 var (
 	_ apis.Listable         = (*AddressableType)(nil)
 	_ ducktypes.Populatable = (*AddressableType)(nil)
+	_ kmeta.OwnerRefable    = (*AddressableType)(nil)
 )
 
 // GetFullType implements duck.Implementable
@@ -97,6 +100,11 @@ func (t *AddressableType) Populate() {
 	}
 }
 
+// GetGroupVersionKind implements kmeta.OwnerRefable
+func (t *AddressableType) GetGroupVersionKind() schema.GroupVersionKind {
+	return t.GroupVersionKind()
+}
+
 // GetListType implements apis.Listable
 func (*AddressableType) GetListType() runtime.Object {
 	return &AddressableTypeList{}
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fakeclient.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_client.go
similarity index 100%
rename from vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fakeclient.go
rename to vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_client.go
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fakeduck.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_duck.go
similarity index 100%
rename from vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fakeduck.go
rename to vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_duck.go
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fakefactory.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_factory.go
similarity index 100%
rename from vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fakefactory.go
rename to vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_factory.go
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_filtered_factory.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_filtered_factory.go
new file mode 100644
index 000000000..153261dc4
--- /dev/null
+++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_filtered_factory.go
@@ -0,0 +1,131 @@
+/*
+Copyright 2021 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generators
+
+import (
+	"io"
+
+	"k8s.io/gengo/generator"
+	"k8s.io/gengo/namer"
+	"k8s.io/gengo/types"
+	"k8s.io/klog"
+)
+
+// fakeFilteredFactoryGenerator produces a file of listers for a given GroupVersion and
+// type.
+type fakeFilteredFactoryGenerator struct {
+	generator.DefaultGen
+	outputPackage string
+	imports       namer.ImportTracker
+	filtered      bool
+
+	factoryInjectionPkg          string
+	fakeClientInjectionPkg       string
+	sharedInformerFactoryPackage string
+}
+
+var _ generator.Generator = (*fakeFilteredFactoryGenerator)(nil)
+
+func (g *fakeFilteredFactoryGenerator) Filter(c *generator.Context, t *types.Type) bool {
+	// We generate a single factory, so return true once.
+	if !g.filtered {
+		g.filtered = true
+		return true
+	}
+	return false
+}
+
+func (g *fakeFilteredFactoryGenerator) Namers(c *generator.Context) namer.NameSystems {
+	return namer.NameSystems{
+		"raw": namer.NewRawNamer(g.outputPackage, g.imports),
+	}
+}
+
+func (g *fakeFilteredFactoryGenerator) Imports(c *generator.Context) (imports []string) {
+	imports = append(imports, g.imports.ImportLines()...)
+	return
+}
+
+func (g *fakeFilteredFactoryGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
+	sw := generator.NewSnippetWriter(w, c, "{{", "}}")
+
+	klog.V(5).Info("processing type ", t)
+
+	m := map[string]interface{}{
+		"factoryKey":      c.Universe.Type(types.Name{Package: g.factoryInjectionPkg, Name: "Key"}),
+		"factoryLabelKey": c.Universe.Type(types.Name{Package: g.factoryInjectionPkg, Name: "LabelKey"}),
+		"factoryGet":      c.Universe.Function(types.Name{Package: g.factoryInjectionPkg, Name: "Get"}),
+		"clientGet":       c.Universe.Function(types.Name{Package: g.fakeClientInjectionPkg, Name: "Get"}),
+		"informersNewSharedInformerFactoryWithOptions": c.Universe.Function(types.Name{Package: g.sharedInformerFactoryPackage, Name: "NewSharedInformerFactoryWithOptions"}),
+		"informersSharedInformerOption":                c.Universe.Function(types.Name{Package: g.sharedInformerFactoryPackage, Name: "SharedInformerOption"}),
+		"informersWithNamespace":                       c.Universe.Function(types.Name{Package: g.sharedInformerFactoryPackage, Name: "WithNamespace"}),
+		"informersWithTweakListOptions":                c.Universe.Function(types.Name{Package: g.sharedInformerFactoryPackage, Name: "WithTweakListOptions"}),
+		"injectionRegisterInformerFactory": c.Universe.Function(types.Name{
+			Package: "knative.dev/pkg/injection",
+			Name:    "Fake.RegisterInformerFactory",
+		}),
+		"injectionHasNamespace":     c.Universe.Type(types.Name{Package: "knative.dev/pkg/injection", Name: "HasNamespaceScope"}),
+		"injectionGetNamespace":     c.Universe.Type(types.Name{Package: "knative.dev/pkg/injection", Name: "GetNamespaceScope"}),
+		"controllerGetResyncPeriod": c.Universe.Type(types.Name{Package: "knative.dev/pkg/controller", Name: "GetResyncPeriod"}),
+		"contextContext": c.Universe.Type(types.Name{
+			Package: "context",
+			Name:    "Context",
+		}),
+		"loggingFromContext": c.Universe.Function(types.Name{
+			Package: "knative.dev/pkg/logging",
+			Name:    "FromContext",
+		}),
+		"metav1ListOptions": c.Universe.Type(types.Name{
+			Package: "k8s.io/apimachinery/pkg/apis/meta/v1",
+			Name:    "ListOptions",
+		}),
+	}
+
+	sw.Do(injectionFakeFilteredInformerFactory, m)
+
+	return sw.Error()
+}
+
+var injectionFakeFilteredInformerFactory = `
+var Get = {{.factoryGet|raw}}
+
+func init() {
+	{{.injectionRegisterInformerFactory|raw}}(withInformerFactory)
+}
+
+func withInformerFactory(ctx {{.contextContext|raw}}) {{.contextContext|raw}} {
+	c := {{.clientGet|raw}}(ctx)
+	opts := []{{.informersSharedInformerOption|raw}}{}
+	if {{.injectionHasNamespace|raw}}(ctx) {
+		opts = append(opts, {{.informersWithNamespace|raw}}({{.injectionGetNamespace|raw}}(ctx)))
+	}
+	untyped := ctx.Value({{.factoryLabelKey|raw}}{})
+	if untyped == nil {
+		{{.loggingFromContext|raw}}(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	for _, selector := range labelSelectors {
+		thisOpts := append(opts, {{.informersWithTweakListOptions|raw}}(func(l *{{.metav1ListOptions|raw}}) {
+			l.LabelSelector = selector
+		}))
+		ctx = context.WithValue(ctx, {{.factoryKey|raw}}{Selector: selector},
+			{{.informersNewSharedInformerFactoryWithOptions|raw}}(c, {{.controllerGetResyncPeriod|raw}}(ctx), thisOpts...))
+	}
+	return ctx
+}
+`
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_filtered_informer.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_filtered_informer.go
new file mode 100644
index 000000000..47b700884
--- /dev/null
+++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_filtered_informer.go
@@ -0,0 +1,133 @@
+/*
+Copyright 2021 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generators
+
+import (
+	"io"
+
+	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
+	"k8s.io/gengo/generator"
+	"k8s.io/gengo/namer"
+	"k8s.io/gengo/types"
+	"k8s.io/klog"
+)
+
+// fakeFilteredInformerGenerator produces a file of listers for a given GroupVersion and
+// type.
+type fakeFilteredInformerGenerator struct {
+	generator.DefaultGen
+	outputPackage string
+	imports       namer.ImportTracker
+
+	typeToGenerate          *types.Type
+	groupVersion            clientgentypes.GroupVersion
+	groupGoName             string
+	informerInjectionPkg    string
+	fakeFactoryInjectionPkg string
+}
+
+var _ generator.Generator = (*fakeFilteredInformerGenerator)(nil)
+
+func (g *fakeFilteredInformerGenerator) Filter(c *generator.Context, t *types.Type) bool {
+	// Only process the type for this informer generator.
+	return t == g.typeToGenerate
+}
+
+func (g *fakeFilteredInformerGenerator) Namers(c *generator.Context) namer.NameSystems {
+	publicPluralNamer := &ExceptionNamer{
+		Exceptions: map[string]string{
+			// these exceptions are used to deconflict the generated code
+			// you can put your fully qualified package like
+			// to generate a name that doesn't conflict with your group.
+			// "k8s.io/apis/events/v1beta1.Event": "EventResource"
+		},
+		KeyFunc: func(t *types.Type) string {
+			return t.Name.Package + "." + t.Name.Name
+		},
+		Delegate: namer.NewPublicPluralNamer(map[string]string{
+			"Endpoints": "Endpoints",
+		}),
+	}
+
+	return namer.NameSystems{
+		"raw":          namer.NewRawNamer(g.outputPackage, g.imports),
+		"publicPlural": publicPluralNamer,
+	}
+}
+
+func (g *fakeFilteredInformerGenerator) Imports(c *generator.Context) (imports []string) {
+	imports = append(imports, g.imports.ImportLines()...)
+	return
+}
+
+func (g *fakeFilteredInformerGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
+	sw := generator.NewSnippetWriter(w, c, "{{", "}}")
+
+	klog.V(5).Info("processing type ", t)
+
+	m := map[string]interface{}{
+		"informerKey":        c.Universe.Type(types.Name{Package: g.informerInjectionPkg, Name: "Key"}),
+		"informerGet":        c.Universe.Function(types.Name{Package: g.informerInjectionPkg, Name: "Get"}),
+		"factoryGet":         c.Universe.Function(types.Name{Package: g.fakeFactoryInjectionPkg, Name: "Get"}),
+		"factoryLabelKey":    c.Universe.Type(types.Name{Package: g.fakeFactoryInjectionPkg, Name: "LabelKey"}),
+		"group":              namer.IC(g.groupGoName),
+		"type":               t,
+		"version":            namer.IC(g.groupVersion.Version.String()),
+		"controllerInformer": c.Universe.Type(types.Name{Package: "knative.dev/pkg/controller", Name: "Informer"}),
+		"injectionRegisterFilteredInformers": c.Universe.Function(types.Name{
+			Package: "knative.dev/pkg/injection",
+			Name:    "Fake.RegisterFilteredInformers",
+		}),
+		"loggingFromContext": c.Universe.Function(types.Name{
+			Package: "knative.dev/pkg/logging",
+			Name:    "FromContext",
+		}),
+		"contextContext": c.Universe.Type(types.Name{
+			Package: "context",
+			Name:    "Context",
+		}),
+	}
+
+	sw.Do(injectionFakeFilteredInformer, m)
+
+	return sw.Error()
+}
+
+var injectionFakeFilteredInformer = `
+var Get = {{.informerGet|raw}}
+
+func init() {
+	{{.injectionRegisterFilteredInformers|raw}}(withInformer)
+}
+
+func withInformer(ctx {{.contextContext|raw}}) ({{.contextContext|raw}}, []{{.controllerInformer|raw}}) {
+	untyped := ctx.Value({{.factoryLabelKey|raw}}{})
+	if untyped == nil {
+		{{.loggingFromContext|raw}}(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []{{.controllerInformer|raw}}{}
+	for _, selector := range labelSelectors {
+		f := {{.factoryGet|raw}}(ctx, selector)
+		inf := f.{{.group}}().{{.version}}().{{.type|publicPlural}}()
+		ctx = context.WithValue(ctx, {{.informerKey|raw}}{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
+`
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fakeinformer.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_informer.go
similarity index 100%
rename from vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fakeinformer.go
rename to vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_informer.go
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_factory.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_factory.go
new file mode 100644
index 000000000..b036cf1cf
--- /dev/null
+++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_factory.go
@@ -0,0 +1,143 @@
+/*
+Copyright 2021 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generators
+
+import (
+	"io"
+
+	"k8s.io/gengo/generator"
+	"k8s.io/gengo/namer"
+	"k8s.io/gengo/types"
+
+	"k8s.io/klog"
+)
+
+// factoryTestGenerator produces a file of factory injection of a given type.
+type filteredFactoryGenerator struct {
+	generator.DefaultGen
+	outputPackage                string
+	imports                      namer.ImportTracker
+	cachingClientSetPackage      string
+	sharedInformerFactoryPackage string
+	filtered                     bool
+}
+
+var _ generator.Generator = (*filteredFactoryGenerator)(nil)
+
+func (g *filteredFactoryGenerator) Filter(c *generator.Context, t *types.Type) bool {
+	// We generate a single factory, so return true once.
+	if !g.filtered {
+		g.filtered = true
+		return true
+	}
+	return false
+}
+
+func (g *filteredFactoryGenerator) Namers(c *generator.Context) namer.NameSystems {
+	return namer.NameSystems{
+		"raw": namer.NewRawNamer(g.outputPackage, g.imports),
+	}
+}
+
+func (g *filteredFactoryGenerator) Imports(c *generator.Context) (imports []string) {
+	imports = append(imports, g.imports.ImportLines()...)
+	return
+}
+
+func (g *filteredFactoryGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
+	sw := generator.NewSnippetWriter(w, c, "{{", "}}")
+
+	klog.V(5).Info("processing type ", t)
+
+	m := map[string]interface{}{
+		"cachingClientGet": c.Universe.Type(types.Name{Package: g.cachingClientSetPackage, Name: "Get"}),
+		"informersNewSharedInformerFactoryWithOptions": c.Universe.Function(types.Name{Package: g.sharedInformerFactoryPackage, Name: "NewSharedInformerFactoryWithOptions"}),
+		"informersSharedInformerOption":                c.Universe.Function(types.Name{Package: g.sharedInformerFactoryPackage, Name: "SharedInformerOption"}),
+		"informersWithNamespace":                       c.Universe.Function(types.Name{Package: g.sharedInformerFactoryPackage, Name: "WithNamespace"}),
+		"informersWithTweakListOptions":                c.Universe.Function(types.Name{Package: g.sharedInformerFactoryPackage, Name: "WithTweakListOptions"}),
+		"informersSharedInformerFactory":               c.Universe.Function(types.Name{Package: g.sharedInformerFactoryPackage, Name: "SharedInformerFactory"}),
+		"injectionRegisterInformerFactory":             c.Universe.Type(types.Name{Package: "knative.dev/pkg/injection", Name: "Default.RegisterInformerFactory"}),
+		"injectionHasNamespace":                        c.Universe.Type(types.Name{Package: "knative.dev/pkg/injection", Name: "HasNamespaceScope"}),
+		"injectionGetNamespace":                        c.Universe.Type(types.Name{Package: "knative.dev/pkg/injection", Name: "GetNamespaceScope"}),
+		"controllerGetResyncPeriod":                    c.Universe.Type(types.Name{Package: "knative.dev/pkg/controller", Name: "GetResyncPeriod"}),
+		"loggingFromContext": c.Universe.Function(types.Name{
+			Package: "knative.dev/pkg/logging",
+			Name:    "FromContext",
+		}),
+		"contextContext": c.Universe.Type(types.Name{
+			Package: "context",
+			Name:    "Context",
+		}),
+		"metav1ListOptions": c.Universe.Type(types.Name{
+			Package: "k8s.io/apimachinery/pkg/apis/meta/v1",
+			Name:    "ListOptions",
+		}),
+	}
+
+	sw.Do(injectionFilteredFactory, m)
+
+	return sw.Error()
+}
+
+var injectionFilteredFactory = `
+func init() {
+	{{.injectionRegisterInformerFactory|raw}}(withInformerFactory)
+}
+
+// Key is used as the key for associating information with a context.Context.
+type Key struct{
+	Selector string
+}
+
+type LabelKey struct{}
+
+func WithSelectors(ctx {{.contextContext|raw}}, selector ...string) context.Context {
+	return context.WithValue(ctx, LabelKey{}, selector)
+}
+
+func withInformerFactory(ctx {{.contextContext|raw}}) {{.contextContext|raw}} {
+	c := {{.cachingClientGet|raw}}(ctx)
+	opts := []{{.informersSharedInformerOption|raw}}{}
+	if {{.injectionHasNamespace|raw}}(ctx) {
+		opts = append(opts, {{.informersWithNamespace|raw}}({{.injectionGetNamespace|raw}}(ctx)))
+	}
+	untyped := ctx.Value(LabelKey{})
+	if untyped == nil {
+		{{.loggingFromContext|raw}}(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	for _, selector := range labelSelectors {
+		thisOpts := append(opts, {{.informersWithTweakListOptions|raw}}(func(l *{{.metav1ListOptions|raw}}) {
+			l.LabelSelector = selector
+		}))
+		ctx = context.WithValue(ctx, Key{Selector: selector},
+			{{.informersNewSharedInformerFactoryWithOptions|raw}}(c, {{.controllerGetResyncPeriod|raw}}(ctx), thisOpts...))
+	}
+	return ctx
+}
+
+// Get extracts the InformerFactory from the context.
+func Get(ctx {{.contextContext|raw}}, selector string) {{.informersSharedInformerFactory|raw}} {
+	untyped := ctx.Value(Key{Selector: selector})
+	if untyped == nil {
+		{{.loggingFromContext|raw}}(ctx).Panicf(
+			"Unable to fetch {{.informersSharedInformerFactory}} with selector %s from context.", selector)
+	}
+	return untyped.({{.informersSharedInformerFactory|raw}})
+}
+`
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_informer.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_informer.go
new file mode 100644
index 000000000..c82a2e59f
--- /dev/null
+++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_informer.go
@@ -0,0 +1,141 @@
+/*
+Copyright 2021 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generators
+
+import (
+	"io"
+
+	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
+	"k8s.io/gengo/generator"
+	"k8s.io/gengo/namer"
+	"k8s.io/gengo/types"
+	"k8s.io/klog"
+)
+
+// injectionTestGenerator produces a file of listers for a given GroupVersion and
+// type.
+type filteredInjectionGenerator struct {
+	generator.DefaultGen
+	outputPackage               string
+	groupVersion                clientgentypes.GroupVersion
+	groupGoName                 string
+	typeToGenerate              *types.Type
+	imports                     namer.ImportTracker
+	typedInformerPackage        string
+	groupInformerFactoryPackage string
+}
+
+var _ generator.Generator = (*filteredInjectionGenerator)(nil)
+
+func (g *filteredInjectionGenerator) Filter(c *generator.Context, t *types.Type) bool {
+	// Only process the type for this informer generator.
+	return t == g.typeToGenerate
+}
+
+func (g *filteredInjectionGenerator) Namers(c *generator.Context) namer.NameSystems {
+	publicPluralNamer := &ExceptionNamer{
+		Exceptions: map[string]string{
+			// these exceptions are used to deconflict the generated code
+			// you can put your fully qualified package like
+			// to generate a name that doesn't conflict with your group.
+			// "k8s.io/apis/events/v1beta1.Event": "EventResource"
+		},
+		KeyFunc: func(t *types.Type) string {
+			return t.Name.Package + "." + t.Name.Name
+		},
+		Delegate: namer.NewPublicPluralNamer(map[string]string{
+			"Endpoints": "Endpoints",
+		}),
+	}
+
+	return namer.NameSystems{
+		"raw":          namer.NewRawNamer(g.outputPackage, g.imports),
+		"publicPlural": publicPluralNamer,
+	}
+}
+
+func (g *filteredInjectionGenerator) Imports(c *generator.Context) (imports []string) {
+	imports = append(imports, g.imports.ImportLines()...)
+	return
+}
+
+func (g *filteredInjectionGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
+	sw := generator.NewSnippetWriter(w, c, "{{", "}}")
+
+	klog.V(5).Info("processing type ", t)
+
+	m := map[string]interface{}{
+		"group":                              namer.IC(g.groupGoName),
+		"type":                               t,
+		"version":                            namer.IC(g.groupVersion.Version.String()),
+		"injectionRegisterFilteredInformers": c.Universe.Type(types.Name{Package: "knative.dev/pkg/injection", Name: "Default.RegisterFilteredInformers"}),
+		"controllerInformer":                 c.Universe.Type(types.Name{Package: "knative.dev/pkg/controller", Name: "Informer"}),
+		"informersTypedInformer":             c.Universe.Type(types.Name{Package: g.typedInformerPackage, Name: t.Name.Name + "Informer"}),
+		"factoryLabelKey":                    c.Universe.Type(types.Name{Package: g.groupInformerFactoryPackage, Name: "LabelKey"}),
+		"factoryGet":                         c.Universe.Function(types.Name{Package: g.groupInformerFactoryPackage, Name: "Get"}),
+		"loggingFromContext": c.Universe.Function(types.Name{
+			Package: "knative.dev/pkg/logging",
+			Name:    "FromContext",
+		}),
+		"contextContext": c.Universe.Type(types.Name{
+			Package: "context",
+			Name:    "Context",
+		}),
+	}
+
+	sw.Do(filteredInjectionInformer, m)
+
+	return sw.Error()
+}
+
+var filteredInjectionInformer = `
+func init() {
+	{{.injectionRegisterFilteredInformers|raw}}(withInformer)
+}
+
+// Key is used for associating the Informer inside the context.Context.
+type Key struct{
+	Selector string
+}
+
+func withInformer(ctx {{.contextContext|raw}}) ({{.contextContext|raw}}, []{{.controllerInformer|raw}}) {
+	untyped := ctx.Value({{.factoryLabelKey|raw}}{})
+	if untyped == nil {
+		{{.loggingFromContext|raw}}(ctx).Panic(
+			"Unable to fetch labelkey from context.")
+	}
+	labelSelectors := untyped.([]string)
+	infs := []{{.controllerInformer|raw}}{}
+	for _, selector := range labelSelectors {
+		f := {{.factoryGet|raw}}(ctx, selector)
+		inf := f.{{.group}}().{{.version}}().{{.type|publicPlural}}()
+		ctx = context.WithValue(ctx, Key{Selector: selector}, inf)
+		infs = append(infs, inf.Informer())
+	}
+	return ctx, infs
+}
+
+// Get extracts the typed informer from the context.
+func Get(ctx {{.contextContext|raw}}, selector string) {{.informersTypedInformer|raw}} {
+	untyped := ctx.Value(Key{Selector: selector})
+	if untyped == nil {
+		{{.loggingFromContext|raw}}(ctx).Panicf(
+			"Unable to fetch {{.informersTypedInformer}} with selector %s from context.", selector)
+	}
+	return untyped.({{.informersTypedInformer|raw}})
+}
+`
diff --git a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/packages.go b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/packages.go
index d1fa91e09..75dafbf1b 100644
--- a/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/packages.go
+++ b/vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/packages.go
@@ -336,11 +336,61 @@ func versionFactoryPackages(basePackage string, boilerplate []byte, customArgs *
 				return tags.NeedsInformerInjection()
 			},
 		},
+
+		// FilterFactoryImpl
+		&generator.DefaultPackage{
+			PackageName: "filteredFactory",
+			PackagePath: filepath.Join(packagePath, "filtered"),
+			HeaderText:  boilerplate,
+			GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+				// Impl
+				generators = append(generators, &filteredFactoryGenerator{
+					DefaultGen: generator.DefaultGen{
+						OptionalName: "filtered_factory",
+					},
+					outputPackage:                filepath.Join(packagePath, "filtered"),
+					cachingClientSetPackage:      filepath.Join(basePackage, "client"),
+					sharedInformerFactoryPackage: customArgs.ExternalVersionsInformersPackage,
+					imports:                      generator.NewImportTracker(),
+				})
+				return generators
+			},
+			FilterFunc: func(c *generator.Context, t *types.Type) bool {
+				tags := MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
+				return tags.NeedsInformerInjection()
+			},
+		},
+		// FakeFilterFactory
+		&generator.DefaultPackage{
+			PackageName: "fakeFilteredFactory",
+			PackagePath: filepath.Join(packagePath, "filtered", "fake"),
+			HeaderText:  boilerplate,
+			GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+				// Impl
+				generators = append(generators, &fakeFilteredFactoryGenerator{
+					DefaultGen: generator.DefaultGen{
+						OptionalName: "fake_filtered_factory",
+					},
+					outputPackage:                filepath.Join(packagePath, "filtered", "fake"),
+					factoryInjectionPkg:          filepath.Join(packagePath, "filtered"),
+					fakeClientInjectionPkg:       filepath.Join(basePackage, "client", "fake"),
+					sharedInformerFactoryPackage: customArgs.ExternalVersionsInformersPackage,
+					imports:                      generator.NewImportTracker(),
+				})
+				return generators
+			},
+			FilterFunc: func(c *generator.Context, t *types.Type) bool {
+				tags := MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
+				return tags.NeedsInformerInjection()
+			},
+		},
 	}
 }
 
 func versionInformerPackages(basePackage string, groupPkgName string, gv clientgentypes.GroupVersion, groupGoName string, boilerplate []byte, typesToGenerate []*types.Type, customArgs *informergenargs.CustomArgs) []generator.Package {
 	factoryPackagePath := filepath.Join(basePackage, "informers", "factory")
+	filteredFactoryPackagePath := filepath.Join(basePackage, "informers", "factory", "filtered")
+
 	packagePath := filepath.Join(basePackage, "informers", groupPkgName, strings.ToLower(gv.Version.NonEmpty()))
 
 	vers := make([]generator.Package, 0, 2*len(typesToGenerate))
@@ -404,6 +454,60 @@ func versionInformerPackages(basePackage string, groupPkgName string, gv clientg
 				return tags.NeedsInformerInjection()
 			},
 		})
+		// FilteredInformer
+		vers = append(vers, &generator.DefaultPackage{
+			PackageName: "filtered",
+			PackagePath: filepath.Join(packagePath, "filtered"),
+			HeaderText:  boilerplate,
+			GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+				// Impl
+				generators = append(generators, &filteredInjectionGenerator{
+					DefaultGen: generator.DefaultGen{
+						OptionalName: strings.ToLower(t.Name.Name),
+					},
+					outputPackage:               filepath.Join(packagePath, "filtered"),
+					groupVersion:                gv,
+					groupGoName:                 groupGoName,
+					typeToGenerate:              t,
+					imports:                     generator.NewImportTracker(),
+					typedInformerPackage:        typedInformerPackage,
+					groupInformerFactoryPackage: filteredFactoryPackagePath,
+				})
+				return generators
+			},
+			FilterFunc: func(c *generator.Context, t *types.Type) bool {
+				tags := MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
+				return tags.NeedsInformerInjection()
+			},
+		})
+
+		// FakeFilteredInformer
+		vers = append(vers, &generator.DefaultPackage{
+			PackageName: "fake",
+			PackagePath: filepath.Join(packagePath, "filtered", "fake"),
+			HeaderText:  boilerplate,
+			GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+				// Impl
+				generators = append(generators, &fakeFilteredInformerGenerator{
+					DefaultGen: generator.DefaultGen{
+						OptionalName: "fake",
+					},
+					outputPackage:           filepath.Join(packagePath, "filtered", "fake"),
+					imports:                 generator.NewImportTracker(),
+					typeToGenerate:          t,
+					groupVersion:            gv,
+					groupGoName:             groupGoName,
+					informerInjectionPkg:    filepath.Join(packagePath, "filtered"),
+					fakeFactoryInjectionPkg: filteredFactoryPackagePath,
+				})
+				return generators
+			},
+			FilterFunc: func(c *generator.Context, t *types.Type) bool {
+				tags := MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
+				return tags.NeedsInformerInjection()
+			},
+		})
+
 	}
 	return vers
 }
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 9260fe87f..0f0f417ec 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
@@ -170,6 +170,18 @@ func (g *reconcilerControllerGenerator) GenerateType(c *generator.Context, t *ty
 			Package: "fmt",
 			Name:    "Sprintf",
 		}),
+		"logkeyControllerType": c.Universe.Constant(types.Name{
+			Package: "knative.dev/pkg/logging/logkey",
+			Name:    "ControllerType",
+		}),
+		"logkeyControllerKind": c.Universe.Constant(types.Name{
+			Package: "knative.dev/pkg/logging/logkey",
+			Name:    "Kind",
+		}),
+		"zapString": c.Universe.Function(types.Name{
+			Package: "go.uber.org/zap",
+			Name:    "String",
+		}),
 	}
 
 	sw.Do(reconcilerControllerNewImpl, m)
@@ -227,10 +239,17 @@ func NewImpl(ctx {{.contextContext|raw}}, r Interface{{if .hasClass}}, classValu
 		{{if .hasClass}}classValue: classValue,{{end}}
 	}
 
-	t := {{.reflectTypeOf|raw}}(r).Elem()
-	queueName := {{.fmtSprintf|raw}}("%s.%s", {{.stringsReplaceAll|raw}}(t.PkgPath(), "/", "-"), t.Name())
+	ctrType := {{.reflectTypeOf|raw}}(r).Elem()
+	ctrTypeName := {{.fmtSprintf|raw}}("%s.%s", ctrType.PkgPath(), ctrType.Name())
+	ctrTypeName = {{.stringsReplaceAll|raw}}(ctrTypeName, "/", ".")
+
+	logger = logger.With(
+			{{.zapString|raw}}({{.logkeyControllerType|raw}}, ctrTypeName),
+			{{.zapString|raw}}({{.logkeyControllerKind|raw}}, "{{ printf "%s.%s" .group .type.Name.Name }}"),
+	)
+
 
-	impl := {{.controllerNewImpl|raw}}(rec, logger, queueName)
+	impl := {{.controllerNewImpl|raw}}(rec, logger, ctrTypeName)
 	agentName := defaultControllerAgentName
 
 	// Pass impl to the options. Save any optional results.
diff --git a/vendor/knative.dev/pkg/controller/controller.go b/vendor/knative.dev/pkg/controller/controller.go
index 953e5ea0c..26030626e 100644
--- a/vendor/knative.dev/pkg/controller/controller.go
+++ b/vendor/knative.dev/pkg/controller/controller.go
@@ -230,7 +230,6 @@ func NewImplWithStats(r Reconciler, logger *zap.SugaredLogger, workQueueName str
 
 // NewImplFull accepts the full set of options available to all controllers.
 func NewImplFull(r Reconciler, options ControllerOptions) *Impl {
-	logger := options.Logger.Named(options.WorkQueueName)
 	if options.RateLimiter == nil {
 		options.RateLimiter = workqueue.DefaultControllerRateLimiter()
 	}
@@ -241,7 +240,7 @@ func NewImplFull(r Reconciler, options ControllerOptions) *Impl {
 		Name:          options.WorkQueueName,
 		Reconciler:    r,
 		workQueue:     newTwoLaneWorkQueue(options.WorkQueueName, options.RateLimiter),
-		logger:        logger,
+		logger:        options.Logger,
 		statsReporter: options.Reporter,
 	}
 }
@@ -528,7 +527,7 @@ func (c *Impl) processNextWorkItem() bool {
 	// Finally, if no error occurs we Forget this item so it does not
 	// have any delay when another change happens.
 	c.workQueue.Forget(key)
-	logger.Info("Reconcile succeeded. Time taken: ", zap.Duration("duration", time.Since(startTime)))
+	logger.Infow("Reconcile succeeded", zap.Duration("duration", time.Since(startTime)))
 
 	return true
 }
diff --git a/vendor/knative.dev/pkg/injection/README.md b/vendor/knative.dev/pkg/injection/README.md
index 131484ab0..761677e88 100644
--- a/vendor/knative.dev/pkg/injection/README.md
+++ b/vendor/knative.dev/pkg/injection/README.md
@@ -138,6 +138,7 @@ func NewController(ctx context.Context, cmw configmap.Watcher) *controller.Impl
 		Client:        kubeclient.Get(ctx),
 		ServiceLister: svcInformer.Lister(),
 	}
+	logger = logger.Named("NameOfController")
 	impl := controller.NewImpl(c, logger, "NameOfController")
 
 	// Set up event handlers.
diff --git a/vendor/knative.dev/pkg/injection/informers.go b/vendor/knative.dev/pkg/injection/informers.go
index 1140174d1..9356f8d7f 100644
--- a/vendor/knative.dev/pkg/injection/informers.go
+++ b/vendor/knative.dev/pkg/injection/informers.go
@@ -28,6 +28,10 @@ import (
 // informer type to a context.
 type InformerInjector func(context.Context) (context.Context, controller.Informer)
 
+// FilteredInformersInjector holds the type of a callback that attaches a set of particular
+// filtered informers type to a context.
+type FilteredInformersInjector func(context.Context) (context.Context, []controller.Informer)
+
 func (i *impl) RegisterInformer(ii InformerInjector) {
 	i.m.Lock()
 	defer i.m.Unlock()
@@ -35,6 +39,13 @@ func (i *impl) RegisterInformer(ii InformerInjector) {
 	i.informers = append(i.informers, ii)
 }
 
+func (i *impl) RegisterFilteredInformers(fii FilteredInformersInjector) {
+	i.m.Lock()
+	defer i.m.Unlock()
+
+	i.filteredInformers = append(i.filteredInformers, fii)
+}
+
 func (i *impl) GetInformers() []InformerInjector {
 	i.m.RLock()
 	defer i.m.RUnlock()
@@ -43,6 +54,14 @@ func (i *impl) GetInformers() []InformerInjector {
 	return append(i.informers[:0:0], i.informers...)
 }
 
+func (i *impl) GetFilteredInformers() []FilteredInformersInjector {
+	i.m.RLock()
+	defer i.m.RUnlock()
+
+	// Copy the slice before returning.
+	return append(i.filteredInformers[:0:0], i.filteredInformers...)
+}
+
 func (i *impl) SetupInformers(ctx context.Context, cfg *rest.Config) (context.Context, []controller.Informer) {
 	// Based on the reconcilers we have linked, build up a set of clients and inject
 	// them onto the context.
@@ -65,10 +84,16 @@ func (i *impl) SetupInformers(ctx context.Context, cfg *rest.Config) (context.Co
 	// Based on the reconcilers we have linked, build up a set of informers
 	// and inject them onto the context.
 	var inf controller.Informer
+	var filteredinfs []controller.Informer
 	informers := make([]controller.Informer, 0, len(i.GetInformers()))
 	for _, ii := range i.GetInformers() {
 		ctx, inf = ii(ctx)
 		informers = append(informers, inf)
 	}
+	for _, fii := range i.GetFilteredInformers() {
+		ctx, filteredinfs = fii(ctx)
+		informers = append(informers, filteredinfs...)
+
+	}
 	return ctx, informers
 }
diff --git a/vendor/knative.dev/pkg/injection/interface.go b/vendor/knative.dev/pkg/injection/interface.go
index 85955db58..7d2764cdc 100644
--- a/vendor/knative.dev/pkg/injection/interface.go
+++ b/vendor/knative.dev/pkg/injection/interface.go
@@ -53,9 +53,16 @@ type Interface interface {
 	// a new informer with a context.
 	RegisterInformer(InformerInjector)
 
+	// RegisterFilteredInformers registers a new filtered informer injector callback for associating
+	// a new set of informers with a context.
+	RegisterFilteredInformers(FilteredInformersInjector)
+
 	// GetInformers fetches all of the registered informer injectors.
 	GetInformers() []InformerInjector
 
+	// GetFilteredInformers fetches all of the registered filtered informer injectors.
+	GetFilteredInformers() []FilteredInformersInjector
+
 	// SetupInformers runs all of the injectors against a context, starting with
 	// the clients and the given rest.Config.  The resulting context is returned
 	// along with a list of the .Informer() for each of the injected informers,
@@ -84,8 +91,9 @@ var (
 type impl struct {
 	m sync.RWMutex
 
-	clients   []ClientInjector
-	factories []InformerFactoryInjector
-	informers []InformerInjector
-	ducks     []DuckFactoryInjector
+	clients           []ClientInjector
+	factories         []InformerFactoryInjector
+	informers         []InformerInjector
+	filteredInformers []FilteredInformersInjector
+	ducks             []DuckFactoryInjector
 }
diff --git a/vendor/knative.dev/pkg/logging/config.go b/vendor/knative.dev/pkg/logging/config.go
index 7e8636f9b..5dbf0a4e4 100644
--- a/vendor/knative.dev/pkg/logging/config.go
+++ b/vendor/knative.dev/pkg/logging/config.go
@@ -55,14 +55,15 @@ func NewLogger(configJSON string, levelOverride string, opts ...zap.Option) (*za
 		return enrichLoggerWithCommitID(logger), atomicLevel
 	}
 
-	loggingCfg := zapdriver.NewProductionConfig()
+	loggingCfg := stackdriverConfig()
+
 	if levelOverride != "" {
 		if level, err := levelFromString(levelOverride); err == nil {
 			loggingCfg.Level = zap.NewAtomicLevelAt(*level)
 		}
 	}
 
-	logger, err = loggingCfg.Build(append(opts, zapdriver.WrapCore())...)
+	logger, err = loggingCfg.Build(opts...)
 	if err != nil {
 		panic(err)
 	}
@@ -107,7 +108,7 @@ func newLoggerFromConfig(configJSON, levelOverride string, opts []zap.Option) (*
 		}
 	}
 
-	logger, err := loggingCfg.Build(append(opts, zapdriver.WrapCore())...)
+	logger, err := loggingCfg.Build(opts...)
 	if err != nil {
 		return nil, zap.AtomicLevel{}, err
 	}
@@ -118,7 +119,8 @@ func newLoggerFromConfig(configJSON, levelOverride string, opts []zap.Option) (*
 }
 
 func zapConfigFromJSON(configJSON string) (*zap.Config, error) {
-	loggingCfg := zapdriver.NewProductionConfig()
+	loggingCfg := stackdriverConfig()
+
 	if configJSON != "" {
 		if err := json.Unmarshal([]byte(configJSON), &loggingCfg); err != nil {
 			return nil, err
@@ -249,3 +251,9 @@ func ConfigToJSON(cfg *Config) (string, error) {
 	})
 	return string(jsonCfg), err
 }
+
+func stackdriverConfig() zap.Config {
+	cfg := zapdriver.NewProductionConfig()
+	cfg.EncoderConfig.EncodeDuration = zapcore.StringDurationEncoder
+	return cfg
+}
diff --git a/vendor/knative.dev/pkg/webhook/certificates/certificates.go b/vendor/knative.dev/pkg/webhook/certificates/certificates.go
index 95a9633b1..5239279e5 100644
--- a/vendor/knative.dev/pkg/webhook/certificates/certificates.go
+++ b/vendor/knative.dev/pkg/webhook/certificates/certificates.go
@@ -36,7 +36,7 @@ import (
 
 const (
 	// Time used for updating a certificate before it expires.
-	oneWeek = 7 * 24 * time.Hour
+	oneDay = 24 * time.Hour
 )
 
 type reconciler struct {
@@ -89,7 +89,7 @@ func (r *reconciler) reconcileCertificate(ctx context.Context) error {
 			certData, err := x509.ParseCertificate(cert.Certificate[0])
 			if err != nil {
 				logger.Errorw("Error parsing certificate", zap.Error(err))
-			} else if time.Now().Add(oneWeek).Before(certData.NotAfter) {
+			} else if time.Now().Add(oneDay).Before(certData.NotAfter) {
 				return nil
 			}
 		}
diff --git a/vendor/knative.dev/pkg/webhook/certificates/controller.go b/vendor/knative.dev/pkg/webhook/certificates/controller.go
index a50acb39a..f6dedb722 100644
--- a/vendor/knative.dev/pkg/webhook/certificates/controller.go
+++ b/vendor/knative.dev/pkg/webhook/certificates/controller.go
@@ -66,7 +66,8 @@ func NewController(
 		secretlister: secretInformer.Lister(),
 	}
 
-	c := controller.NewImpl(wh, logging.FromContext(ctx), "WebhookCertificates")
+	const queueName = "WebhookCertificates"
+	c := controller.NewImpl(wh, logging.FromContext(ctx).Named(queueName), queueName)
 
 	// Reconcile when the cert bundle changes.
 	secretInformer.Informer().AddEventHandler(cache.FilteringResourceEventHandler{
diff --git a/vendor/knative.dev/pkg/webhook/certificates/resources/certs.go b/vendor/knative.dev/pkg/webhook/certificates/resources/certs.go
index 3b1486469..c7ab8f6a3 100644
--- a/vendor/knative.dev/pkg/webhook/certificates/resources/certs.go
+++ b/vendor/knative.dev/pkg/webhook/certificates/resources/certs.go
@@ -18,8 +18,8 @@ package resources
 
 import (
 	"context"
+	"crypto/ed25519"
 	"crypto/rand"
-	"crypto/rsa"
 	"crypto/x509"
 	"crypto/x509/pkix"
 	"encoding/pem"
@@ -62,7 +62,7 @@ func createCertTemplate(name, namespace string, notAfter time.Time) (*x509.Certi
 			Organization: []string{organization},
 			CommonName:   commonName,
 		},
-		SignatureAlgorithm:    x509.SHA256WithRSA,
+		SignatureAlgorithm:    x509.PureEd25519,
 		NotBefore:             time.Now(),
 		NotAfter:              notAfter,
 		BasicConstraintsValid: true,
@@ -112,9 +112,9 @@ func createCert(template, parent *x509.Certificate, pub, parentPriv interface{})
 	return
 }
 
-func createCA(ctx context.Context, name, namespace string, notAfter time.Time) (*rsa.PrivateKey, *x509.Certificate, []byte, error) {
+func createCA(ctx context.Context, name, namespace string, notAfter time.Time) (ed25519.PrivateKey, *x509.Certificate, []byte, error) {
 	logger := logging.FromContext(ctx)
-	rootKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
 	if err != nil {
 		logger.Errorw("error generating random key", zap.Error(err))
 		return nil, nil, nil, err
@@ -126,12 +126,12 @@ func createCA(ctx context.Context, name, namespace string, notAfter time.Time) (
 		return nil, nil, nil, err
 	}
 
-	rootCert, rootCertPEM, err := createCert(rootCertTmpl, rootCertTmpl, &rootKey.PublicKey, rootKey)
+	rootCert, rootCertPEM, err := createCert(rootCertTmpl, rootCertTmpl, publicKey, privateKey)
 	if err != nil {
 		logger.Errorw("error signing the CA cert", zap.Error(err))
 		return nil, nil, nil, err
 	}
-	return rootKey, rootCert, rootCertPEM, nil
+	return privateKey, rootCert, rootCertPEM, nil
 }
 
 // CreateCerts creates and returns a CA certificate and certificate and
@@ -148,7 +148,7 @@ func CreateCerts(ctx context.Context, name, namespace string, notAfter time.Time
 	}
 
 	// Then create the private key for the serving cert
-	servKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
 	if err != nil {
 		logger.Errorw("error generating random key", zap.Error(err))
 		return nil, nil, nil, err
@@ -160,13 +160,18 @@ func CreateCerts(ctx context.Context, name, namespace string, notAfter time.Time
 	}
 
 	// create a certificate which wraps the server's public key, sign it with the CA private key
-	_, servCertPEM, err := createCert(servCertTemplate, caCertificate, &servKey.PublicKey, caKey)
+	_, servCertPEM, err := createCert(servCertTemplate, caCertificate, publicKey, caKey)
 	if err != nil {
 		logger.Errorw("error signing server certificate template", zap.Error(err))
 		return nil, nil, nil, err
 	}
+	privKeyBytes, err := x509.MarshalPKCS8PrivateKey(privateKey)
+	if err != nil {
+		logger.Errorw("error marshaling private key", zap.Error(err))
+		return nil, nil, nil, err
+	}
 	servKeyPEM := pem.EncodeToMemory(&pem.Block{
-		Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(servKey),
+		Type: "PRIVATE KEY", Bytes: privKeyBytes,
 	})
 	return servKeyPEM, servCertPEM, caCertificatePEM, nil
 }
diff --git a/vendor/knative.dev/pkg/webhook/certificates/resources/secret.go b/vendor/knative.dev/pkg/webhook/certificates/resources/secret.go
index 48e57e870..6fad6629f 100644
--- a/vendor/knative.dev/pkg/webhook/certificates/resources/secret.go
+++ b/vendor/knative.dev/pkg/webhook/certificates/resources/secret.go
@@ -32,6 +32,8 @@ const (
 	// CACert is the name of the key associated with the certificate of the CA for
 	// the keypair.
 	CACert = "ca-cert.pem"
+
+	oneWeek = 7 * 24 * time.Hour
 )
 
 // MakeSecret synthesizes a Kubernetes Secret object with the keys specified by
@@ -41,7 +43,7 @@ var MakeSecret = MakeSecretInternal
 
 // MakeSecretInternal is only public so MakeSecret can be restored in testing.  Use MakeSecret.
 func MakeSecretInternal(ctx context.Context, name, namespace, serviceName string) (*corev1.Secret, error) {
-	serverKey, serverCert, caCert, err := CreateCerts(ctx, serviceName, namespace, time.Now().AddDate(1, 0, 0))
+	serverKey, serverCert, caCert, err := CreateCerts(ctx, serviceName, namespace, time.Now().Add(oneWeek))
 	if err != nil {
 		return nil, err
 	}
diff --git a/vendor/knative.dev/pkg/webhook/psbinding/README.md b/vendor/knative.dev/pkg/webhook/psbinding/README.md
index 4083093b3..e73ccf858 100644
--- a/vendor/knative.dev/pkg/webhook/psbinding/README.md
+++ b/vendor/knative.dev/pkg/webhook/psbinding/README.md
@@ -142,6 +142,7 @@ func NewController(
 		Recorder: record.NewBroadcaster().NewRecorder(
 			scheme.Scheme, corev1.EventSource{Component: controllerAgentName}),
 	}
+	logger = logger.Named("GithubBindings")
 	impl := controller.NewImpl(c, logger, "GithubBindings")
 
 	logger.Info("Setting up event handlers")
diff --git a/vendor/knative.dev/pkg/webhook/psbinding/controller.go b/vendor/knative.dev/pkg/webhook/psbinding/controller.go
index 3967c053b..1d671d072 100644
--- a/vendor/knative.dev/pkg/webhook/psbinding/controller.go
+++ b/vendor/knative.dev/pkg/webhook/psbinding/controller.go
@@ -87,7 +87,7 @@ func NewAdmissionController(
 
 	// Construct the reconciler for the mutating webhook configuration.
 	wh := NewReconciler(name, path, options.SecretName, client, mwhInformer.Lister(), secretInformer.Lister(), withContext, reconcilerOptions...)
-	c := controller.NewImpl(wh, logging.FromContext(ctx), name)
+	c := controller.NewImpl(wh, logging.FromContext(ctx).Named(name), name)
 
 	// Enqueue a sentinel when we become leader.
 	wh.PromoteFunc = func(bkt pkgreconciler.Bucket, enq func(pkgreconciler.Bucket, types.NamespacedName)) error {
diff --git a/vendor/knative.dev/pkg/webhook/resourcesemantics/conversion/controller.go b/vendor/knative.dev/pkg/webhook/resourcesemantics/conversion/controller.go
index 3b404ba97..7ab4b158b 100644
--- a/vendor/knative.dev/pkg/webhook/resourcesemantics/conversion/controller.go
+++ b/vendor/knative.dev/pkg/webhook/resourcesemantics/conversion/controller.go
@@ -117,7 +117,9 @@ func NewConversionController(
 		crdLister:    crdInformer.Lister(),
 	}
 
-	c := controller.NewImpl(r, logging.FromContext(ctx), "ConversionWebhook")
+	const queueName = "ConversionWebhook"
+	logger := logging.FromContext(ctx)
+	c := controller.NewImpl(r, logger.Named(queueName), queueName)
 
 	// Reconciler when the named CRDs change.
 	for _, gkc := range kinds {
diff --git a/vendor/knative.dev/pkg/webhook/resourcesemantics/defaulting/controller.go b/vendor/knative.dev/pkg/webhook/resourcesemantics/defaulting/controller.go
index b33140588..7a3f22e34 100644
--- a/vendor/knative.dev/pkg/webhook/resourcesemantics/defaulting/controller.go
+++ b/vendor/knative.dev/pkg/webhook/resourcesemantics/defaulting/controller.go
@@ -74,7 +74,8 @@ func NewAdmissionController(
 	}
 
 	logger := logging.FromContext(ctx)
-	c := controller.NewImpl(wh, logger, "DefaultingWebhook")
+	const queueName = "DefaultingWebhook"
+	c := controller.NewImpl(wh, logger.Named(queueName), queueName)
 
 	// Reconcile when the named MutatingWebhookConfiguration changes.
 	mwhInformer.Informer().AddEventHandler(cache.FilteringResourceEventHandler{
diff --git a/vendor/knative.dev/pkg/webhook/resourcesemantics/validation/controller.go b/vendor/knative.dev/pkg/webhook/resourcesemantics/validation/controller.go
index 567515843..942da7079 100644
--- a/vendor/knative.dev/pkg/webhook/resourcesemantics/validation/controller.go
+++ b/vendor/knative.dev/pkg/webhook/resourcesemantics/validation/controller.go
@@ -89,7 +89,8 @@ func NewAdmissionController(
 	}
 
 	logger := logging.FromContext(ctx)
-	c := controller.NewImpl(wh, logger, "ValidationWebhook")
+	const queueName = "ValidationWebhook"
+	c := controller.NewImpl(wh, logger.Named(queueName), queueName)
 
 	// Reconcile when the named ValidatingWebhookConfiguration changes.
 	vwhInformer.Informer().AddEventHandler(cache.FilteringResourceEventHandler{
diff --git a/vendor/modules.txt b/vendor/modules.txt
index faba8ba3b..9e26913ca 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -685,7 +685,7 @@ gopkg.in/jcmturner/rpc.v1/ndr
 gopkg.in/yaml.v2
 # gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776
 gopkg.in/yaml.v3
-# k8s.io/api v0.18.12 => k8s.io/api v0.18.8
+# k8s.io/api v0.19.7 => k8s.io/api v0.18.8
 ## explicit
 k8s.io/api/admission/v1
 k8s.io/api/admissionregistration/v1
@@ -728,7 +728,7 @@ k8s.io/api/settings/v1alpha1
 k8s.io/api/storage/v1
 k8s.io/api/storage/v1alpha1
 k8s.io/api/storage/v1beta1
-# k8s.io/apiextensions-apiserver v0.18.12 => k8s.io/apiextensions-apiserver v0.18.8
+# k8s.io/apiextensions-apiserver v0.19.7 => k8s.io/apiextensions-apiserver v0.18.8
 k8s.io/apiextensions-apiserver/pkg/apis/apiextensions
 k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1
 k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1
@@ -746,7 +746,7 @@ k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensio
 k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces
 k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1
 k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1
-# k8s.io/apimachinery v0.18.12 => k8s.io/apimachinery v0.18.8
+# k8s.io/apimachinery v0.19.7 => k8s.io/apimachinery v0.18.8
 ## explicit
 k8s.io/apimachinery/pkg/api/apitesting
 k8s.io/apimachinery/pkg/api/apitesting/fuzzer
@@ -1016,7 +1016,7 @@ k8s.io/client-go/util/jsonpath
 k8s.io/client-go/util/keyutil
 k8s.io/client-go/util/retry
 k8s.io/client-go/util/workqueue
-# k8s.io/code-generator v0.18.12 => k8s.io/code-generator v0.18.8
+# k8s.io/code-generator v0.19.7 => k8s.io/code-generator v0.18.8
 k8s.io/code-generator
 k8s.io/code-generator/cmd/client-gen
 k8s.io/code-generator/cmd/client-gen/args
@@ -1050,7 +1050,7 @@ k8s.io/code-generator/cmd/set-gen
 k8s.io/code-generator/pkg/namer
 k8s.io/code-generator/pkg/util
 k8s.io/code-generator/third_party/forked/golang/reflect
-# k8s.io/gengo v0.0.0-20200205140755-e0e292d8aa12
+# k8s.io/gengo v0.0.0-20200428234225-8167cfdcfc14
 k8s.io/gengo/args
 k8s.io/gengo/examples/deepcopy-gen/generators
 k8s.io/gengo/examples/defaulter-gen/generators
@@ -1078,7 +1078,7 @@ k8s.io/utils/buffer
 k8s.io/utils/integer
 k8s.io/utils/pointer
 k8s.io/utils/trace
-# knative.dev/eventing v0.20.1-0.20210115015220-1c94ef83b6b5
+# knative.dev/eventing v0.20.1-0.20210125061954-340f07f40bda
 ## explicit
 knative.dev/eventing/pkg/adapter/v2
 knative.dev/eventing/pkg/adapter/v2/util/crstatusevent
@@ -1172,6 +1172,7 @@ knative.dev/eventing/pkg/client/listers/sources/v1alpha1
 knative.dev/eventing/pkg/client/listers/sources/v1alpha2
 knative.dev/eventing/pkg/client/listers/sources/v1beta1
 knative.dev/eventing/pkg/client/listers/sources/v1beta2
+knative.dev/eventing/pkg/duck
 knative.dev/eventing/pkg/kncloudevents
 knative.dev/eventing/pkg/reconciler/source
 knative.dev/eventing/pkg/reconciler/sugar
@@ -1210,10 +1211,10 @@ knative.dev/eventing/test/test_images/heartbeats
 knative.dev/eventing/test/test_images/performance
 knative.dev/eventing/test/test_images/print
 knative.dev/eventing/test/test_images/recordevents
-# knative.dev/hack v0.0.0-20210114150620-4422dcadb3c8
+# knative.dev/hack v0.0.0-20210120165453-8d623a0af457
 ## explicit
 knative.dev/hack
-# knative.dev/pkg v0.0.0-20210114223020-f0ea5e6b9c4e
+# knative.dev/pkg v0.0.0-20210124203454-7101e9d4f6c6
 ## explicit
 knative.dev/pkg/apis
 knative.dev/pkg/apis/duck


Test patch:
diff --git a/test/README.md b/test/README.md
index 2a63e1ad7..e2bc37b04 100644
--- a/test/README.md
+++ b/test/README.md
@@ -64,7 +64,7 @@ with `test/e2e-tests.sh --run-tests --skip-knative-setup`.
 You can also use `go test` command to run unit tests:
 
 ```shell
-go test -v ./...
+SYSTEM_NAMESPACE=knative-eventing go test -v ./...
 ```
 
 _By default `go test` will not run [the e2e tests](#running-end-to-end-tests),
@@ -75,10 +75,10 @@ which needs [`-tags=e2e`](#running-end-to-end-tests) to be enabled._
 To run [the e2e tests](e2e) with `go test` command, you need to have a running
 environment that meets
 [the e2e test environment requirements](#environment-requirements), and you need
-to specify the build tag `e2e`.
+to specify the build tags `e2e` and `source`.
 
 ```bash
-go test -v -tags=e2e -count=1 ./test/e2e
+SYSTEM_NAMESPACE=knative-eventing go test -v -tags=e2e,source -count=1 ./test/e2e
 ```
 
 By default, it will run all applicable tests against the cluster's default
@@ -88,14 +88,14 @@ If you want to run tests against other `channels`, you can specify them through
 `-channels`.
 
 ```bash
-go test -v -tags=e2e -count=1 ./test/e2e -channels=InMemoryChannel,KafkaChannel
+SYSTEM_NAMESPACE=knative-eventing go test -v -tags=e2e,source -count=1 ./test/e2e -channels=InMemoryChannel,KafkaChannel
 ```
 
 By default, tests run against images with the `latest` tag. To override this
 bevavior you can specify a different tag through `-tag`:
 
 ```bash
-go test -v -tags=e2e -count=1 ./test/e2e -tag e2e
+SYSTEM_NAMESPACE=knative-eventing go test -v -tags=e2e,source -count=1 ./test/e2e -tag e2e
 ```
 
 #### One test case
@@ -104,7 +104,7 @@ To run one e2e test case, e.g. `TestSingleBinaryEventForChannel`, use
 [the `-run` flag with `go test`](https://golang.org/cmd/go/#hdr-Testing_flags):
 
 ```bash
-go test -v -tags=e2e -count=1 ./test/e2e -run ^TestSingleBinaryEventForChannel$
+SYSTEM_NAMESPACE=knative-eventing go test -v -tags=e2e,source -count=1 ./test/e2e -run ^TestSingleBinaryEventForChannel$
 ```
 
 By default, it will run the test against the default `channel`.
@@ -113,7 +113,15 @@ If you want to run it against another `channel`, you can specify it through
 `-channels`.
 
 ```bash
-go test -v -tags=e2e -count=1 ./test/e2e -run ^TestSingleBinaryEventForChannel$ -channels=InMemoryChannel
+SYSTEM_NAMESPACE=knative-eventing go test -v -tags=e2e,source -count=1 ./test/e2e -run ^TestSingleBinaryEventForChannel$ -channels=InMemoryChannel
+```
+
+#### Only channel test cases
+
+To run only the channel e2e tests, use only the `e2e` tag:
+
+```bash
+SYSTEM_NAMESPACE=knative-eventing go test -v -tags=e2e -count=1 ./test/e2e
 ```
 
 ## Environment requirements
@@ -143,14 +151,16 @@ and push the test images used by the e2e tests. It requires:
 To run the script for all end to end test images:
 
 ```bash
-./test/upload-test-images.sh
+./test/upload-test-images.sh ./vendor/knative.dev/eventing/test/test_images
+./test/upload-test-images.sh ./test/test_images
 ```
 
 For images deployed in GCR, a docker tag is mandatory to avoid issues with using
 `latest` tag:
 
 ```bash
-./test/upload-test-images.sh e2e
+./test/upload-test-images.sh ./vendor/knative.dev/eventing/test/test_images e2e
+./test/upload-test-images.sh ./test/test_images e2e
 ```
 
 ### Adding new test images
@@ -164,6 +174,21 @@ uploading test images, `ko` will build an image from this folder.
 If you need to add a new test image imported from eventing, import it in
 `hack/tools.go`
 
+## Tracing
+
+The following command installs Zipkin:
+
+```bash
+sed "s/\${SYSTEM_NAMESPACE}/knative-eventing/g" < "test/config/monitoring.yaml" | kubectl apply -f -
+
+```
+
+Run this command to tell Knative to send traces to Zipkin:
+
+```bash
+sed "s/\${SYSTEM_NAMESPACE}/knative-eventing/g" < "test/config/config-tracing.yaml" | kubectl apply -f -
+```
+
 ## Flags
 
 Flags are similar to those in
diff --git a/test/e2e-common.sh b/test/e2e-common.sh
index f711c8152..0fd29c8f2 100755
--- a/test/e2e-common.sh
+++ b/test/e2e-common.sh
@@ -104,7 +104,7 @@ readonly KAFKA_SOURCE_CRD_CONFIG_DIR="$(mktemp -d)"
 trap "{ for dirrm in \"${KAFKA_CRD_CONFIG_DIR}\" \"${KAFKA_SOURCE_CRD_CONFIG_DIR}\"; do rm \"\${dirrm}\"/*; rmdir \"\${dirrm}\"; done }" EXIT
 
 # Kafka channel CRD config template directory.
-readonly KAFKA_SOURCE_TEMPLATE_DIR="config/source"
+readonly KAFKA_SOURCE_TEMPLATE_DIR="config/source/single"
 
 # Namespaces where we install Eventing components
 # This is the namespace of knative-eventing itself
diff --git a/vendor/knative.dev/eventing/test/README.md b/vendor/knative.dev/eventing/test/README.md
index 2d9bcb3c1..08635f225 100644
--- a/vendor/knative.dev/eventing/test/README.md
+++ b/vendor/knative.dev/eventing/test/README.md
@@ -135,6 +135,10 @@ build and push the test images used by the e2e tests. It requires:
   [authenticated with your `KO_DOCKER_REPO`](https://github.com/knative/serving/blob/master/DEVELOPMENT.md#environment-setup)
 - [`docker`](https://docs.docker.com/install/) to be installed
 
+`PLATFORM` environment variable is optional. If it is specified, test images
+will be built for specific hardware architecture, according to its value (for
+instance,`linux/arm64`).
+
 To run the script for all end to end test images:
 
 ```bash
diff --git a/vendor/knative.dev/eventing/test/conformance/helpers/tracing/traces.go b/vendor/knative.dev/eventing/test/conformance/helpers/tracing/traces.go
index 079039aeb..d9d85e638 100644
--- a/vendor/knative.dev/eventing/test/conformance/helpers/tracing/traces.go
+++ b/vendor/knative.dev/eventing/test/conformance/helpers/tracing/traces.go
@@ -160,18 +160,22 @@ func GetTraceTree(trace []model.SpanModel) (*SpanTree, error) {
 		}
 	}
 
+	if len(roots) == 0 {
+		return nil, fmt.Errorf("no root spans found in the trace: Original: %v", PrettyPrintTrace(trace))
+	}
+
 	children, err := getChildren(parents, roots)
 	if err != nil {
 		return nil, fmt.Errorf("could not create span tree for %v: %v", PrettyPrintTrace(trace), err)
 	}
 
+	if len(parents) != 0 {
+		return nil, fmt.Errorf("left over spans after generating the SpanTree: %v. Original: %v", parents, PrettyPrintTrace(trace))
+	}
 	tree := SpanTree{
 		Root:     true,
 		Children: children,
 	}
-	if len(parents) != 0 {
-		return nil, fmt.Errorf("left over spans after generating the SpanTree: %v. Original: %v", parents, PrettyPrintTrace(trace))
-	}
 	return &tree, nil
 }
 
diff --git a/vendor/knative.dev/eventing/test/lib/duck/resource_creators.go b/vendor/knative.dev/eventing/test/lib/duck/resource_creators.go
index 0869cb8c0..997e1e9eb 100644
--- a/vendor/knative.dev/eventing/test/lib/duck/resource_creators.go
+++ b/vendor/knative.dev/eventing/test/lib/duck/resource_creators.go
@@ -20,18 +20,14 @@ package duck
 
 import (
 	"context"
-	"encoding/json"
 
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/dynamic"
 
+	"knative.dev/eventing/pkg/duck"
 	"knative.dev/eventing/test/lib/resources"
-
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-
-	messagingv1beta1 "knative.dev/eventing/pkg/apis/messaging/v1beta1"
 )
 
 // CreateGenericChannelObject create a generic channel object with the dynamic client and channel's meta data.
@@ -41,7 +37,7 @@ func CreateGenericChannelObject(
 ) ( /*plural*/ schema.GroupVersionResource, error) {
 	// get the resource's gvr
 	gvr, _ := meta.UnsafeGuessKindToResource(obj.GroupVersionKind())
-	newChannel, err := newChannel(obj)
+	newChannel, err := duck.NewPhysicalChannel(obj.TypeMeta, obj.ObjectMeta)
 	if err != nil {
 		return gvr, err
 	}
@@ -50,31 +46,3 @@ func CreateGenericChannelObject(
 	_, err = channelResourceInterface.Create(context.Background(), newChannel, metav1.CreateOptions{})
 	return gvr, err
 }
-
-// newChannel returns an unstructured.Unstructured based on the ChannelTemplateSpec for a given meta resource.
-func newChannel(obj *resources.MetaResource) (*unstructured.Unstructured, error) {
-	// Set the name of the resource we're creating as well as the namespace, etc.
-	template := messagingv1beta1.ChannelTemplateSpecInternal{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       obj.Kind,
-			APIVersion: obj.APIVersion,
-		},
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      obj.Name,
-			Namespace: obj.Namespace,
-		},
-		Spec: messagingv1beta1.ChannelTemplateSpec{
-			TypeMeta: obj.TypeMeta,
-		}.Spec,
-	}
-	raw, err := json.Marshal(template)
-	if err != nil {
-		return nil, err
-	}
-	u := &unstructured.Unstructured{}
-	err = json.Unmarshal(raw, u)
-	if err != nil {
-		return nil, err
-	}
-	return u, nil
-}
diff --git a/vendor/knative.dev/eventing/test/upload-test-images.sh b/vendor/knative.dev/eventing/test/upload-test-images.sh
index 50a523ef2..89df5a416 100644
--- a/vendor/knative.dev/eventing/test/upload-test-images.sh
+++ b/vendor/knative.dev/eventing/test/upload-test-images.sh
@@ -30,9 +30,17 @@ function upload_test_images() {
     tag_option="--tags $docker_tag,latest"
   fi
 
+  # If PLATFORM environment variable is specified, then images will be built for
+  # specific hardware architecture.
+  # Example of the variable values - "linux/arm64", "linux/s390x".
+  local platform=""
+  if [ -n "${PLATFORM}" ]; then
+    platform="--platform ${PLATFORM}"
+  fi
+
   # ko resolve is being used for the side-effect of publishing images,
   # so the resulting yaml produced is ignored.
-  ko resolve ${tag_option} -RBf "${image_dir}" > /dev/null
+  ko resolve ${platform} ${tag_option} -RBf "${image_dir}" > /dev/null
 }
 
 : ${KO_DOCKER_REPO:?"You must set 'KO_DOCKER_REPO', see DEVELOPMENT.md"}