github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-13 22:05:59 +00:00
Code Issues Projects Releases Wiki Activity

update informer generator

Browse Source
This commit is contained in:
deads2k 2016-12-06 16:22:55 -05:00
parent 0579e86663
commit 97854b8de5
9 changed files with 164 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
cmd/libs/go2idl/informer-gen/generators/factory.go
View File

@ -36,6 +36,7 @@ type factoryGenerator struct {
groupVersions map[string]clientgentypes.GroupVersions
internalClientSetPackage string
versionedClientSetPackage string
internalInterfacesPackage string
filtered bool
}
@ -76,9 +77,9 @@ func (g *factoryGenerator) GenerateType(c *generator.Context, t *types.Type, w i
"groupVersions": g.groupVersions,
"gvInterfaces": gvInterfaces,
"gvNewFuncs": gvNewFuncs,
"interfacesNewInternalInformerFunc": c.Universe.Type(interfacesNewInternalInformerFunc),
"interfacesNewVersionedInformerFunc": c.Universe.Type(interfacesNewVersionedInformerFunc),
"interfacesSharedInformerFactory": c.Universe.Type(interfacesSharedInformerFactory),
"interfacesNewInternalInformerFunc": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "NewInternalInformerFunc"}),
"interfacesNewVersionedInformerFunc": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "NewVersionedInformerFunc"}),
"informerFactoryInterface": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "SharedInformerFactory"}),
"internalClientSetInterface": c.Universe.Type(types.Name{Package: g.internalClientSetPackage, Name: "Interface"}),
"reflectType": c.Universe.Type(reflectType),
"runtimeObject": c.Universe.Type(runtimeObject),
@ -107,7 +108,7 @@ type sharedInformerFactory struct {
}
// NewSharedInformerFactory constructs a new instance of sharedInformerFactory
func NewSharedInformerFactory(internalClient {{.internalClientSetInterface|raw}}, versionedClient {{.versionedClientSetInterface|raw}}, defaultResync {{.timeDuration|raw}}) {{.interfacesSharedInformerFactory|raw}} {
func NewSharedInformerFactory(internalClient {{.internalClientSetInterface|raw}}, versionedClient {{.versionedClientSetInterface|raw}}, defaultResync {{.timeDuration|raw}}) SharedInformerFactory {
return &sharedInformerFactory{
internalClient: internalClient,
versionedClient: versionedClient,
@ -169,7 +170,7 @@ var sharedInformerFactoryInterface = `
// SharedInformerFactory provides shared informers for resources in all known
// API group versions.
type SharedInformerFactory interface {
{{.interfacesSharedInformerFactory|raw}}
{{.informerFactoryInterface|raw}}
{{$gvInterfaces := .gvInterfaces}}
{{range $groupName, $group := .groupVersions}}{{$groupName}}() {{index $gvInterfaces $groupName|raw}}

89
cmd/libs/go2idl/informer-gen/generators/factoryinterface.go Normal file
View File

@ -0,0 +1,89 @@
/*
Copyright 2016 The Kubernetes 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"
"github.com/golang/glog"
)
// factoryInterfaceGenerator produces a file of interfaces used to break a dependency cycle for
// informer registration
type factoryInterfaceGenerator struct {
generator.DefaultGen
outputPackage string
imports namer.ImportTracker
internalClientSetPackage string
versionedClientSetPackage string
filtered bool
}
var _ generator.Generator = &factoryInterfaceGenerator{}
func (g *factoryInterfaceGenerator) Filter(c *generator.Context, t *types.Type) bool {
if !g.filtered {
g.filtered = true
return true
}
return false
}
func (g *factoryInterfaceGenerator) Namers(c *generator.Context) namer.NameSystems {
return namer.NameSystems{
"raw": namer.NewRawNamer(g.outputPackage, g.imports),
}
}
func (g *factoryInterfaceGenerator) Imports(c *generator.Context) (imports []string) {
imports = append(imports, g.imports.ImportLines()...)
return
}
func (g *factoryInterfaceGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
sw := generator.NewSnippetWriter(w, c, "{{", "}}")
glog.V(5).Infof("processing type %v", t)
m := map[string]interface{}{
"cacheSharedIndexInformer": c.Universe.Type(cacheSharedIndexInformer),
"internalClientSetInterface": c.Universe.Type(types.Name{Package: g.internalClientSetPackage, Name: "Interface"}),
"runtimeObject": c.Universe.Type(runtimeObject),
"timeDuration": c.Universe.Type(timeDuration),
"versionedClientSetInterface": c.Universe.Type(types.Name{Package: g.versionedClientSetPackage, Name: "Interface"}),
}
sw.Do(externalSharedInformerFactoryInterface, m)
return sw.Error()
}
var externalSharedInformerFactoryInterface = `
type NewInternalInformerFunc func({{.internalClientSetInterface|raw}}, {{.timeDuration|raw}}) cache.SharedIndexInformer
type NewVersionedInformerFunc func({{.versionedClientSetInterface|raw}}, {{.timeDuration|raw}}) cache.SharedIndexInformer
// SharedInformerFactory a small interface to allow for adding an informer without an import cycle
type SharedInformerFactory interface {
Start(stopCh <-chan struct{})
InternalInformerFor(obj {{.runtimeObject|raw}}, newFunc NewInternalInformerFunc) {{.cacheSharedIndexInformer|raw}}
VersionedInformerFor(obj {{.runtimeObject|raw}}, newFunc NewVersionedInformerFunc) {{.cacheSharedIndexInformer|raw}}
}
`

3
cmd/libs/go2idl/informer-gen/generators/groupinterface.go
View File

@ -34,6 +34,7 @@ type groupInterfaceGenerator struct {
imports namer.ImportTracker
groupVersions clientgentypes.GroupVersions
filtered bool
internalInterfacesPackage string
}
var _ generator.Generator = &groupInterfaceGenerator{}
@ -78,7 +79,7 @@ func (g *groupInterfaceGenerator) GenerateType(c *generator.Context, t *types.Ty
})
}
m := map[string]interface{}{
"interfacesSharedInformerFactory": c.Universe.Type(interfacesSharedInformerFactory),
"interfacesSharedInformerFactory": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "SharedInformerFactory"}),
"versions": versions,
}

3
cmd/libs/go2idl/informer-gen/generators/informer.go
View File

@ -40,6 +40,7 @@ type informerGenerator struct {
versionedClientSetPackage string
internalClientSetPackage string
listersPackage string
internalInterfacesPackage string
}
var _ generator.Generator = &informerGenerator{}
@ -92,7 +93,7 @@ func (g *informerGenerator) GenerateType(c *generator.Context, t *types.Type, w
"clientSetInterface": clientSetInterface,
"group": namer.IC(g.groupVersion.Group.NonEmpty()),
"informerFor": informerFor,
"interfacesSharedInformerFactory": c.Universe.Type(interfacesSharedInformerFactory),
"interfacesSharedInformerFactory": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "SharedInformerFactory"}),
"listOptions": c.Universe.Type(listOptions),
"lister": c.Universe.Type(types.Name{Package: listerPackage, Name: t.Name.Name + "Lister"}),
"namespaceAll": namespaceAll,

32
cmd/libs/go2idl/informer-gen/generators/packages.go
View File

@ -103,6 +103,10 @@ func packageForGroup(base string, group clientgentypes.Group) string {
return filepath.Join(base, group.NonEmpty())
}
func packageForInternalInterfaces(base string) string {
return filepath.Join(base, "internalinterfaces")
}
// Packages makes the client package definition.
func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages {
boilerplate, err := arguments.LoadGoBoilerplate()
@ -185,6 +189,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
packageList = append(packageList, versionPackage(arguments.OutputPackagePath, gv, boilerplate, typesToGenerate, customArgs.InternalClientSetPackage, customArgs.VersionedClientSetPackage, customArgs.ListersPackage))
}
packageList = append(packageList, factoryInterfacePackage(arguments.OutputPackagePath, boilerplate, customArgs.InternalClientSetPackage, customArgs.VersionedClientSetPackage, typesForGroupVersion))
packageList = append(packageList, factoryPackage(arguments.OutputPackagePath, boilerplate, groupVersions, customArgs.InternalClientSetPackage, customArgs.VersionedClientSetPackage, typesForGroupVersion))
for _, groupVersionsEntry := range groupVersions {
packageList = append(packageList, groupPackage(arguments.OutputPackagePath, groupVersionsEntry, boilerplate))
@ -208,6 +213,7 @@ func factoryPackage(basePackage string, boilerplate []byte, groupVersions map[st
groupVersions: groupVersions,
internalClientSetPackage: internalClientSetPackage,
versionedClientSetPackage: versionedClientSetPackage,
internalInterfacesPackage: packageForInternalInterfaces(basePackage),
})
generators = append(generators, &genericGenerator{
@ -225,6 +231,29 @@ func factoryPackage(basePackage string, boilerplate []byte, groupVersions map[st
}
}
func factoryInterfacePackage(basePackage string, boilerplate []byte, internalClientSetPackage, versionedClientSetPackage string, typesForGroupVersion map[clientgentypes.GroupVersion][]*types.Type) generator.Package {
packagePath := packageForInternalInterfaces(basePackage)
return &generator.DefaultPackage{
PackageName: filepath.Base(packagePath),
PackagePath: packagePath,
HeaderText: boilerplate,
GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
generators = append(generators, &factoryInterfaceGenerator{
DefaultGen: generator.DefaultGen{
OptionalName: "internal_interfaces",
},
outputPackage: packagePath,
imports: generator.NewImportTracker(),
internalClientSetPackage: internalClientSetPackage,
versionedClientSetPackage: versionedClientSetPackage,
})
return generators
},
}
}
func groupPackage(basePackage string, groupVersions clientgentypes.GroupVersions, boilerplate []byte) generator.Package {
packagePath := filepath.Join(basePackage, strings.ToLower(groupVersions.Group.NonEmpty()))
@ -240,6 +269,7 @@ func groupPackage(basePackage string, groupVersions clientgentypes.GroupVersions
outputPackage: packagePath,
groupVersions: groupVersions,
imports: generator.NewImportTracker(),
internalInterfacesPackage: packageForInternalInterfaces(basePackage),
})
return generators
},
@ -265,6 +295,7 @@ func versionPackage(basePackage string, gv clientgentypes.GroupVersion, boilerpl
outputPackage: packagePath,
imports: generator.NewImportTracker(),
types: typesToGenerate,
internalInterfacesPackage: packageForInternalInterfaces(basePackage),
})
for _, t := range typesToGenerate {
@ -279,6 +310,7 @@ func versionPackage(basePackage string, gv clientgentypes.GroupVersion, boilerpl
internalClientSetPackage: internalClientSetPackage,
versionedClientSetPackage: versionedClientSetPackage,
listersPackage: listersPackage,
internalInterfacesPackage: packageForInternalInterfaces(basePackage),
})
}
return generators

3
cmd/libs/go2idl/informer-gen/generators/types.go
View File

@ -29,9 +29,6 @@ var (
cacheNewGenericLister = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "NewGenericLister"}
cacheNewSharedIndexInformer = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "NewSharedIndexInformer"}
cacheSharedIndexInformer = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "SharedIndexInformer"}
interfacesNewInternalInformerFunc = types.Name{Package: "k8s.io/kubernetes/pkg/client/informers/interfaces", Name: "NewInternalInformerFunc"}
interfacesNewVersionedInformerFunc = types.Name{Package: "k8s.io/kubernetes/pkg/client/informers/interfaces", Name: "NewVersionedInformerFunc"}
interfacesSharedInformerFactory = types.Name{Package: "k8s.io/kubernetes/pkg/client/informers/interfaces", Name: "SharedInformerFactory"}
listOptions = types.Name{Package: "k8s.io/kubernetes/pkg/api", Name: "ListOptions"}
reflectType = types.Name{Package: "reflect", Name: "Type"}
runtimeObject = types.Name{Package: "k8s.io/kubernetes/pkg/runtime", Name: "Object"}

3
cmd/libs/go2idl/informer-gen/generators/versioninterface.go
View File

@ -31,6 +31,7 @@ type versionInterfaceGenerator struct {
imports namer.ImportTracker
types []*types.Type
filtered bool
internalInterfacesPackage string
}
var _ generator.Generator = &versionInterfaceGenerator{}
@ -58,7 +59,7 @@ func (g *versionInterfaceGenerator) GenerateType(c *generator.Context, t *types.
sw := generator.NewSnippetWriter(w, c, "$", "$")
m := map[string]interface{}{
"interfacesSharedInformerFactory": c.Universe.Type(interfacesSharedInformerFactory),
"interfacesSharedInformerFactory": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "SharedInformerFactory"}),
"types": g.types,
}

23
pkg/client/informers/interfaces/BUILD
View File

@ -1,23 +0,0 @@
package(default_visibility = ["//visibility:public"])
licenses(["notice"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_binary",
"go_library",
"go_test",
"cgo_library",
)
go_library(
name = "go_default_library",
srcs = ["interface.go"],
tags = ["automanaged"],
deps = [
"//pkg/client/cache:go_default_library",
"//pkg/client/clientset_generated/internalclientset:go_default_library",
"//pkg/client/clientset_generated/release_1_5:go_default_library",
"//pkg/runtime:go_default_library",
],
)

35
pkg/client/informers/interfaces/interface.go
View File

@ -1,35 +0,0 @@
/*
Copyright 2016 The Kubernetes 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 interfaces
import (
"time"
"k8s.io/kubernetes/pkg/client/cache"
"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
"k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
"k8s.io/kubernetes/pkg/runtime"
)
type NewInternalInformerFunc func(internalclientset.Interface, time.Duration) cache.SharedIndexInformer
type NewVersionedInformerFunc func(release_1_5.Interface, time.Duration) cache.SharedIndexInformer
type SharedInformerFactory interface {
Start(stopCh <-chan struct{})
InternalInformerFor(obj runtime.Object, newFunc NewInternalInformerFunc) cache.SharedIndexInformer
VersionedInformerFor(obj runtime.Object, newFunc NewVersionedInformerFunc) cache.SharedIndexInformer
}