Custom resource definition

Co-authored-by: Mathieu Lonjaret <mathieu.lonjaret@gmail.com>

vendor/k8s.io/code-generator/cmd/informer-gen/args/args.go

@@ -0,0 +1,77 @@
+/*
+Copyright 2017 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 args
+
+import (
+	"fmt"
+	"path"
+
+	"github.com/spf13/pflag"
+	codegenutil "k8s.io/code-generator/pkg/util"
+	"k8s.io/gengo/args"
+)
+
+// CustomArgs is used by the gengo framework to pass args specific to this generator.
+type CustomArgs struct {
+	VersionedClientSetPackage string
+	InternalClientSetPackage  string
+	ListersPackage            string
+	SingleDirectory           bool
+}
+
+// NewDefaults returns default arguments for the generator.
+func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
+	genericArgs := args.Default().WithoutDefaultFlagParsing()
+	customArgs := &CustomArgs{
+		SingleDirectory: false,
+	}
+	genericArgs.CustomArgs = customArgs
+
+	if pkg := codegenutil.CurrentPackage(); len(pkg) != 0 {
+		genericArgs.OutputPackagePath = path.Join(pkg, "pkg/client/informers")
+		customArgs.VersionedClientSetPackage = path.Join(pkg, "pkg/client/clientset/versioned")
+		customArgs.InternalClientSetPackage = path.Join(pkg, "pkg/client/clientset/internalversion")
+		customArgs.ListersPackage = path.Join(pkg, "pkg/client/listers")
+	}
+
+	return genericArgs, customArgs
+}
+
+// AddFlags add the generator flags to the flag set.
+func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
+	fs.StringVar(&ca.InternalClientSetPackage, "internal-clientset-package", ca.InternalClientSetPackage, "the full package name for the internal clientset to use")
+	fs.StringVar(&ca.VersionedClientSetPackage, "versioned-clientset-package", ca.VersionedClientSetPackage, "the full package name for the versioned clientset to use")
+	fs.StringVar(&ca.ListersPackage, "listers-package", ca.ListersPackage, "the full package name for the listers to use")
+	fs.BoolVar(&ca.SingleDirectory, "single-directory", ca.SingleDirectory, "if true, omit the intermediate \"internalversion\" and \"externalversions\" subdirectories")
+}
+
+// Validate checks the given arguments.
+func Validate(genericArgs *args.GeneratorArgs) error {
+	customArgs := genericArgs.CustomArgs.(*CustomArgs)
+
+	if len(genericArgs.OutputPackagePath) == 0 {
+		return fmt.Errorf("output package cannot be empty")
+	}
+	if len(customArgs.VersionedClientSetPackage) == 0 {
+		return fmt.Errorf("versioned clientset package cannot be empty")
+	}
+	if len(customArgs.ListersPackage) == 0 {
+		return fmt.Errorf("listers package cannot be empty")
+	}
+
+	return nil
+}

vendor/k8s.io/code-generator/cmd/informer-gen/generators/factory.go

@@ -0,0 +1,258 @@
+/*
+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"
+	"path"
+
+	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
+	"k8s.io/gengo/generator"
+	"k8s.io/gengo/namer"
+	"k8s.io/gengo/types"
+
+	"github.com/golang/glog"
+)
+
+// factoryGenerator produces a file of listers for a given GroupVersion and
+// type.
+type factoryGenerator struct {
+	generator.DefaultGen
+	outputPackage             string
+	imports                   namer.ImportTracker
+	groupVersions             map[string]clientgentypes.GroupVersions
+	gvGoNames                 map[string]string
+	clientSetPackage          string
+	internalInterfacesPackage string
+	filtered                  bool
+}
+
+var _ generator.Generator = &factoryGenerator{}
+
+func (g *factoryGenerator) Filter(c *generator.Context, t *types.Type) bool {
+	if !g.filtered {
+		g.filtered = true
+		return true
+	}
+	return false
+}
+
+func (g *factoryGenerator) Namers(c *generator.Context) namer.NameSystems {
+	return namer.NameSystems{
+		"raw": namer.NewRawNamer(g.outputPackage, g.imports),
+	}
+}
+
+func (g *factoryGenerator) Imports(c *generator.Context) (imports []string) {
+	imports = append(imports, g.imports.ImportLines()...)
+	return
+}
+
+func (g *factoryGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
+	sw := generator.NewSnippetWriter(w, c, "{{", "}}")
+
+	glog.V(5).Infof("processing type %v", t)
+
+	gvInterfaces := make(map[string]*types.Type)
+	gvNewFuncs := make(map[string]*types.Type)
+	for groupPkgName := range g.groupVersions {
+		gvInterfaces[groupPkgName] = c.Universe.Type(types.Name{Package: path.Join(g.outputPackage, groupPkgName), Name: "Interface"})
+		gvNewFuncs[groupPkgName] = c.Universe.Function(types.Name{Package: path.Join(g.outputPackage, groupPkgName), Name: "New"})
+	}
+	m := map[string]interface{}{
+		"cacheSharedIndexInformer":       c.Universe.Type(cacheSharedIndexInformer),
+		"groupVersions":                  g.groupVersions,
+		"gvInterfaces":                   gvInterfaces,
+		"gvNewFuncs":                     gvNewFuncs,
+		"gvGoNames":                      g.gvGoNames,
+		"interfacesNewInformerFunc":      c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "NewInformerFunc"}),
+		"interfacesTweakListOptionsFunc": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "TweakListOptionsFunc"}),
+		"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),
+		"namespaceAll":                   c.Universe.Type(metav1NamespaceAll),
+		"object":                         c.Universe.Type(metav1Object),
+	}
+
+	sw.Do(sharedInformerFactoryStruct, m)
+	sw.Do(sharedInformerFactoryInterface, m)
+
+	return sw.Error()
+}
+
+var sharedInformerFactoryStruct = `
+// SharedInformerOption defines the functional option type for SharedInformerFactory.
+type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory
+
+type sharedInformerFactory struct {
+	client {{.clientSetInterface|raw}}
+	namespace string
+	tweakListOptions {{.interfacesTweakListOptionsFunc|raw}}
+	lock {{.syncMutex|raw}}
+	defaultResync {{.timeDuration|raw}}
+	customResync map[{{.reflectType|raw}}]{{.timeDuration|raw}}
+
+	informers map[{{.reflectType|raw}}]{{.cacheSharedIndexInformer|raw}}
+	// startedInformers is used for tracking which informers have been started.
+	// This allows Start() to be called multiple times safely.
+	startedInformers map[{{.reflectType|raw}}]bool
+}
+
+// WithCustomResyncConfig sets a custom resync period for the specified informer types.
+func WithCustomResyncConfig(resyncConfig map[{{.object|raw}}]{{.timeDuration|raw}}) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		for k, v := range resyncConfig {
+			factory.customResync[reflect.TypeOf(k)] = v
+		}
+		return factory
+	}
+}
+
+// WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory.
+func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		factory.tweakListOptions = tweakListOptions
+		return factory
+	}
+}
+
+// WithNamespace limits the SharedInformerFactory to the specified namespace.
+func WithNamespace(namespace string) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		factory.namespace = namespace
+		return factory
+	}
+}
+
+// NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces.
+func NewSharedInformerFactory(client {{.clientSetInterface|raw}}, defaultResync {{.timeDuration|raw}}) SharedInformerFactory {
+	return NewSharedInformerFactoryWithOptions(client, defaultResync)
+}
+
+// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory.
+// Listers obtained via this SharedInformerFactory will be subject to the same filters
+// as specified here.
+// Deprecated: Please use NewSharedInformerFactoryWithOptions instead
+func NewFilteredSharedInformerFactory(client {{.clientSetInterface|raw}}, defaultResync {{.timeDuration|raw}}, namespace string, tweakListOptions {{.interfacesTweakListOptionsFunc|raw}}) SharedInformerFactory {
+	return NewSharedInformerFactoryWithOptions(client, defaultResync, WithNamespace(namespace), WithTweakListOptions(tweakListOptions)) 
+}
+
+// NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options.
+func NewSharedInformerFactoryWithOptions(client {{.clientSetInterface|raw}}, defaultResync {{.timeDuration|raw}}, options ...SharedInformerOption) SharedInformerFactory {
+	factory := &sharedInformerFactory{
+		client:           client,
+		namespace:        v1.NamespaceAll,
+		defaultResync:    defaultResync,
+		informers:        make(map[{{.reflectType|raw}}]{{.cacheSharedIndexInformer|raw}}),
+		startedInformers: make(map[{{.reflectType|raw}}]bool),
+		customResync:     make(map[{{.reflectType|raw}}]{{.timeDuration|raw}}),
+	}
+	
+	// Apply all options
+	for _, opt := range options {
+		factory = opt(factory)
+	}
+
+	return factory
+}
+
+// Start initializes all requested informers.
+func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {
+  f.lock.Lock()
+  defer f.lock.Unlock()
+
+  for informerType, informer := range f.informers {
+    if !f.startedInformers[informerType] {
+      go informer.Run(stopCh)
+      f.startedInformers[informerType] = true
+    }
+  }
+}
+
+// WaitForCacheSync waits for all started informers' cache were synced.
+func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool {
+	informers := func()map[reflect.Type]cache.SharedIndexInformer{
+               f.lock.Lock()
+               defer f.lock.Unlock()
+
+               informers := map[reflect.Type]cache.SharedIndexInformer{}
+               for informerType, informer := range f.informers {
+                       if f.startedInformers[informerType] {
+                               informers[informerType] = informer
+                       }
+               }
+               return informers
+       }()
+
+       res := map[reflect.Type]bool{}
+       for informType, informer := range informers {
+               res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced)
+       }
+       return res
+}
+
+// InternalInformerFor returns the SharedIndexInformer for obj using an internal
+// client.
+func (f *sharedInformerFactory) InformerFor(obj {{.runtimeObject|raw}}, newFunc {{.interfacesNewInformerFunc|raw}}) {{.cacheSharedIndexInformer|raw}} {
+  f.lock.Lock()
+  defer f.lock.Unlock()
+
+  informerType := reflect.TypeOf(obj)
+  informer, exists := f.informers[informerType]
+  if exists {
+    return informer
+  }
+
+  resyncPeriod, exists := f.customResync[informerType]
+  if !exists {
+    resyncPeriod = f.defaultResync
+  }
+
+  informer = newFunc(f.client, resyncPeriod)
+  f.informers[informerType] = informer
+
+  return informer
+}
+
+`
+
+var sharedInformerFactoryInterface = `
+// SharedInformerFactory provides shared informers for resources in all known
+// API group versions.
+type SharedInformerFactory interface {
+	{{.informerFactoryInterface|raw}}
+	ForResource(resource {{.schemaGroupVersionResource|raw}}) (GenericInformer, error)
+	WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool
+
+	{{$gvInterfaces := .gvInterfaces}}
+	{{$gvGoNames := .gvGoNames}}
+	{{range $groupName, $group := .groupVersions}}{{index $gvGoNames $groupName}}() {{index $gvInterfaces $groupName|raw}}
+	{{end}}
+}
+
+{{$gvNewFuncs := .gvNewFuncs}}
+{{$gvGoNames := .gvGoNames}}
+{{range $groupPkgName, $group := .groupVersions}}
+func (f *sharedInformerFactory) {{index $gvGoNames $groupPkgName}}() {{index $gvInterfaces $groupPkgName|raw}} {
+  return {{index $gvNewFuncs $groupPkgName|raw}}(f, f.namespace, f.tweakListOptions)
+}
+{{end}}
+`

vendor/k8s.io/code-generator/cmd/informer-gen/generators/factoryinterface.go

@@ -0,0 +1,88 @@
+/*
+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
+	clientSetPackage 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),
+		"clientSetPackage":         c.Universe.Type(types.Name{Package: g.clientSetPackage, Name: "Interface"}),
+		"runtimeObject":            c.Universe.Type(runtimeObject),
+		"timeDuration":             c.Universe.Type(timeDuration),
+		"v1ListOptions":            c.Universe.Type(v1ListOptions),
+	}
+
+	sw.Do(externalSharedInformerFactoryInterface, m)
+
+	return sw.Error()
+}
+
+var externalSharedInformerFactoryInterface = `
+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{})
+	InformerFor(obj {{.runtimeObject|raw}}, newFunc NewInformerFunc) {{.cacheSharedIndexInformer|raw}}
+}
+
+type TweakListOptionsFunc func(*{{.v1ListOptions|raw}})
+`

vendor/k8s.io/code-generator/cmd/informer-gen/generators/generic.go

@@ -0,0 +1,180 @@
+/*
+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"
+	"sort"
+	"strings"
+
+	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
+	"k8s.io/gengo/generator"
+	"k8s.io/gengo/namer"
+	"k8s.io/gengo/types"
+)
+
+// genericGenerator generates the generic informer.
+type genericGenerator struct {
+	generator.DefaultGen
+	outputPackage        string
+	imports              namer.ImportTracker
+	groupVersions        map[string]clientgentypes.GroupVersions
+	groupGoNames         map[string]string
+	typesForGroupVersion map[clientgentypes.GroupVersion][]*types.Type
+	filtered             bool
+}
+
+var _ generator.Generator = &genericGenerator{}
+
+func (g *genericGenerator) Filter(c *generator.Context, t *types.Type) bool {
+	if !g.filtered {
+		g.filtered = true
+		return true
+	}
+	return false
+}
+
+func (g *genericGenerator) Namers(c *generator.Context) namer.NameSystems {
+	pluralExceptions := map[string]string{
+		"Endpoints": "Endpoints",
+	}
+	return namer.NameSystems{
+		"raw":                namer.NewRawNamer(g.outputPackage, g.imports),
+		"allLowercasePlural": namer.NewAllLowercasePluralNamer(pluralExceptions),
+		"publicPlural":       namer.NewPublicPluralNamer(pluralExceptions),
+	}
+}
+
+func (g *genericGenerator) Imports(c *generator.Context) (imports []string) {
+	imports = append(imports, g.imports.ImportLines()...)
+	imports = append(imports, "fmt")
+	return
+}
+
+type group struct {
+	GroupGoName string
+	Name        string
+	Versions    []*version
+}
+
+type groupSort []group
+
+func (g groupSort) Len() int           { return len(g) }
+func (g groupSort) Less(i, j int) bool { return strings.ToLower(g[i].Name) < strings.ToLower(g[j].Name) }
+func (g groupSort) Swap(i, j int)      { g[i], g[j] = g[j], g[i] }
+
+type version struct {
+	Name      string
+	GoName    string
+	Resources []*types.Type
+}
+
+type versionSort []*version
+
+func (v versionSort) Len() int { return len(v) }
+func (v versionSort) Less(i, j int) bool {
+	return strings.ToLower(v[i].Name) < strings.ToLower(v[j].Name)
+}
+func (v versionSort) Swap(i, j int) { v[i], v[j] = v[j], v[i] }
+
+func (g *genericGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
+	sw := generator.NewSnippetWriter(w, c, "{{", "}}")
+
+	groups := []group{}
+	schemeGVs := make(map[*version]*types.Type)
+
+	orderer := namer.Orderer{Namer: namer.NewPrivateNamer(0)}
+	for groupPackageName, groupVersions := range g.groupVersions {
+		group := group{
+			GroupGoName: g.groupGoNames[groupPackageName],
+			Name:        groupVersions.Group.NonEmpty(),
+			Versions:    []*version{},
+		}
+		for _, v := range groupVersions.Versions {
+			gv := clientgentypes.GroupVersion{Group: groupVersions.Group, Version: v.Version}
+			version := &version{
+				Name:      v.Version.NonEmpty(),
+				GoName:    namer.IC(v.Version.NonEmpty()),
+				Resources: orderer.OrderTypes(g.typesForGroupVersion[gv]),
+			}
+			schemeGVs[version] = c.Universe.Variable(types.Name{Package: g.typesForGroupVersion[gv][0].Name.Package, Name: "SchemeGroupVersion"})
+			group.Versions = append(group.Versions, version)
+		}
+		sort.Sort(versionSort(group.Versions))
+		groups = append(groups, group)
+	}
+	sort.Sort(groupSort(groups))
+
+	m := map[string]interface{}{
+		"cacheGenericLister":         c.Universe.Type(cacheGenericLister),
+		"cacheNewGenericLister":      c.Universe.Function(cacheNewGenericLister),
+		"cacheSharedIndexInformer":   c.Universe.Type(cacheSharedIndexInformer),
+		"groups":                     groups,
+		"schemeGVs":                  schemeGVs,
+		"schemaGroupResource":        c.Universe.Type(schemaGroupResource),
+		"schemaGroupVersionResource": c.Universe.Type(schemaGroupVersionResource),
+	}
+
+	sw.Do(genericInformer, m)
+	sw.Do(forResource, m)
+
+	return sw.Error()
+}
+
+var genericInformer = `
+// GenericInformer is type of SharedIndexInformer which will locate and delegate to other
+// sharedInformers based on type
+type GenericInformer interface {
+	Informer() {{.cacheSharedIndexInformer|raw}}
+	Lister() {{.cacheGenericLister|raw}}
+}
+
+type genericInformer struct {
+	informer {{.cacheSharedIndexInformer|raw}}
+	resource {{.schemaGroupResource|raw}}
+}
+
+// Informer returns the SharedIndexInformer.
+func (f *genericInformer) Informer() {{.cacheSharedIndexInformer|raw}} {
+	return f.informer
+}
+
+// Lister returns the GenericLister.
+func (f *genericInformer) Lister() {{.cacheGenericLister|raw}} {
+	return {{.cacheNewGenericLister|raw}}(f.Informer().GetIndexer(), f.resource)
+}
+`
+
+var forResource = `
+// ForResource gives generic access to a shared informer of the matching type
+// TODO extend this to unknown resources with a client pool
+func (f *sharedInformerFactory) ForResource(resource {{.schemaGroupVersionResource|raw}}) (GenericInformer, error) {
+	switch resource {
+		{{range $group := .groups -}}{{$GroupGoName := .GroupGoName -}}
+			{{range $version := .Versions -}}
+	// Group={{$group.Name}}, Version={{.Name}}
+				{{range .Resources -}}
+	case {{index $.schemeGVs $version|raw}}.WithResource("{{.|allLowercasePlural}}"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.{{$GroupGoName}}().{{$version.GoName}}().{{.|publicPlural}}().Informer()}, nil
+				{{end}}
+			{{end}}
+		{{end -}}
+	}
+
+	return nil, fmt.Errorf("no informer found for %v", resource)
+}
+`

vendor/k8s.io/code-generator/cmd/informer-gen/generators/groupinterface.go

@@ -0,0 +1,118 @@
+/*
+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"
+	"path/filepath"
+	"strings"
+
+	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
+	"k8s.io/gengo/generator"
+	"k8s.io/gengo/namer"
+	"k8s.io/gengo/types"
+)
+
+// groupInterfaceGenerator generates the per-group interface file.
+type groupInterfaceGenerator struct {
+	generator.DefaultGen
+	outputPackage             string
+	imports                   namer.ImportTracker
+	groupVersions             clientgentypes.GroupVersions
+	filtered                  bool
+	internalInterfacesPackage string
+}
+
+var _ generator.Generator = &groupInterfaceGenerator{}
+
+func (g *groupInterfaceGenerator) Filter(c *generator.Context, t *types.Type) bool {
+	if !g.filtered {
+		g.filtered = true
+		return true
+	}
+	return false
+}
+
+func (g *groupInterfaceGenerator) Namers(c *generator.Context) namer.NameSystems {
+	return namer.NameSystems{
+		"raw": namer.NewRawNamer(g.outputPackage, g.imports),
+	}
+}
+
+func (g *groupInterfaceGenerator) Imports(c *generator.Context) (imports []string) {
+	imports = append(imports, g.imports.ImportLines()...)
+	return
+}
+
+type versionData struct {
+	Name      string
+	Interface *types.Type
+	New       *types.Type
+}
+
+func (g *groupInterfaceGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
+	sw := generator.NewSnippetWriter(w, c, "$", "$")
+
+	versions := make([]versionData, 0, len(g.groupVersions.Versions))
+	for _, version := range g.groupVersions.Versions {
+		gv := clientgentypes.GroupVersion{Group: g.groupVersions.Group, Version: version.Version}
+		versionPackage := filepath.Join(g.outputPackage, strings.ToLower(gv.Version.NonEmpty()))
+		iface := c.Universe.Type(types.Name{Package: versionPackage, Name: "Interface"})
+		versions = append(versions, versionData{
+			Name:      namer.IC(version.Version.NonEmpty()),
+			Interface: iface,
+			New:       c.Universe.Function(types.Name{Package: versionPackage, Name: "New"}),
+		})
+	}
+	m := map[string]interface{}{
+		"interfacesTweakListOptionsFunc":  c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "TweakListOptionsFunc"}),
+		"interfacesSharedInformerFactory": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "SharedInformerFactory"}),
+		"versions":                        versions,
+	}
+
+	sw.Do(groupTemplate, m)
+
+	return sw.Error()
+}
+
+var groupTemplate = `
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	$range .versions -$
+		// $.Name$ provides access to shared informers for resources in $.Name$.
+		$.Name$() $.Interface|raw$
+	$end$
+}
+
+type group struct {
+	factory $.interfacesSharedInformerFactory|raw$
+	namespace string
+	tweakListOptions  $.interfacesTweakListOptionsFunc|raw$
+}
+
+// New returns a new Interface.
+func New(f $.interfacesSharedInformerFactory|raw$, namespace string, tweakListOptions $.interfacesTweakListOptionsFunc|raw$) Interface {
+	return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+
+$range .versions$
+// $.Name$ returns a new $.Interface|raw$.
+func (g *group) $.Name$() $.Interface|raw$ {
+	return $.New|raw$(g.factory, g.namespace, g.tweakListOptions)
+}
+$end$
+`

vendor/k8s.io/code-generator/cmd/informer-gen/generators/informer.go

@@ -0,0 +1,186 @@
+/*
+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 (
+	"fmt"
+	"io"
+	"strings"
+
+	"k8s.io/gengo/generator"
+	"k8s.io/gengo/namer"
+	"k8s.io/gengo/types"
+
+	"k8s.io/code-generator/cmd/client-gen/generators/util"
+	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
+
+	"github.com/golang/glog"
+)
+
+// informerGenerator produces a file of listers for a given GroupVersion and
+// type.
+type informerGenerator struct {
+	generator.DefaultGen
+	outputPackage             string
+	groupPkgName              string
+	groupVersion              clientgentypes.GroupVersion
+	groupGoName               string
+	typeToGenerate            *types.Type
+	imports                   namer.ImportTracker
+	clientSetPackage          string
+	listersPackage            string
+	internalInterfacesPackage string
+}
+
+var _ generator.Generator = &informerGenerator{}
+
+func (g *informerGenerator) Filter(c *generator.Context, t *types.Type) bool {
+	return t == g.typeToGenerate
+}
+
+func (g *informerGenerator) Namers(c *generator.Context) namer.NameSystems {
+	return namer.NameSystems{
+		"raw": namer.NewRawNamer(g.outputPackage, g.imports),
+	}
+}
+
+func (g *informerGenerator) Imports(c *generator.Context) (imports []string) {
+	imports = append(imports, g.imports.ImportLines()...)
+	return
+}
+
+func (g *informerGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
+	sw := generator.NewSnippetWriter(w, c, "$", "$")
+
+	glog.V(5).Infof("processing type %v", t)
+
+	listerPackage := fmt.Sprintf("%s/%s/%s", g.listersPackage, g.groupPkgName, strings.ToLower(g.groupVersion.Version.NonEmpty()))
+	clientSetInterface := c.Universe.Type(types.Name{Package: g.clientSetPackage, Name: "Interface"})
+	informerFor := "InformerFor"
+
+	tags, err := util.ParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
+	if err != nil {
+		return err
+	}
+
+	m := map[string]interface{}{
+		"apiScheme":                       c.Universe.Type(apiScheme),
+		"cacheIndexers":                   c.Universe.Type(cacheIndexers),
+		"cacheListWatch":                  c.Universe.Type(cacheListWatch),
+		"cacheMetaNamespaceIndexFunc":     c.Universe.Function(cacheMetaNamespaceIndexFunc),
+		"cacheNamespaceIndex":             c.Universe.Variable(cacheNamespaceIndex),
+		"cacheNewSharedIndexInformer":     c.Universe.Function(cacheNewSharedIndexInformer),
+		"cacheSharedIndexInformer":        c.Universe.Type(cacheSharedIndexInformer),
+		"clientSetInterface":              clientSetInterface,
+		"group":                           namer.IC(g.groupGoName),
+		"informerFor":                     informerFor,
+		"interfacesTweakListOptionsFunc":  c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "TweakListOptionsFunc"}),
+		"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":                    c.Universe.Type(metav1NamespaceAll),
+		"namespaced":                      !tags.NonNamespaced,
+		"newLister":                       c.Universe.Function(types.Name{Package: listerPackage, Name: "New" + t.Name.Name + "Lister"}),
+		"runtimeObject":                   c.Universe.Type(runtimeObject),
+		"timeDuration":                    c.Universe.Type(timeDuration),
+		"type":                            t,
+		"v1ListOptions":                   c.Universe.Type(v1ListOptions),
+		"version":                         namer.IC(g.groupVersion.Version.String()),
+		"watchInterface":                  c.Universe.Type(watchInterface),
+	}
+
+	sw.Do(typeInformerInterface, m)
+	sw.Do(typeInformerStruct, m)
+	sw.Do(typeInformerPublicConstructor, m)
+	sw.Do(typeFilteredInformerPublicConstructor, m)
+	sw.Do(typeInformerConstructor, m)
+	sw.Do(typeInformerInformer, m)
+	sw.Do(typeInformerLister, m)
+
+	return sw.Error()
+}
+
+var typeInformerInterface = `
+// $.type|public$Informer provides access to a shared informer and lister for
+// $.type|publicPlural$.
+type $.type|public$Informer interface {
+	Informer() $.cacheSharedIndexInformer|raw$
+	Lister() $.lister|raw$
+}
+`
+
+var typeInformerStruct = `
+type $.type|private$Informer struct {
+	factory $.interfacesSharedInformerFactory|raw$
+	tweakListOptions $.interfacesTweakListOptionsFunc|raw$
+	$if .namespaced$namespace string$end$
+}
+`
+
+var typeInformerPublicConstructor = `
+// New$.type|public$Informer constructs a new informer for $.type|public$ type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func New$.type|public$Informer(client $.clientSetInterface|raw$$if .namespaced$, namespace string$end$, resyncPeriod $.timeDuration|raw$, indexers $.cacheIndexers|raw$) $.cacheSharedIndexInformer|raw$ {
+	return NewFiltered$.type|public$Informer(client$if .namespaced$, namespace$end$, resyncPeriod, indexers, nil)
+}
+`
+
+var typeFilteredInformerPublicConstructor = `
+// NewFiltered$.type|public$Informer constructs a new informer for $.type|public$ type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewFiltered$.type|public$Informer(client $.clientSetInterface|raw$$if .namespaced$, namespace string$end$, resyncPeriod $.timeDuration|raw$, indexers $.cacheIndexers|raw$, tweakListOptions $.interfacesTweakListOptionsFunc|raw$) $.cacheSharedIndexInformer|raw$ {
+	return $.cacheNewSharedIndexInformer|raw$(
+		&$.cacheListWatch|raw${
+			ListFunc: func(options $.v1ListOptions|raw$) ($.runtimeObject|raw$, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.$.group$$.version$().$.type|publicPlural$($if .namespaced$namespace$end$).List(options)
+			},
+			WatchFunc: func(options $.v1ListOptions|raw$) ($.watchInterface|raw$, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.$.group$$.version$().$.type|publicPlural$($if .namespaced$namespace$end$).Watch(options)
+			},
+		},
+		&$.type|raw${},
+		resyncPeriod,
+		indexers,
+	)
+}
+`
+
+var typeInformerConstructor = `
+func (f *$.type|private$Informer) defaultInformer(client $.clientSetInterface|raw$, resyncPeriod $.timeDuration|raw$) $.cacheSharedIndexInformer|raw$ {
+	return NewFiltered$.type|public$Informer(client$if .namespaced$, f.namespace$end$, resyncPeriod, $.cacheIndexers|raw${$.cacheNamespaceIndex|raw$: $.cacheMetaNamespaceIndexFunc|raw$}, f.tweakListOptions)
+}
+`
+
+var typeInformerInformer = `
+func (f *$.type|private$Informer) Informer() $.cacheSharedIndexInformer|raw$ {
+	return f.factory.$.informerFor$(&$.type|raw${}, f.defaultInformer)
+}
+`
+
+var typeInformerLister = `
+func (f *$.type|private$Informer) Lister() $.lister|raw$ {
+	return $.newLister|raw$(f.Informer().GetIndexer())
+}
+`

vendor/k8s.io/code-generator/cmd/informer-gen/generators/packages.go

@@ -0,0 +1,352 @@
+/*
+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 (
+	"fmt"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/golang/glog"
+	"k8s.io/gengo/args"
+	"k8s.io/gengo/generator"
+	"k8s.io/gengo/namer"
+	"k8s.io/gengo/types"
+
+	"k8s.io/code-generator/cmd/client-gen/generators/util"
+	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
+	informergenargs "k8s.io/code-generator/cmd/informer-gen/args"
+)
+
+// NameSystems returns the name system used by the generators in this package.
+func NameSystems() namer.NameSystems {
+	pluralExceptions := map[string]string{
+		"Endpoints": "Endpoints",
+	}
+	return namer.NameSystems{
+		"public":             namer.NewPublicNamer(0),
+		"private":            namer.NewPrivateNamer(0),
+		"raw":                namer.NewRawNamer("", nil),
+		"publicPlural":       namer.NewPublicPluralNamer(pluralExceptions),
+		"allLowercasePlural": namer.NewAllLowercasePluralNamer(pluralExceptions),
+		"lowercaseSingular":  &lowercaseSingularNamer{},
+	}
+}
+
+// lowercaseSingularNamer implements Namer
+type lowercaseSingularNamer struct{}
+
+// Name returns t's name in all lowercase.
+func (n *lowercaseSingularNamer) Name(t *types.Type) string {
+	return strings.ToLower(t.Name.Name)
+}
+
+// DefaultNameSystem returns the default name system for ordering the types to be
+// processed by the generators in this package.
+func DefaultNameSystem() string {
+	return "public"
+}
+
+// objectMetaForPackage returns the type of ObjectMeta used by package p.
+func objectMetaForPackage(p *types.Package) (*types.Type, bool, error) {
+	generatingForPackage := false
+	for _, t := range p.Types {
+		if !util.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...)).GenerateClient {
+			continue
+		}
+		generatingForPackage = true
+		for _, member := range t.Members {
+			if member.Name == "ObjectMeta" {
+				return member.Type, isInternal(member), nil
+			}
+		}
+	}
+	if generatingForPackage {
+		return nil, false, fmt.Errorf("unable to find ObjectMeta for any types in package %s", p.Path)
+	}
+	return nil, false, nil
+}
+
+// isInternal returns true if the tags for a member do not contain a json tag
+func isInternal(m types.Member) bool {
+	return !strings.Contains(m.Tags, "json")
+}
+
+func packageForInternalInterfaces(base string) string {
+	return filepath.Join(base, "internalinterfaces")
+}
+
+func vendorless(p string) string {
+	if pos := strings.LastIndex(p, "/vendor/"); pos != -1 {
+		return p[pos+len("/vendor/"):]
+	}
+	return p
+}
+
+// Packages makes the client package definition.
+func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages {
+	boilerplate, err := arguments.LoadGoBoilerplate()
+	if err != nil {
+		glog.Fatalf("Failed loading boilerplate: %v", err)
+	}
+
+	customArgs, ok := arguments.CustomArgs.(*informergenargs.CustomArgs)
+	if !ok {
+		glog.Fatalf("Wrong CustomArgs type: %T", arguments.CustomArgs)
+	}
+
+	internalVersionPackagePath := filepath.Join(arguments.OutputPackagePath)
+	externalVersionPackagePath := filepath.Join(arguments.OutputPackagePath)
+	if !customArgs.SingleDirectory {
+		internalVersionPackagePath = filepath.Join(arguments.OutputPackagePath, "internalversion")
+		externalVersionPackagePath = filepath.Join(arguments.OutputPackagePath, "externalversions")
+	}
+
+	var packageList generator.Packages
+	typesForGroupVersion := make(map[clientgentypes.GroupVersion][]*types.Type)
+
+	externalGroupVersions := make(map[string]clientgentypes.GroupVersions)
+	internalGroupVersions := make(map[string]clientgentypes.GroupVersions)
+	groupGoNames := make(map[string]string)
+	for _, inputDir := range arguments.InputDirs {
+		p := context.Universe.Package(vendorless(inputDir))
+
+		objectMeta, internal, err := objectMetaForPackage(p)
+		if err != nil {
+			glog.Fatal(err)
+		}
+		if objectMeta == nil {
+			// no types in this package had genclient
+			continue
+		}
+
+		var gv clientgentypes.GroupVersion
+		var targetGroupVersions map[string]clientgentypes.GroupVersions
+
+		if internal {
+			lastSlash := strings.LastIndex(p.Path, "/")
+			if lastSlash == -1 {
+				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
+		}
+		groupPackageName := gv.Group.NonEmpty()
+		gvPackage := path.Clean(p.Path)
+
+		// If there's a comment of the form "// +groupName=somegroup" or
+		// "// +groupName=somegroup.foo.bar.io", use the first field (somegroup) as the name of the
+		// group when generating.
+		if override := types.ExtractCommentTags("+", p.Comments)["groupName"]; override != nil {
+			gv.Group = clientgentypes.Group(override[0])
+		}
+
+		// If there's a comment of the form "// +groupGoName=SomeUniqueShortName", use that as
+		// the Go group identifier in CamelCase. It defaults
+		groupGoNames[groupPackageName] = namer.IC(strings.Split(gv.Group.NonEmpty(), ".")[0])
+		if override := types.ExtractCommentTags("+", p.Comments)["groupGoName"]; override != nil {
+			groupGoNames[groupPackageName] = namer.IC(override[0])
+		}
+
+		var typesToGenerate []*types.Type
+		for _, t := range p.Types {
+			tags := util.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
+			if !tags.GenerateClient || tags.NoVerbs || !tags.HasVerb("list") || !tags.HasVerb("watch") {
+				continue
+			}
+
+			typesToGenerate = append(typesToGenerate, t)
+
+			if _, ok := typesForGroupVersion[gv]; !ok {
+				typesForGroupVersion[gv] = []*types.Type{}
+			}
+			typesForGroupVersion[gv] = append(typesForGroupVersion[gv], t)
+		}
+		if len(typesToGenerate) == 0 {
+			continue
+		}
+
+		groupVersionsEntry, ok := targetGroupVersions[groupPackageName]
+		if !ok {
+			groupVersionsEntry = clientgentypes.GroupVersions{
+				PackageName: groupPackageName,
+				Group:       gv.Group,
+			}
+		}
+		groupVersionsEntry.Versions = append(groupVersionsEntry.Versions, clientgentypes.PackageVersion{Version: gv.Version, Package: gvPackage})
+		targetGroupVersions[groupPackageName] = groupVersionsEntry
+
+		orderer := namer.Orderer{Namer: namer.NewPrivateNamer(0)}
+		typesToGenerate = orderer.OrderTypes(typesToGenerate)
+
+		if internal {
+			packageList = append(packageList, versionPackage(internalVersionPackagePath, groupPackageName, gv, groupGoNames[groupPackageName], boilerplate, typesToGenerate, customArgs.InternalClientSetPackage, customArgs.ListersPackage))
+		} else {
+			packageList = append(packageList, versionPackage(externalVersionPackagePath, groupPackageName, gv, groupGoNames[groupPackageName], boilerplate, typesToGenerate, customArgs.VersionedClientSetPackage, customArgs.ListersPackage))
+		}
+	}
+
+	if len(externalGroupVersions) != 0 {
+		packageList = append(packageList, factoryInterfacePackage(externalVersionPackagePath, boilerplate, customArgs.VersionedClientSetPackage))
+		packageList = append(packageList, factoryPackage(externalVersionPackagePath, boilerplate, groupGoNames, externalGroupVersions, customArgs.VersionedClientSetPackage, typesForGroupVersion))
+		for _, gvs := range externalGroupVersions {
+			packageList = append(packageList, groupPackage(externalVersionPackagePath, gvs, boilerplate))
+		}
+	}
+
+	if len(internalGroupVersions) != 0 {
+		packageList = append(packageList, factoryInterfacePackage(internalVersionPackagePath, boilerplate, customArgs.InternalClientSetPackage))
+		packageList = append(packageList, factoryPackage(internalVersionPackagePath, boilerplate, groupGoNames, internalGroupVersions, customArgs.InternalClientSetPackage, typesForGroupVersion))
+		for _, gvs := range internalGroupVersions {
+			packageList = append(packageList, groupPackage(internalVersionPackagePath, gvs, boilerplate))
+		}
+	}
+
+	return packageList
+}
+
+func factoryPackage(basePackage string, boilerplate []byte, groupGoNames map[string]string, groupVersions map[string]clientgentypes.GroupVersions, clientSetPackage string, typesForGroupVersion map[clientgentypes.GroupVersion][]*types.Type) generator.Package {
+	return &generator.DefaultPackage{
+		PackageName: filepath.Base(basePackage),
+		PackagePath: basePackage,
+		HeaderText:  boilerplate,
+		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+			generators = append(generators, &factoryGenerator{
+				DefaultGen: generator.DefaultGen{
+					OptionalName: "factory",
+				},
+				outputPackage:             basePackage,
+				imports:                   generator.NewImportTracker(),
+				groupVersions:             groupVersions,
+				clientSetPackage:          clientSetPackage,
+				internalInterfacesPackage: packageForInternalInterfaces(basePackage),
+				gvGoNames:                 groupGoNames,
+			})
+
+			generators = append(generators, &genericGenerator{
+				DefaultGen: generator.DefaultGen{
+					OptionalName: "generic",
+				},
+				outputPackage:        basePackage,
+				imports:              generator.NewImportTracker(),
+				groupVersions:        groupVersions,
+				typesForGroupVersion: typesForGroupVersion,
+				groupGoNames:         groupGoNames,
+			})
+
+			return generators
+		},
+	}
+}
+
+func factoryInterfacePackage(basePackage string, boilerplate []byte, clientSetPackage string) 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: "factory_interfaces",
+				},
+				outputPackage:    packagePath,
+				imports:          generator.NewImportTracker(),
+				clientSetPackage: clientSetPackage,
+			})
+
+			return generators
+		},
+	}
+}
+
+func groupPackage(basePackage string, groupVersions clientgentypes.GroupVersions, boilerplate []byte) generator.Package {
+	packagePath := filepath.Join(basePackage, groupVersions.PackageName)
+	groupPkgName := strings.Split(string(groupVersions.Group), ".")[0]
+
+	return &generator.DefaultPackage{
+		PackageName: groupPkgName,
+		PackagePath: packagePath,
+		HeaderText:  boilerplate,
+		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+			generators = append(generators, &groupInterfaceGenerator{
+				DefaultGen: generator.DefaultGen{
+					OptionalName: "interface",
+				},
+				outputPackage:             packagePath,
+				groupVersions:             groupVersions,
+				imports:                   generator.NewImportTracker(),
+				internalInterfacesPackage: packageForInternalInterfaces(basePackage),
+			})
+			return generators
+		},
+		FilterFunc: func(c *generator.Context, t *types.Type) bool {
+			tags := util.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
+			return tags.GenerateClient && tags.HasVerb("list") && tags.HasVerb("watch")
+		},
+	}
+}
+
+func versionPackage(basePackage string, groupPkgName string, gv clientgentypes.GroupVersion, groupGoName string, boilerplate []byte, typesToGenerate []*types.Type, clientSetPackage, listersPackage string) generator.Package {
+	packagePath := filepath.Join(basePackage, groupPkgName, strings.ToLower(gv.Version.NonEmpty()))
+
+	return &generator.DefaultPackage{
+		PackageName: strings.ToLower(gv.Version.NonEmpty()),
+		PackagePath: packagePath,
+		HeaderText:  boilerplate,
+		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+			generators = append(generators, &versionInterfaceGenerator{
+				DefaultGen: generator.DefaultGen{
+					OptionalName: "interface",
+				},
+				outputPackage: packagePath,
+				imports:       generator.NewImportTracker(),
+				types:         typesToGenerate,
+				internalInterfacesPackage: packageForInternalInterfaces(basePackage),
+			})
+
+			for _, t := range typesToGenerate {
+				generators = append(generators, &informerGenerator{
+					DefaultGen: generator.DefaultGen{
+						OptionalName: strings.ToLower(t.Name.Name),
+					},
+					outputPackage:             packagePath,
+					groupPkgName:              groupPkgName,
+					groupVersion:              gv,
+					groupGoName:               groupGoName,
+					typeToGenerate:            t,
+					imports:                   generator.NewImportTracker(),
+					clientSetPackage:          clientSetPackage,
+					listersPackage:            listersPackage,
+					internalInterfacesPackage: packageForInternalInterfaces(basePackage),
+				})
+			}
+			return generators
+		},
+		FilterFunc: func(c *generator.Context, t *types.Type) bool {
+			tags := util.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
+			return tags.GenerateClient && tags.HasVerb("list") && tags.HasVerb("watch")
+		},
+	}
+}

vendor/k8s.io/code-generator/cmd/informer-gen/generators/tags.go

@@ -0,0 +1,33 @@
+/*
+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 (
+	"github.com/golang/glog"
+	"k8s.io/gengo/types"
+)
+
+// extractBoolTagOrDie gets the comment-tags for the key and asserts that, if
+// it exists, the value is boolean.  If the tag did not exist, it returns
+// false.
+func extractBoolTagOrDie(key string, lines []string) bool {
+	val, err := types.ExtractSingleBoolCommentTag("+", key, false, lines)
+	if err != nil {
+		glog.Fatal(err)
+	}
+	return val
+}

vendor/k8s.io/code-generator/cmd/informer-gen/generators/types.go

@@ -0,0 +1,42 @@
+/*
+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 "k8s.io/gengo/types"
+
+var (
+	apiScheme                   = types.Name{Package: "k8s.io/kubernetes/pkg/api/legacyscheme", Name: "Scheme"}
+	cacheGenericLister          = types.Name{Package: "k8s.io/client-go/tools/cache", Name: "GenericLister"}
+	cacheIndexers               = types.Name{Package: "k8s.io/client-go/tools/cache", Name: "Indexers"}
+	cacheListWatch              = types.Name{Package: "k8s.io/client-go/tools/cache", Name: "ListWatch"}
+	cacheMetaNamespaceIndexFunc = types.Name{Package: "k8s.io/client-go/tools/cache", Name: "MetaNamespaceIndexFunc"}
+	cacheNamespaceIndex         = types.Name{Package: "k8s.io/client-go/tools/cache", Name: "NamespaceIndex"}
+	cacheNewGenericLister       = types.Name{Package: "k8s.io/client-go/tools/cache", Name: "NewGenericLister"}
+	cacheNewSharedIndexInformer = types.Name{Package: "k8s.io/client-go/tools/cache", Name: "NewSharedIndexInformer"}
+	cacheSharedIndexInformer    = types.Name{Package: "k8s.io/client-go/tools/cache", Name: "SharedIndexInformer"}
+	listOptions                 = types.Name{Package: "k8s.io/kubernetes/pkg/apis/core", Name: "ListOptions"}
+	reflectType                 = types.Name{Package: "reflect", Name: "Type"}
+	runtimeObject               = types.Name{Package: "k8s.io/apimachinery/pkg/runtime", Name: "Object"}
+	schemaGroupResource         = types.Name{Package: "k8s.io/apimachinery/pkg/runtime/schema", Name: "GroupResource"}
+	schemaGroupVersionResource  = types.Name{Package: "k8s.io/apimachinery/pkg/runtime/schema", Name: "GroupVersionResource"}
+	syncMutex                   = types.Name{Package: "sync", Name: "Mutex"}
+	timeDuration                = types.Name{Package: "time", Name: "Duration"}
+	v1ListOptions               = types.Name{Package: "k8s.io/apimachinery/pkg/apis/meta/v1", Name: "ListOptions"}
+	metav1NamespaceAll          = types.Name{Package: "k8s.io/apimachinery/pkg/apis/meta/v1", Name: "NamespaceAll"}
+	metav1Object                = types.Name{Package: "k8s.io/apimachinery/pkg/apis/meta/v1", Name: "Object"}
+	watchInterface              = types.Name{Package: "k8s.io/apimachinery/pkg/watch", Name: "Interface"}
+)

vendor/k8s.io/code-generator/cmd/informer-gen/generators/versioninterface.go

@@ -0,0 +1,109 @@
+/*
+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"
+
+	"k8s.io/code-generator/cmd/client-gen/generators/util"
+)
+
+// versionInterfaceGenerator generates the per-version interface file.
+type versionInterfaceGenerator struct {
+	generator.DefaultGen
+	outputPackage             string
+	imports                   namer.ImportTracker
+	types                     []*types.Type
+	filtered                  bool
+	internalInterfacesPackage string
+}
+
+var _ generator.Generator = &versionInterfaceGenerator{}
+
+func (g *versionInterfaceGenerator) Filter(c *generator.Context, t *types.Type) bool {
+	if !g.filtered {
+		g.filtered = true
+		return true
+	}
+	return false
+}
+
+func (g *versionInterfaceGenerator) Namers(c *generator.Context) namer.NameSystems {
+	return namer.NameSystems{
+		"raw": namer.NewRawNamer(g.outputPackage, g.imports),
+	}
+}
+
+func (g *versionInterfaceGenerator) Imports(c *generator.Context) (imports []string) {
+	imports = append(imports, g.imports.ImportLines()...)
+	return
+}
+
+func (g *versionInterfaceGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
+	sw := generator.NewSnippetWriter(w, c, "$", "$")
+
+	m := map[string]interface{}{
+		"interfacesTweakListOptionsFunc":  c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "TweakListOptionsFunc"}),
+		"interfacesSharedInformerFactory": c.Universe.Type(types.Name{Package: g.internalInterfacesPackage, Name: "SharedInformerFactory"}),
+		"types": g.types,
+	}
+
+	sw.Do(versionTemplate, m)
+	for _, typeDef := range g.types {
+		tags, err := util.ParseClientGenTags(typeDef.SecondClosestCommentLines)
+		if err != nil {
+			return err
+		}
+		m["namespaced"] = !tags.NonNamespaced
+		m["type"] = typeDef
+		sw.Do(versionFuncTemplate, m)
+	}
+
+	return sw.Error()
+}
+
+var versionTemplate = `
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	$range .types -$
+		// $.|publicPlural$ returns a $.|public$Informer.
+		$.|publicPlural$() $.|public$Informer
+	$end$
+}
+
+type version struct {
+	factory $.interfacesSharedInformerFactory|raw$
+	namespace string
+	tweakListOptions $.interfacesTweakListOptionsFunc|raw$
+}
+
+// New returns a new Interface.
+func New(f $.interfacesSharedInformerFactory|raw$, namespace string, tweakListOptions $.interfacesTweakListOptionsFunc|raw$) Interface {
+	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+`
+
+var versionFuncTemplate = `
+// $.type|publicPlural$ returns a $.type|public$Informer.
+func (v *version) $.type|publicPlural$() $.type|public$Informer {
+	return &$.type|private$Informer{factory: v.factory$if .namespaced$, namespace: v.namespace$end$, tweakListOptions: v.tweakListOptions}
+}
+`

vendor/k8s.io/code-generator/cmd/informer-gen/main.go

@@ -0,0 +1,62 @@
+/*
+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 main
+
+import (
+	"flag"
+	"path/filepath"
+
+	"github.com/golang/glog"
+	"github.com/spf13/pflag"
+	"k8s.io/code-generator/cmd/informer-gen/generators"
+	"k8s.io/code-generator/pkg/util"
+	"k8s.io/gengo/args"
+
+	generatorargs "k8s.io/code-generator/cmd/informer-gen/args"
+)
+
+func main() {
+	genericArgs, customArgs := generatorargs.NewDefaults()
+
+	// Override defaults.
+	// TODO: move out of informer-gen
+	genericArgs.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath())
+	genericArgs.OutputPackagePath = "k8s.io/kubernetes/pkg/client/informers/informers_generated"
+	customArgs.VersionedClientSetPackage = "k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
+	customArgs.InternalClientSetPackage = "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	customArgs.ListersPackage = "k8s.io/kubernetes/pkg/client/listers"
+
+	genericArgs.AddFlags(pflag.CommandLine)
+	customArgs.AddFlags(pflag.CommandLine)
+	flag.Set("logtostderr", "true")
+	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
+	pflag.Parse()
+
+	if err := generatorargs.Validate(genericArgs); err != nil {
+		glog.Fatalf("Error: %v", err)
+	}
+
+	// Run it.
+	if err := genericArgs.Execute(
+		generators.NameSystems(),
+		generators.DefaultNameSystem(),
+		generators.Packages,
+	); err != nil {
+		glog.Fatalf("Error: %v", err)
+	}
+	glog.V(2).Info("Completed successfully.")
+}