From cc4d11bd427402600a3a07cf0317237ad262c98c Mon Sep 17 00:00:00 2001 From: knative-automation Date: Tue, 19 Jan 2021 22:48:53 -0800 Subject: [PATCH] upgrade to latest dependencies (#417) bumping knative.dev/pkg 75d66b5...1bbf0a6: > 1bbf0a6 add LabelSelector to InformerFactory so that the informers only list and watch resources with the given labels (# 1940) Signed-off-by: Knative Automation --- go.mod | 2 +- go.sum | 4 +- .../v1alpha1/image/filtered/fake/fake.go | 52 +++++++ .../caching/v1alpha1/image/filtered/image.go | 65 ++++++++ .../filtered/fake/fake_filtered_factory.go | 59 ++++++++ .../factory/filtered/filtered_factory.go | 77 ++++++++++ .../{fakeclient.go => fake_client.go} | 0 .../generators/{fakeduck.go => fake_duck.go} | 0 .../{fakefactory.go => fake_factory.go} | 0 .../generators/fake_filtered_factory.go | 131 ++++++++++++++++ .../generators/fake_filtered_informer.go | 133 ++++++++++++++++ .../{fakeinformer.go => fake_informer.go} | 0 .../generators/filtered_factory.go | 143 ++++++++++++++++++ .../generators/filtered_informer.go | 141 +++++++++++++++++ .../cmd/injection-gen/generators/packages.go | 104 +++++++++++++ vendor/knative.dev/pkg/injection/informers.go | 25 +++ vendor/knative.dev/pkg/injection/interface.go | 16 +- vendor/modules.txt | 2 +- 18 files changed, 946 insertions(+), 8 deletions(-) create mode 100644 pkg/client/injection/informers/caching/v1alpha1/image/filtered/fake/fake.go create mode 100644 pkg/client/injection/informers/caching/v1alpha1/image/filtered/image.go create mode 100644 pkg/client/injection/informers/factory/filtered/fake/fake_filtered_factory.go create mode 100644 pkg/client/injection/informers/factory/filtered/filtered_factory.go rename vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/{fakeclient.go => fake_client.go} (100%) rename vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/{fakeduck.go => fake_duck.go} (100%) rename vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/{fakefactory.go => fake_factory.go} (100%) create mode 100644 vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_filtered_factory.go create mode 100644 vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/fake_filtered_informer.go rename vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/{fakeinformer.go => fake_informer.go} (100%) create mode 100644 vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_factory.go create mode 100644 vendor/knative.dev/pkg/codegen/cmd/injection-gen/generators/filtered_informer.go diff --git a/go.mod b/go.mod index bba7026a..705ec3f3 100644 --- a/go.mod +++ b/go.mod @@ -18,5 +18,5 @@ require ( k8s.io/code-generator v0.18.12 k8s.io/kube-openapi v0.0.0-20200410145947-bcb3869e6f29 knative.dev/hack v0.0.0-20210114150620-4422dcadb3c8 - knative.dev/pkg v0.0.0-20210118192521-75d66b58948d + knative.dev/pkg v0.0.0-20210119162123-1bbf0a6436c3 ) diff --git a/go.sum b/go.sum index fc6a67cd..b270d6ae 100644 --- a/go.sum +++ b/go.sum @@ -1172,8 +1172,8 @@ k8s.io/utils v0.0.0-20200603063816-c1c6865ac451 h1:v8ud2Up6QK1lNOKFgiIVrZdMg7Mpm k8s.io/utils v0.0.0-20200603063816-c1c6865ac451/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= 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-20210118192521-75d66b58948d h1:EY2H22iv1MuvuSZzXwode/quaZQKx0utiNkC2SSOm5k= -knative.dev/pkg v0.0.0-20210118192521-75d66b58948d/go.mod h1:cZdMjcJE6JGSNaEypgbUigX1TjteMIwQsW2woNBPVCA= +knative.dev/pkg v0.0.0-20210119162123-1bbf0a6436c3 h1:kvBQKadSBqhTMveExPsvlkTWNS8yQcvxes6PS5RxDQs= +knative.dev/pkg v0.0.0-20210119162123-1bbf0a6436c3/go.mod h1:cZdMjcJE6JGSNaEypgbUigX1TjteMIwQsW2woNBPVCA= pgregory.net/rapid v0.3.3/go.mod h1:UYpPVyjFHzYBGHIxLFoupi8vwk6rXNzRY9OMvVxFIOU= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= diff --git a/pkg/client/injection/informers/caching/v1alpha1/image/filtered/fake/fake.go b/pkg/client/injection/informers/caching/v1alpha1/image/filtered/fake/fake.go new file mode 100644 index 00000000..2f0c645e --- /dev/null +++ b/pkg/client/injection/informers/caching/v1alpha1/image/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/caching/pkg/client/injection/informers/caching/v1alpha1/image/filtered" + factoryfiltered "knative.dev/caching/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.Caching().V1alpha1().Images() + ctx = context.WithValue(ctx, filtered.Key{Selector: selector}, inf) + infs = append(infs, inf.Informer()) + } + return ctx, infs +} diff --git a/pkg/client/injection/informers/caching/v1alpha1/image/filtered/image.go b/pkg/client/injection/informers/caching/v1alpha1/image/filtered/image.go new file mode 100644 index 00000000..5c247816 --- /dev/null +++ b/pkg/client/injection/informers/caching/v1alpha1/image/filtered/image.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/caching/pkg/client/informers/externalversions/caching/v1alpha1" + filtered "knative.dev/caching/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.Caching().V1alpha1().Images() + 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.ImageInformer { + untyped := ctx.Value(Key{Selector: selector}) + if untyped == nil { + logging.FromContext(ctx).Panicf( + "Unable to fetch knative.dev/caching/pkg/client/informers/externalversions/caching/v1alpha1.ImageInformer with selector %s from context.", selector) + } + return untyped.(v1alpha1.ImageInformer) +} 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 00000000..025aa3b7 --- /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/caching/pkg/client/informers/externalversions" + fake "knative.dev/caching/pkg/client/injection/client/fake" + filtered "knative.dev/caching/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 00000000..de8b505b --- /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/caching/pkg/client/informers/externalversions" + client "knative.dev/caching/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/caching/pkg/client/informers/externalversions.SharedInformerFactory with selector %s from context.", selector) + } + return untyped.(externalversions.SharedInformerFactory) +} 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 00000000..153261dc --- /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 00000000..47b70088 --- /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 00000000..b036cf1c --- /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 00000000..c82a2e59 --- /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 d1fa91e0..75dafbf1 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/injection/informers.go b/vendor/knative.dev/pkg/injection/informers.go index 1140174d..9356f8d7 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 85955db5..7d2764cd 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/modules.txt b/vendor/modules.txt index 87c03a8d..a3c8f8b3 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -655,7 +655,7 @@ k8s.io/utils/trace # knative.dev/hack v0.0.0-20210114150620-4422dcadb3c8 ## explicit knative.dev/hack -# knative.dev/pkg v0.0.0-20210118192521-75d66b58948d +# knative.dev/pkg v0.0.0-20210119162123-1bbf0a6436c3 ## explicit knative.dev/pkg/apis knative.dev/pkg/apis/duck