diff --git a/cmd/libs/go2idl/informer-gen/generators/factory.go b/cmd/libs/go2idl/informer-gen/generators/factory.go index 883f052a938..5c2be00ab04 100644 --- a/cmd/libs/go2idl/informer-gen/generators/factory.go +++ b/cmd/libs/go2idl/informer-gen/generators/factory.go @@ -34,8 +34,7 @@ type factoryGenerator struct { outputPackage string imports namer.ImportTracker groupVersions map[string]clientgentypes.GroupVersions - internalClientSetPackage string - versionedClientSetPackage string + clientSetPackage string internalInterfacesPackage string 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"}) } m := map[string]interface{}{ - "cacheSharedIndexInformer": c.Universe.Type(cacheSharedIndexInformer), - "groupVersions": g.groupVersions, - "gvInterfaces": gvInterfaces, - "gvNewFuncs": gvNewFuncs, - "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), - "schemaGroupVersionResource": c.Universe.Type(schemaGroupVersionResource), - "syncMutex": c.Universe.Type(syncMutex), - "timeDuration": c.Universe.Type(timeDuration), - "versionedClientSetInterface": c.Universe.Type(types.Name{Package: g.versionedClientSetPackage, Name: "Interface"}), + "cacheSharedIndexInformer": c.Universe.Type(cacheSharedIndexInformer), + "groupVersions": g.groupVersions, + "gvInterfaces": gvInterfaces, + "gvNewFuncs": gvNewFuncs, + "interfacesNewInformerFunc": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "NewInformerFunc"}), + "informerFactoryInterface": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "SharedInformerFactory"}), + "clientSetInterface": c.Universe.Type(types.Name{Package: g.clientSetPackage, Name: "Interface"}), + "reflectType": c.Universe.Type(reflectType), + "runtimeObject": c.Universe.Type(runtimeObject), + "schemaGroupVersionResource": c.Universe.Type(schemaGroupVersionResource), + "syncMutex": c.Universe.Type(syncMutex), + "timeDuration": c.Universe.Type(timeDuration), } sw.Do(sharedInformerFactoryStruct, m) @@ -97,8 +94,7 @@ func (g *factoryGenerator) GenerateType(c *generator.Context, t *types.Type, w i var sharedInformerFactoryStruct = ` type sharedInformerFactory struct { - internalClient {{.internalClientSetInterface|raw}} - versionedClient {{.versionedClientSetInterface|raw}} + client {{.clientSetInterface|raw}} lock {{.syncMutex|raw}} defaultResync {{.timeDuration|raw}} @@ -109,10 +105,9 @@ type sharedInformerFactory struct { } // 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{ - internalClient: internalClient, - versionedClient: versionedClient, + client: client, defaultResync: defaultResync, informers: make(map[{{.reflectType|raw}}]{{.cacheSharedIndexInformer|raw}}), 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 // 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() defer f.lock.Unlock() @@ -143,28 +138,12 @@ func (f *sharedInformerFactory) InternalInformerFor(obj {{.runtimeObject|raw}}, if exists { return informer } - informer = newFunc(f.internalClient, f.defaultResync) + informer = newFunc(f.client, f.defaultResync) f.informers[informerType] = 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 = ` diff --git a/cmd/libs/go2idl/informer-gen/generators/factoryinterface.go b/cmd/libs/go2idl/informer-gen/generators/factoryinterface.go index f59b880c9e2..011fea20b3c 100644 --- a/cmd/libs/go2idl/informer-gen/generators/factoryinterface.go +++ b/cmd/libs/go2idl/informer-gen/generators/factoryinterface.go @@ -30,11 +30,10 @@ import ( // informer registration type factoryInterfaceGenerator struct { generator.DefaultGen - outputPackage string - imports namer.ImportTracker - internalClientSetPackage string - versionedClientSetPackage string - filtered bool + outputPackage string + imports namer.ImportTracker + clientSetPackage string + filtered bool } 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) 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"}), + "cacheSharedIndexInformer": c.Universe.Type(cacheSharedIndexInformer), + "clientSetPackage": c.Universe.Type(types.Name{Package: g.clientSetPackage, Name: "Interface"}), + "runtimeObject": c.Universe.Type(runtimeObject), + "timeDuration": c.Universe.Type(timeDuration), } sw.Do(externalSharedInformerFactoryInterface, m) @@ -77,13 +75,11 @@ func (g *factoryInterfaceGenerator) GenerateType(c *generator.Context, t *types. } var externalSharedInformerFactoryInterface = ` -type NewInternalInformerFunc func({{.internalClientSetInterface|raw}}, {{.timeDuration|raw}}) cache.SharedIndexInformer -type NewVersionedInformerFunc func({{.versionedClientSetInterface|raw}}, {{.timeDuration|raw}}) cache.SharedIndexInformer +type NewInformerFunc func({{.clientSetPackage|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}} + InformerFor(obj {{.runtimeObject|raw}}, newFunc NewInformerFunc) {{.cacheSharedIndexInformer|raw}} } ` diff --git a/cmd/libs/go2idl/informer-gen/generators/informer.go b/cmd/libs/go2idl/informer-gen/generators/informer.go index 079845321b1..e48be0fce5b 100644 --- a/cmd/libs/go2idl/informer-gen/generators/informer.go +++ b/cmd/libs/go2idl/informer-gen/generators/informer.go @@ -37,8 +37,7 @@ type informerGenerator struct { groupVersion clientgentypes.GroupVersion typeToGenerate *types.Type imports namer.ImportTracker - versionedClientSetPackage string - internalClientSetPackage string + clientSetPackage string listersPackage 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 := fmt.Sprintf("%s/%s/%s", g.listersPackage, g.groupVersion.Group.NonEmpty(), strings.ToLower(g.groupVersion.Version.NonEmpty())) - - var ( - 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" - } + clientSetInterface := c.Universe.Type(types.Name{Package: g.clientSetPackage, Name: "Interface"}) + informerFor := "InformerFor" m := map[string]interface{}{ "apiScheme": c.Universe.Type(apiScheme), diff --git a/cmd/libs/go2idl/informer-gen/generators/packages.go b/cmd/libs/go2idl/informer-gen/generators/packages.go index a6d581c2de1..1f3ffcbe4d8 100644 --- a/cmd/libs/go2idl/informer-gen/generators/packages.go +++ b/cmd/libs/go2idl/informer-gen/generators/packages.go @@ -113,10 +113,14 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat glog.Fatalf("Wrong CustomArgs type: %T", arguments.CustomArgs) } + internalVersionPackagePath := filepath.Join(arguments.OutputPackagePath, "internalversion") + externalVersionPackagePath := filepath.Join(arguments.OutputPackagePath, "externalversions") + var packageList generator.Packages 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 { p := context.Universe.Package(inputDir) @@ -130,6 +134,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat } var gv clientgentypes.GroupVersion + var targetGroupVersions map[string]clientgentypes.GroupVersions if internal { 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) } gv.Group = clientgentypes.Group(p.Path[lastSlash+1:]) + targetGroupVersions = internalGroupVersions } else { parts := strings.Split(p.Path, "/") gv.Group = clientgentypes.Group(parts[len(parts)-2]) gv.Version = clientgentypes.Version(parts[len(parts)-1]) + targetGroupVersions = externalGroupVersions } var typesToGenerate []*types.Type @@ -166,31 +173,45 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat } icGroupName := namer.IC(gv.Group.NonEmpty()) - groupVersionsEntry, ok := groupVersions[icGroupName] + groupVersionsEntry, ok := targetGroupVersions[icGroupName] if !ok { groupVersionsEntry = clientgentypes.GroupVersions{ Group: gv.Group, } } groupVersionsEntry.Versions = append(groupVersionsEntry.Versions, gv.Version) - groupVersions[icGroupName] = groupVersionsEntry + targetGroupVersions[icGroupName] = groupVersionsEntry orderer := namer.Orderer{Namer: namer.NewPrivateNamer(0)} 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, factoryPackage(arguments.OutputPackagePath, boilerplate, groupVersions, customArgs.InternalClientSetPackage, customArgs.VersionedClientSetPackage, typesForGroupVersion)) - for _, groupVersionsEntry := range groupVersions { - packageList = append(packageList, groupPackage(arguments.OutputPackagePath, groupVersionsEntry, boilerplate)) + packageList = append(packageList, factoryInterfacePackage(externalVersionPackagePath, boilerplate, customArgs.VersionedClientSetPackage, typesForGroupVersion)) + packageList = append(packageList, factoryPackage(externalVersionPackagePath, boilerplate, externalGroupVersions, customArgs.VersionedClientSetPackage, typesForGroupVersion)) + for _, groupVersionsEntry := range externalGroupVersions { + 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 } -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{ PackageName: filepath.Base(basePackage), PackagePath: basePackage, @@ -203,8 +224,7 @@ func factoryPackage(basePackage string, boilerplate []byte, groupVersions map[st outputPackage: basePackage, imports: generator.NewImportTracker(), groupVersions: groupVersions, - internalClientSetPackage: internalClientSetPackage, - versionedClientSetPackage: versionedClientSetPackage, + clientSetPackage: clientSetPackage, 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) return &generator.DefaultPackage{ @@ -233,12 +253,11 @@ func factoryInterfacePackage(basePackage string, boilerplate []byte, internalCli GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) { generators = append(generators, &factoryInterfaceGenerator{ DefaultGen: generator.DefaultGen{ - OptionalName: "internal_interfaces", + OptionalName: "factory_interfaces", }, - outputPackage: packagePath, - imports: generator.NewImportTracker(), - internalClientSetPackage: internalClientSetPackage, - versionedClientSetPackage: versionedClientSetPackage, + outputPackage: packagePath, + imports: generator.NewImportTracker(), + clientSetPackage: clientSetPackage, }) 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())) return &generator.DefaultPackage{ @@ -299,8 +318,7 @@ func versionPackage(basePackage string, gv clientgentypes.GroupVersion, boilerpl groupVersion: gv, typeToGenerate: t, imports: generator.NewImportTracker(), - internalClientSetPackage: internalClientSetPackage, - versionedClientSetPackage: versionedClientSetPackage, + clientSetPackage: clientSetPackage, listersPackage: listersPackage, internalInterfacesPackage: packageForInternalInterfaces(basePackage), })