split generated informers by internal and external

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
+	clientSetPackage          string
-	versionedClientSetPackage 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),
+		"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)
@@ -97,8 +94,7 @@ func (g *factoryGenerator) GenerateType(c *generator.Context, t *types.Type, w i
 
 var sharedInformerFactoryStruct = `
 type sharedInformerFactory struct {
-	internalClient {{.internalClientSetInterface|raw}}
+	client {{.clientSetInterface|raw}}
-	versionedClient {{.versionedClientSetInterface|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,
+		client: client,
-		versionedClient: versionedClient,
     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 = `

cmd/libs/go2idl/informer-gen/generators/factoryinterface.go

@@ -30,11 +30,10 @@ import (
 // informer registration
 type factoryInterfaceGenerator struct {
 	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{}
@@ -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),
+		"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)
@@ -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 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
 type SharedInformerFactory interface {
 	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}}
 }
 `

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
+	clientSetPackage          string
-	internalClientSetPackage  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()))
-
+	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{}{
 		"apiScheme":                       c.Universe.Type(apiScheme),

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, 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
 }
 
-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,
+				clientSetPackage:          clientSetPackage,
-				versionedClientSetPackage: versionedClientSetPackage,
 				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,
+				outputPackage:    packagePath,
-				imports:                   generator.NewImportTracker(),
+				imports:          generator.NewImportTracker(),
-				internalClientSetPackage:  internalClientSetPackage,
+				clientSetPackage: clientSetPackage,
-				versionedClientSetPackage: versionedClientSetPackage,
 			})
 
 			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,
+					clientSetPackage:          clientSetPackage,
-					versionedClientSetPackage: versionedClientSetPackage,
 					listersPackage:            listersPackage,
 					internalInterfacesPackage: packageForInternalInterfaces(basePackage),
 				})