scottk/kubernetes
1
0
Fork 0
mirror of https://github.com/optim-enterprises-bv/kubernetes.git synced 2025-11-04 04:08:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

split generated informers by internal and external

Browse Source
This commit is contained in:
deads2k
2017-02-08 16:11:01 -05:00
parent 06e2a0820e
commit c5359fd059
4 changed files with 69 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -34,8 +34,7 @@ type factoryGenerator struct {
outputPackage string outputPackage string
imports namer.ImportTracker imports namer.ImportTracker
groupVersions map[string]clientgentypes.GroupVersions groupVersions map[string]clientgentypes.GroupVersions
internalClientSetPackage string clientSetPackage string
versionedClientSetPackage string
internalInterfacesPackage string internalInterfacesPackage string
filtered bool filtered bool
} }
@@ -73,20 +72,18 @@ func (g *factoryGenerator) GenerateType(c *generator.Context, t *types.Type, w i
gvNewFuncs[groupName] = c.Universe.Function(types.Name{Package: packageForGroup(g.outputPackage, g.groupVersions[groupName].Group), Name: "New"}) gvNewFuncs[groupName] = c.Universe.Function(types.Name{Package: packageForGroup(g.outputPackage, g.groupVersions[groupName].Group), Name: "New"})
} }
m := map[string]interface{}{ m := map[string]interface{}{
"cacheSharedIndexInformer": c.Universe.Type(cacheSharedIndexInformer), "cacheSharedIndexInformer": c.Universe.Type(cacheSharedIndexInformer),
"groupVersions": g.groupVersions, "groupVersions": g.groupVersions,
"gvInterfaces": gvInterfaces, "gvInterfaces": gvInterfaces,
"gvNewFuncs": gvNewFuncs, "gvNewFuncs": gvNewFuncs,
"interfacesNewInternalInformerFunc": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "NewInternalInformerFunc"}), "interfacesNewInformerFunc": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "NewInformerFunc"}),
"interfacesNewVersionedInformerFunc": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "NewVersionedInformerFunc"}), "informerFactoryInterface": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "SharedInformerFactory"}),
"informerFactoryInterface": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "SharedInformerFactory"}), "clientSetInterface": c.Universe.Type(types.Name{Package: g.clientSetPackage, Name: "Interface"}),
"internalClientSetInterface": c.Universe.Type(types.Name{Package: g.internalClientSetPackage, Name: "Interface"}), "reflectType": c.Universe.Type(reflectType),
"reflectType": c.Universe.Type(reflectType), "runtimeObject": c.Universe.Type(runtimeObject),
"runtimeObject": c.Universe.Type(runtimeObject), "schemaGroupVersionResource": c.Universe.Type(schemaGroupVersionResource),
"schemaGroupVersionResource": c.Universe.Type(schemaGroupVersionResource), "syncMutex": c.Universe.Type(syncMutex),
"syncMutex": c.Universe.Type(syncMutex), "timeDuration": c.Universe.Type(timeDuration),
"timeDuration": c.Universe.Type(timeDuration),
"versionedClientSetInterface": c.Universe.Type(types.Name{Package: g.versionedClientSetPackage, Name: "Interface"}),
} }
sw.Do(sharedInformerFactoryStruct, m) sw.Do(sharedInformerFactoryStruct, m)
@@ -97,8 +94,7 @@ func (g *factoryGenerator) GenerateType(c *generator.Context, t *types.Type, w i
var sharedInformerFactoryStruct = ` var sharedInformerFactoryStruct = `
type sharedInformerFactory struct { type sharedInformerFactory struct {
internalClient {{.internalClientSetInterface|raw}} client {{.clientSetInterface|raw}}
versionedClient {{.versionedClientSetInterface|raw}}
lock {{.syncMutex|raw}} lock {{.syncMutex|raw}}
defaultResync {{.timeDuration|raw}} defaultResync {{.timeDuration|raw}}
@@ -109,10 +105,9 @@ type sharedInformerFactory struct {
} }
// NewSharedInformerFactory constructs a new instance of sharedInformerFactory // NewSharedInformerFactory constructs a new instance of sharedInformerFactory
func NewSharedInformerFactory(internalClient {{.internalClientSetInterface|raw}}, versionedClient {{.versionedClientSetInterface|raw}}, defaultResync {{.timeDuration|raw}}) SharedInformerFactory { func NewSharedInformerFactory(client {{.clientSetInterface|raw}}, defaultResync {{.timeDuration|raw}}) SharedInformerFactory {
return &sharedInformerFactory{ return &sharedInformerFactory{
internalClient: internalClient, client: client,
versionedClient: versionedClient,
defaultResync: defaultResync, defaultResync: defaultResync,
informers: make(map[{{.reflectType|raw}}]{{.cacheSharedIndexInformer|raw}}), informers: make(map[{{.reflectType|raw}}]{{.cacheSharedIndexInformer|raw}}),
startedInformers: make(map[{{.reflectType|raw}}]bool), startedInformers: make(map[{{.reflectType|raw}}]bool),
@@ -134,7 +129,7 @@ func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {
// InternalInformerFor returns the SharedIndexInformer for obj using an internal // InternalInformerFor returns the SharedIndexInformer for obj using an internal
// client. // client.
func (f *sharedInformerFactory) InternalInformerFor(obj {{.runtimeObject|raw}}, newFunc {{.interfacesNewInternalInformerFunc|raw}}) {{.cacheSharedIndexInformer|raw}} { func (f *sharedInformerFactory) InformerFor(obj {{.runtimeObject|raw}}, newFunc {{.interfacesNewInformerFunc|raw}}) {{.cacheSharedIndexInformer|raw}} {
f.lock.Lock() f.lock.Lock()
defer f.lock.Unlock() defer f.lock.Unlock()
@@ -143,28 +138,12 @@ func (f *sharedInformerFactory) InternalInformerFor(obj {{.runtimeObject|raw}},
if exists { if exists {
return informer return informer
} }
informer = newFunc(f.internalClient, f.defaultResync) informer = newFunc(f.client, f.defaultResync)
f.informers[informerType] = informer f.informers[informerType] = informer
return informer return informer
} }
// VersionedInformerFor returns the SharedIndexInformer for obj using a
// versioned client.
func (f *sharedInformerFactory) VersionedInformerFor(obj {{.runtimeObject|raw}}, newFunc {{.interfacesNewVersionedInformerFunc|raw}}) {{.cacheSharedIndexInformer|raw}} {
f.lock.Lock()
defer f.lock.Unlock()
informerType := reflect.TypeOf(obj)
informer, exists := f.informers[informerType]
if exists {
return informer
}
informer = newFunc(f.versionedClient, f.defaultResync)
f.informers[informerType] = informer
return informer
}
` `
var sharedInformerFactoryInterface = ` var sharedInformerFactoryInterface = `

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

@@ -30,11 +30,10 @@ import (
// informer registration // informer registration
type factoryInterfaceGenerator struct { type factoryInterfaceGenerator struct {
generator.DefaultGen generator.DefaultGen
outputPackage string outputPackage string
imports namer.ImportTracker imports namer.ImportTracker
internalClientSetPackage string clientSetPackage string
versionedClientSetPackage string filtered bool
filtered bool
} }
var _ generator.Generator = &factoryInterfaceGenerator{} var _ generator.Generator = &factoryInterfaceGenerator{}
@@ -64,11 +63,10 @@ func (g *factoryInterfaceGenerator) GenerateType(c *generator.Context, t *types.
glog.V(5).Infof("processing type %v", t) glog.V(5).Infof("processing type %v", t)
m := map[string]interface{}{ m := map[string]interface{}{
"cacheSharedIndexInformer": c.Universe.Type(cacheSharedIndexInformer), "cacheSharedIndexInformer": c.Universe.Type(cacheSharedIndexInformer),
"internalClientSetInterface": c.Universe.Type(types.Name{Package: g.internalClientSetPackage, Name: "Interface"}), "clientSetPackage": c.Universe.Type(types.Name{Package: g.clientSetPackage, Name: "Interface"}),
"runtimeObject": c.Universe.Type(runtimeObject), "runtimeObject": c.Universe.Type(runtimeObject),
"timeDuration": c.Universe.Type(timeDuration), "timeDuration": c.Universe.Type(timeDuration),
"versionedClientSetInterface": c.Universe.Type(types.Name{Package: g.versionedClientSetPackage, Name: "Interface"}),
} }
sw.Do(externalSharedInformerFactoryInterface, m) sw.Do(externalSharedInformerFactoryInterface, m)
@@ -77,13 +75,11 @@ func (g *factoryInterfaceGenerator) GenerateType(c *generator.Context, t *types.
} }
var externalSharedInformerFactoryInterface = ` var externalSharedInformerFactoryInterface = `
type NewInternalInformerFunc func({{.internalClientSetInterface|raw}}, {{.timeDuration|raw}}) cache.SharedIndexInformer type NewInformerFunc func({{.clientSetPackage|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 // SharedInformerFactory a small interface to allow for adding an informer without an import cycle
type SharedInformerFactory interface { type SharedInformerFactory interface {
Start(stopCh <-chan struct{}) Start(stopCh <-chan struct{})
InternalInformerFor(obj {{.runtimeObject|raw}}, newFunc NewInternalInformerFunc) {{.cacheSharedIndexInformer|raw}} InformerFor(obj {{.runtimeObject|raw}}, newFunc NewInformerFunc) {{.cacheSharedIndexInformer|raw}}
VersionedInformerFor(obj {{.runtimeObject|raw}}, newFunc NewVersionedInformerFunc) {{.cacheSharedIndexInformer|raw}}
} }
` `

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

@@ -37,8 +37,7 @@ type informerGenerator struct {
groupVersion clientgentypes.GroupVersion groupVersion clientgentypes.GroupVersion
typeToGenerate *types.Type typeToGenerate *types.Type
imports namer.ImportTracker imports namer.ImportTracker
versionedClientSetPackage string clientSetPackage string
internalClientSetPackage string
listersPackage string listersPackage string
internalInterfacesPackage string internalInterfacesPackage string
} }
@@ -67,18 +66,8 @@ func (g *informerGenerator) GenerateType(c *generator.Context, t *types.Type, w
//listerPackage := "k8s.io/kubernetes/pkg/client/listers/" + g.groupVersion.Group.NonEmpty() + "/" + strings.ToLower(g.groupVersion.Version.NonEmpty()) //listerPackage := "k8s.io/kubernetes/pkg/client/listers/" + g.groupVersion.Group.NonEmpty() + "/" + strings.ToLower(g.groupVersion.Version.NonEmpty())
listerPackage := fmt.Sprintf("%s/%s/%s", g.listersPackage, g.groupVersion.Group.NonEmpty(), strings.ToLower(g.groupVersion.Version.NonEmpty())) listerPackage := fmt.Sprintf("%s/%s/%s", g.listersPackage, g.groupVersion.Group.NonEmpty(), strings.ToLower(g.groupVersion.Version.NonEmpty()))
clientSetInterface := c.Universe.Type(types.Name{Package: g.clientSetPackage, Name: "Interface"})
var ( informerFor := "InformerFor"
clientSetInterface *types.Type
informerFor string
)
if len(g.groupVersion.Version) == 0 {
clientSetInterface = c.Universe.Type(types.Name{Package: g.internalClientSetPackage, Name: "Interface"})
informerFor = "InternalInformerFor"
} else {
clientSetInterface = c.Universe.Type(types.Name{Package: g.versionedClientSetPackage, Name: "Interface"})
informerFor = "VersionedInformerFor"
}
m := map[string]interface{}{ m := map[string]interface{}{
"apiScheme": c.Universe.Type(apiScheme), "apiScheme": c.Universe.Type(apiScheme),

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

@@ -113,10 +113,14 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
glog.Fatalf("Wrong CustomArgs type: %T", arguments.CustomArgs) glog.Fatalf("Wrong CustomArgs type: %T", arguments.CustomArgs)
} }
internalVersionPackagePath := filepath.Join(arguments.OutputPackagePath, "internalversion")
externalVersionPackagePath := filepath.Join(arguments.OutputPackagePath, "externalversions")
var packageList generator.Packages var packageList generator.Packages
typesForGroupVersion := make(map[clientgentypes.GroupVersion][]*types.Type) typesForGroupVersion := make(map[clientgentypes.GroupVersion][]*types.Type)
groupVersions := make(map[string]clientgentypes.GroupVersions) externalGroupVersions := make(map[string]clientgentypes.GroupVersions)
internalGroupVersions := make(map[string]clientgentypes.GroupVersions)
for _, inputDir := range arguments.InputDirs { for _, inputDir := range arguments.InputDirs {
p := context.Universe.Package(inputDir) p := context.Universe.Package(inputDir)
@@ -130,6 +134,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
} }
var gv clientgentypes.GroupVersion var gv clientgentypes.GroupVersion
var targetGroupVersions map[string]clientgentypes.GroupVersions
if internal { if internal {
lastSlash := strings.LastIndex(p.Path, "/") lastSlash := strings.LastIndex(p.Path, "/")
@@ -137,10 +142,12 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
glog.Fatalf("error constructing internal group version for package %q", p.Path) glog.Fatalf("error constructing internal group version for package %q", p.Path)
} }
gv.Group = clientgentypes.Group(p.Path[lastSlash+1:]) gv.Group = clientgentypes.Group(p.Path[lastSlash+1:])
targetGroupVersions = internalGroupVersions
} else { } else {
parts := strings.Split(p.Path, "/") parts := strings.Split(p.Path, "/")
gv.Group = clientgentypes.Group(parts[len(parts)-2]) gv.Group = clientgentypes.Group(parts[len(parts)-2])
gv.Version = clientgentypes.Version(parts[len(parts)-1]) gv.Version = clientgentypes.Version(parts[len(parts)-1])
targetGroupVersions = externalGroupVersions
} }
var typesToGenerate []*types.Type var typesToGenerate []*types.Type
@@ -166,31 +173,45 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
} }
icGroupName := namer.IC(gv.Group.NonEmpty()) icGroupName := namer.IC(gv.Group.NonEmpty())
groupVersionsEntry, ok := groupVersions[icGroupName] groupVersionsEntry, ok := targetGroupVersions[icGroupName]
if !ok { if !ok {
groupVersionsEntry = clientgentypes.GroupVersions{ groupVersionsEntry = clientgentypes.GroupVersions{
Group: gv.Group, Group: gv.Group,
} }
} }
groupVersionsEntry.Versions = append(groupVersionsEntry.Versions, gv.Version) groupVersionsEntry.Versions = append(groupVersionsEntry.Versions, gv.Version)
groupVersions[icGroupName] = groupVersionsEntry targetGroupVersions[icGroupName] = groupVersionsEntry
orderer := namer.Orderer{Namer: namer.NewPrivateNamer(0)} orderer := namer.Orderer{Namer: namer.NewPrivateNamer(0)}
typesToGenerate = orderer.OrderTypes(typesToGenerate) typesToGenerate = orderer.OrderTypes(typesToGenerate)
packageList = append(packageList, versionPackage(arguments.OutputPackagePath, gv, boilerplate, typesToGenerate, customArgs.InternalClientSetPackage, customArgs.VersionedClientSetPackage, customArgs.ListersPackage)) if internal {
packageList = append(packageList, versionPackage(internalVersionPackagePath, gv, boilerplate, typesToGenerate, customArgs.InternalClientSetPackage, customArgs.ListersPackage))
} else {
packageList = append(packageList, versionPackage(externalVersionPackagePath, gv, boilerplate, typesToGenerate, customArgs.VersionedClientSetPackage, customArgs.ListersPackage))
}
} }
packageList = append(packageList, factoryInterfacePackage(arguments.OutputPackagePath, boilerplate, customArgs.InternalClientSetPackage, customArgs.VersionedClientSetPackage, typesForGroupVersion)) packageList = append(packageList, factoryInterfacePackage(externalVersionPackagePath, boilerplate, customArgs.VersionedClientSetPackage, typesForGroupVersion))
packageList = append(packageList, factoryPackage(arguments.OutputPackagePath, boilerplate, groupVersions, customArgs.InternalClientSetPackage, customArgs.VersionedClientSetPackage, typesForGroupVersion)) packageList = append(packageList, factoryPackage(externalVersionPackagePath, boilerplate, externalGroupVersions, customArgs.VersionedClientSetPackage, typesForGroupVersion))
for _, groupVersionsEntry := range groupVersions { for _, groupVersionsEntry := range externalGroupVersions {
packageList = append(packageList, groupPackage(arguments.OutputPackagePath, groupVersionsEntry, boilerplate)) packageList = append(packageList, groupPackage(externalVersionPackagePath, groupVersionsEntry, boilerplate))
}
packageList = append(packageList, factoryInterfacePackage(internalVersionPackagePath, boilerplate, customArgs.InternalClientSetPackage, typesForGroupVersion))
packageList = append(packageList, factoryPackage(internalVersionPackagePath, boilerplate, internalGroupVersions, customArgs.InternalClientSetPackage, typesForGroupVersion))
for _, groupVersionsEntry := range internalGroupVersions {
packageList = append(packageList, groupPackage(internalVersionPackagePath, groupVersionsEntry, boilerplate))
} }
return packageList return packageList
} }
func factoryPackage(basePackage string, boilerplate []byte, groupVersions map[string]clientgentypes.GroupVersions, internalClientSetPackage, versionedClientSetPackage string, typesForGroupVersion map[clientgentypes.GroupVersion][]*types.Type) generator.Package { func isInternalVersion(gv clientgentypes.GroupVersion) bool {
return len(gv.Version) == 0
}
func factoryPackage(basePackage string, boilerplate []byte, groupVersions map[string]clientgentypes.GroupVersions, clientSetPackage string, typesForGroupVersion map[clientgentypes.GroupVersion][]*types.Type) generator.Package {
return &generator.DefaultPackage{ return &generator.DefaultPackage{
PackageName: filepath.Base(basePackage), PackageName: filepath.Base(basePackage),
PackagePath: basePackage, PackagePath: basePackage,
@@ -203,8 +224,7 @@ func factoryPackage(basePackage string, boilerplate []byte, groupVersions map[st
outputPackage: basePackage, outputPackage: basePackage,
imports: generator.NewImportTracker(), imports: generator.NewImportTracker(),
groupVersions: groupVersions, groupVersions: groupVersions,
internalClientSetPackage: internalClientSetPackage, clientSetPackage: clientSetPackage,
versionedClientSetPackage: versionedClientSetPackage,
internalInterfacesPackage: packageForInternalInterfaces(basePackage), internalInterfacesPackage: packageForInternalInterfaces(basePackage),
}) })
@@ -223,7 +243,7 @@ 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 { func factoryInterfacePackage(basePackage string, boilerplate []byte, clientSetPackage string, typesForGroupVersion map[clientgentypes.GroupVersion][]*types.Type) generator.Package {
packagePath := packageForInternalInterfaces(basePackage) packagePath := packageForInternalInterfaces(basePackage)
return &generator.DefaultPackage{ return &generator.DefaultPackage{
@@ -233,12 +253,11 @@ func factoryInterfacePackage(basePackage string, boilerplate []byte, internalCli
GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) { GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
generators = append(generators, &factoryInterfaceGenerator{ generators = append(generators, &factoryInterfaceGenerator{
DefaultGen: generator.DefaultGen{ DefaultGen: generator.DefaultGen{
OptionalName: "internal_interfaces", OptionalName: "factory_interfaces",
}, },
outputPackage: packagePath, outputPackage: packagePath,
imports: generator.NewImportTracker(), imports: generator.NewImportTracker(),
internalClientSetPackage: internalClientSetPackage, clientSetPackage: clientSetPackage,
versionedClientSetPackage: versionedClientSetPackage,
}) })
return generators return generators
@@ -272,7 +291,7 @@ func groupPackage(basePackage string, groupVersions clientgentypes.GroupVersions
} }
} }
func versionPackage(basePackage string, gv clientgentypes.GroupVersion, boilerplate []byte, typesToGenerate []*types.Type, internalClientSetPackage, versionedClientSetPackage, listersPackage string) generator.Package { func versionPackage(basePackage string, gv clientgentypes.GroupVersion, boilerplate []byte, typesToGenerate []*types.Type, clientSetPackage, listersPackage string) generator.Package {
packagePath := filepath.Join(basePackage, strings.ToLower(gv.Group.NonEmpty()), strings.ToLower(gv.Version.NonEmpty())) packagePath := filepath.Join(basePackage, strings.ToLower(gv.Group.NonEmpty()), strings.ToLower(gv.Version.NonEmpty()))
return &generator.DefaultPackage{ return &generator.DefaultPackage{
@@ -299,8 +318,7 @@ func versionPackage(basePackage string, gv clientgentypes.GroupVersion, boilerpl
groupVersion: gv, groupVersion: gv,
typeToGenerate: t, typeToGenerate: t,
imports: generator.NewImportTracker(), imports: generator.NewImportTracker(),
internalClientSetPackage: internalClientSetPackage, clientSetPackage: clientSetPackage,
versionedClientSetPackage: versionedClientSetPackage,
listersPackage: listersPackage, listersPackage: listersPackage,
internalInterfacesPackage: packageForInternalInterfaces(basePackage), internalInterfacesPackage: packageForInternalInterfaces(basePackage),
}) })