update informer generator

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

@@ -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),
+		"interfacesNewInternalInformerFunc":  c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "NewInternalInformerFunc"}),
-		"interfacesNewVersionedInformerFunc": c.Universe.Type(interfacesNewVersionedInformerFunc),
+		"interfacesNewVersionedInformerFunc": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "NewVersionedInformerFunc"}),
-		"interfacesSharedInformerFactory":    c.Universe.Type(interfacesSharedInformerFactory),
+		"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}}

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

@@ -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}}
+}
+`

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

@@ -30,10 +30,11 @@ import (
 // groupInterfaceGenerator generates the per-group interface file.
 type groupInterfaceGenerator struct {
 	generator.DefaultGen
-	outputPackage string
+	outputPackage             string
-	imports       namer.ImportTracker
+	imports                   namer.ImportTracker
-	groupVersions clientgentypes.GroupVersions
+	groupVersions             clientgentypes.GroupVersions
-	filtered      bool
+	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,
 	}
 

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

@@ -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,

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

@@ -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()))
 
@@ -237,9 +266,10 @@ func groupPackage(basePackage string, groupVersions clientgentypes.GroupVersions
 				DefaultGen: generator.DefaultGen{
 					OptionalName: "interface",
 				},
-				outputPackage: packagePath,
+				outputPackage:             packagePath,
-				groupVersions: groupVersions,
+				groupVersions:             groupVersions,
-				imports:       generator.NewImportTracker(),
+				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

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

@@ -19,27 +19,24 @@ package generators
 import "k8s.io/gengo/types"
 
 var (
-	apiNamespaceAll                    = types.Name{Package: "k8s.io/kubernetes/pkg/api", Name: "NamespaceAll"}
+	apiNamespaceAll             = types.Name{Package: "k8s.io/kubernetes/pkg/api", Name: "NamespaceAll"}
-	apiScheme                          = types.Name{Package: "k8s.io/kubernetes/pkg/api", Name: "Scheme"}
+	apiScheme                   = types.Name{Package: "k8s.io/kubernetes/pkg/api", Name: "Scheme"}
-	cacheGenericLister                 = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "GenericLister"}
+	cacheGenericLister          = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "GenericLister"}
-	cacheIndexers                      = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "Indexers"}
+	cacheIndexers               = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "Indexers"}
-	cacheListWatch                     = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "ListWatch"}
+	cacheListWatch              = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "ListWatch"}
-	cacheMetaNamespaceIndexFunc        = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "MetaNamespaceIndexFunc"}
+	cacheMetaNamespaceIndexFunc = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "MetaNamespaceIndexFunc"}
-	cacheNamespaceIndex                = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "NamespaceIndex"}
+	cacheNamespaceIndex         = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "NamespaceIndex"}
-	cacheNewGenericLister              = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "NewGenericLister"}
+	cacheNewGenericLister       = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "NewGenericLister"}
-	cacheNewSharedIndexInformer        = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "NewSharedIndexInformer"}
+	cacheNewSharedIndexInformer = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "NewSharedIndexInformer"}
-	cacheSharedIndexInformer           = types.Name{Package: "k8s.io/kubernetes/pkg/client/cache", Name: "SharedIndexInformer"}
+	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"}
+	listOptions                 = types.Name{Package: "k8s.io/kubernetes/pkg/api", Name: "ListOptions"}
-	interfacesNewVersionedInformerFunc = types.Name{Package: "k8s.io/kubernetes/pkg/client/informers/interfaces", Name: "NewVersionedInformerFunc"}
+	reflectType                 = types.Name{Package: "reflect", Name: "Type"}
-	interfacesSharedInformerFactory    = types.Name{Package: "k8s.io/kubernetes/pkg/client/informers/interfaces", Name: "SharedInformerFactory"}
+	runtimeObject               = types.Name{Package: "k8s.io/kubernetes/pkg/runtime", Name: "Object"}
-	listOptions                        = types.Name{Package: "k8s.io/kubernetes/pkg/api", Name: "ListOptions"}
+	schemaGroupResource         = types.Name{Package: "k8s.io/kubernetes/pkg/runtime/schema", Name: "GroupResource"}
-	reflectType                        = types.Name{Package: "reflect", Name: "Type"}
+	schemaGroupVersionResource  = types.Name{Package: "k8s.io/kubernetes/pkg/runtime/schema", Name: "GroupVersionResource"}
-	runtimeObject                      = types.Name{Package: "k8s.io/kubernetes/pkg/runtime", Name: "Object"}
+	syncMutex                   = types.Name{Package: "sync", Name: "Mutex"}
-	schemaGroupResource                = types.Name{Package: "k8s.io/kubernetes/pkg/runtime/schema", Name: "GroupResource"}
+	timeDuration                = types.Name{Package: "time", Name: "Duration"}
-	schemaGroupVersionResource         = types.Name{Package: "k8s.io/kubernetes/pkg/runtime/schema", Name: "GroupVersionResource"}
+	v1ListOptions               = types.Name{Package: "k8s.io/kubernetes/pkg/api/v1", Name: "ListOptions"}
-	syncMutex                          = types.Name{Package: "sync", Name: "Mutex"}
+	v1NamespaceAll              = types.Name{Package: "k8s.io/kubernetes/pkg/api/v1", Name: "NamespaceAll"}
-	timeDuration                       = types.Name{Package: "time", Name: "Duration"}
+	watchInterface              = types.Name{Package: "k8s.io/kubernetes/pkg/watch", Name: "Interface"}
-	v1ListOptions                      = types.Name{Package: "k8s.io/kubernetes/pkg/api/v1", Name: "ListOptions"}
-	v1NamespaceAll                     = types.Name{Package: "k8s.io/kubernetes/pkg/api/v1", Name: "NamespaceAll"}
-	watchInterface                     = types.Name{Package: "k8s.io/kubernetes/pkg/watch", Name: "Interface"}
 )

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

@@ -27,10 +27,11 @@ import (
 // versionInterfaceGenerator generates the per-version interface file.
 type versionInterfaceGenerator struct {
 	generator.DefaultGen
-	outputPackage string
+	outputPackage             string
-	imports       namer.ImportTracker
+	imports                   namer.ImportTracker
-	types         []*types.Type
+	types                     []*types.Type
-	filtered      bool
+	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,
 	}
 

pkg/client/informers/interfaces/BUILD

@@ -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",
-    ],
-)

pkg/client/informers/interfaces/interface.go

@@ -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
-}