Changes to generator for deepcopygen

clientbase/ops.go

@@ -227,9 +227,7 @@ func (a *APIOperations) DoByID(schemaType string, id string, respObject interfac
 		return errors.New("Failed to find collection URL for [" + schemaType + "]")
 	}
 
-	err := a.DoGet(collectionUrl+"/"+id, nil, respObject)
+	return a.DoGet(collectionUrl+"/"+id, nil, respObject)
-	//TODO check for 404 and return nil, nil
-	return err
 }
 
 func (a *APIOperations) DoResourceDelete(schemaType string, existing *types.Resource) error {

generator/controller_template.go

@@ -31,6 +31,12 @@ var (
 	}
 )
 
+type {{.schema.CodeName}}List struct {
+	metav1.TypeMeta   %BACK%json:",inline"%BACK%
+	metav1.ObjectMeta %BACK%json:"metadata,omitempty"%BACK%
+	Items             []{{.schema.CodeName}}
+}
+
 type {{.schema.CodeName}}HandlerFunc func(key string, obj *{{.schema.CodeName}}) error
 
 type {{.schema.CodeName}}Controller interface {

generator/generator.go

@@ -10,11 +10,15 @@ import (
 	"strings"
 	"text/template"
 
+	"io"
+
 	"github.com/pkg/errors"
 	"github.com/rancher/norman/types"
 	"github.com/rancher/norman/types/convert"
 	"k8s.io/gengo/args"
 	"k8s.io/gengo/examples/deepcopy-gen/generators"
+	"k8s.io/gengo/generator"
+	gengotypes "k8s.io/gengo/types"
 )
 
 var (
@@ -173,6 +177,8 @@ func Generate(schemas *types.Schemas, cattleOutputPackage, k8sOutputPackage stri
 		return err
 	}
 
+	doDeepCopy := false
+
 	generated := []*types.Schema{}
 	for _, schema := range schemas.Schemas() {
 		if blackListTypes[schema.ID] {
@@ -183,7 +189,10 @@ func Generate(schemas *types.Schemas, cattleOutputPackage, k8sOutputPackage stri
 			return err
 		}
 
-		if contains(schema.CollectionMethods, http.MethodGet) {
+		if contains(schema.CollectionMethods, http.MethodGet) &&
+			!strings.HasPrefix(schema.PkgName, "k8s.io") &&
+			!strings.Contains(schema.PkgName, "/vendor/") {
+			doDeepCopy = true
 			if err := generateController(k8sDir, schema, schemas); err != nil {
 				return err
 			}
@@ -196,8 +205,10 @@ func Generate(schemas *types.Schemas, cattleOutputPackage, k8sOutputPackage stri
 		return err
 	}
 
-	if err := deepCopyGen(baseDir, k8sOutputPackage); err != nil {
+	if doDeepCopy {
-		return err
+		if err := deepCopyGen(baseDir, k8sOutputPackage); err != nil {
+			return err
+		}
 	}
 
 	if err := gofmt(baseDir, k8sOutputPackage); err != nil {
@@ -252,5 +263,54 @@ func deepCopyGen(workDir, pkg string) error {
 	return arguments.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.Packages)
+		func(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages {
+			packageParts := strings.Split(pkg, "/")
+			return generator.Packages{
+				&generator.DefaultPackage{
+					PackageName: packageParts[len(packageParts)-1],
+					PackagePath: pkg,
+					HeaderText:  []byte{},
+					GeneratorFunc: func(c *generator.Context) []generator.Generator {
+						return []generator.Generator{
+							&noInitGenerator{
+								generators.NewGenDeepCopy(arguments.OutputFileBaseName, pkg, nil, true, true),
+							},
+						}
+					},
+					FilterFunc: func(c *generator.Context, t *gengotypes.Type) bool {
+						if t.Name.Package != pkg {
+							return false
+						}
+
+						if isObjectOrList(t) {
+							t.SecondClosestCommentLines = append(t.SecondClosestCommentLines,
+								"+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object")
+						}
+
+						return true
+					},
+				},
+			}
+		})
+}
+
+type noInitGenerator struct {
+	generator.Generator
+}
+
+func (n *noInitGenerator) Init(*generator.Context, io.Writer) error {
+	return nil
+}
+
+func isObjectOrList(t *gengotypes.Type) bool {
+	for _, member := range t.Members {
+		if member.Embedded && (member.Name == "ObjectMeta" || member.Name == "ListMeta") {
+			return true
+		}
+		if member.Embedded && isObjectOrList(member.Type) {
+			return true
+		}
+	}
+
+	return false
 }

types/reflection.go

@@ -49,6 +49,7 @@ func (s *Schemas) newSchemaFromType(version *APIVersion, t reflect.Type, typeNam
 		ID:             typeName,
 		Version:        *version,
 		CodeName:       t.Name(),
+		PkgName:        t.PkgPath(),
 		ResourceFields: map[string]Field{},
 	}
 

types/schemas.go

@@ -32,6 +32,13 @@ func (s *Schemas) Err() error {
 	return NewErrors(s.errors)
 }
 
+func (s *Schemas) AddSchemas(schema *Schemas) *Schemas {
+	for _, schema := range schema.Schemas() {
+		s.AddSchema(schema)
+	}
+	return s
+}
+
 func (s *Schemas) AddSchema(schema *Schema) *Schemas {
 	schema.Type = "schema"
 	if schema.ID == "" {

types/types.go

@@ -62,6 +62,7 @@ type APIVersion struct {
 type Schema struct {
 	ID                string            `json:"id,omitempty"`
 	CodeName          string            `json:"-"`
+	PkgName           string            `json:"-"`
 	Type              string            `json:"type,omitempty"`
 	Links             map[string]string `json:"links"`
 	Version           APIVersion        `json:"version"`