Bump vendor

vendor/github.com/rancher/norman/clientbase/common.go

@@ -258,8 +258,8 @@ func (a *APIBaseClient) Update(schemaType string, existing *types.Resource, upda
 	return a.Ops.DoUpdate(schemaType, existing, updates, respObject)
 }
 
-func (a *APIBaseClient) ById(schemaType string, id string, respObject interface{}) error {
-	return a.Ops.DoById(schemaType, id, respObject)
+func (a *APIBaseClient) ByID(schemaType string, id string, respObject interface{}) error {
+	return a.Ops.DoByID(schemaType, id, respObject)
 }
 
 func (a *APIBaseClient) Delete(existing *types.Resource) error {

vendor/github.com/rancher/norman/clientbase/ops.go

@@ -212,7 +212,7 @@ func (a *APIOperations) DoUpdate(schemaType string, existing *types.Resource, up
 	return a.DoModify("PUT", selfUrl, updates, respObject)
 }
 
-func (a *APIOperations) DoById(schemaType string, id string, respObject interface{}) error {
+func (a *APIOperations) DoByID(schemaType string, id string, respObject interface{}) error {
 	schema, ok := a.Types[schemaType]
 	if !ok {
 		return errors.New("Unknown schema type [" + schemaType + "]")
@@ -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)
-	//TODO check for 404 and return nil, nil
-	return err
+	return a.DoGet(collectionUrl+"/"+id, nil, respObject)
 }
 
 func (a *APIOperations) DoResourceDelete(schemaType string, existing *types.Resource) error {

vendor/github.com/rancher/norman/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 {

vendor/github.com/rancher/norman/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 {
-		return err
+	if doDeepCopy {
+		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
 }

vendor/github.com/rancher/norman/generator/type_template.go

@@ -39,7 +39,7 @@ type {{.schema.CodeName}}Operations interface {
     List(opts *types.ListOpts) (*{{.schema.CodeName}}Collection, error)
     Create(opts *{{.schema.CodeName}}) (*{{.schema.CodeName}}, error)
     Update(existing *{{.schema.CodeName}}, updates interface{}) (*{{.schema.CodeName}}, error)
-    ById(id string) (*{{.schema.CodeName}}, error)
+    ByID(id string) (*{{.schema.CodeName}}, error)
     Delete(container *{{.schema.CodeName}}) error{{range $key, $value := .resourceActions}}
     {{if eq $value.Input "" }}
         Action{{$key | capitalize}} (*{{$.schema.CodeName}}) (*{{.Output | capitalize}}, error)
@@ -83,9 +83,9 @@ func (cc *{{.schema.CodeName}}Collection) Next() (*{{.schema.CodeName}}Collectio
     return nil, nil
 }
 
-func (c *{{.schema.CodeName}}Client) ById(id string) (*{{.schema.CodeName}}, error) {
+func (c *{{.schema.CodeName}}Client) ByID(id string) (*{{.schema.CodeName}}, error) {
     resp := &{{.schema.CodeName}}{}
-    err := c.apiClient.Ops.DoById({{.schema.CodeName}}Type, id, resp)
+    err := c.apiClient.Ops.DoByID({{.schema.CodeName}}Type, id, resp)
     return resp, err
 }
 

vendor/github.com/rancher/norman/types/mapping/mapper/check.go

@@ -0,0 +1,28 @@
+package mapper
+
+import (
+	"fmt"
+
+	"github.com/rancher/norman/types"
+)
+
+func getInternal(schema *types.Schema) (*types.Schema, error) {
+	if schema.InternalSchema == nil {
+		return nil, fmt.Errorf("no internal schema found for schema %s", schema.ID)
+	}
+
+	return schema.InternalSchema, nil
+}
+
+func validateInternalField(field string, schema *types.Schema) (*types.Schema, error) {
+	internalSchema, err := getInternal(schema)
+	if err != nil {
+		return nil, err
+	}
+
+	if _, ok := internalSchema.ResourceFields[field]; !ok {
+		return nil, fmt.Errorf("field %s missing on internal schema %s", field, schema.ID)
+	}
+
+	return internalSchema, nil
+}

vendor/github.com/rancher/norman/types/mapping/mapper/copy.go

@@ -0,0 +1,25 @@
+package mapper
+
+import "strings"
+
+type Copy struct {
+	From, To string
+}
+
+func (c Copy) Forward(data map[string]interface{}) {
+	val, ok := GetValue(data, strings.Split(c.From, "/")...)
+	if !ok {
+		return
+	}
+
+	PutValue(data, val, strings.Split(c.To, "/")...)
+}
+
+func (c Copy) Back(data map[string]interface{}) {
+	val, ok := GetValue(data, strings.Split(c.To, "/")...)
+	if !ok {
+		return
+	}
+
+	PutValue(data, val, strings.Split(c.From, "/")...)
+}

vendor/github.com/rancher/norman/types/mapping/mapper/drop.go

@@ -0,0 +1,32 @@
+package mapper
+
+import (
+	"fmt"
+
+	"github.com/rancher/norman/types"
+)
+
+type Drop struct {
+	Field string
+}
+
+func (d Drop) FromInternal(data map[string]interface{}) {
+	delete(data, d.Field)
+}
+
+func (d Drop) ToInternal(data map[string]interface{}) {
+}
+
+func (d Drop) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	_, err := getInternal(schema)
+	if err != nil {
+		return err
+	}
+
+	if _, ok := schema.ResourceFields[d.Field]; !ok {
+		return fmt.Errorf("can not drop missing field %s on %s", d.Field, schema.ID)
+	}
+
+	delete(schema.ResourceFields, d.Field)
+	return nil
+}

vendor/github.com/rancher/norman/types/mapping/mapper/embed.go

@@ -0,0 +1,65 @@
+package mapper
+
+import (
+	"fmt"
+
+	"github.com/rancher/norman/types"
+)
+
+type Embed struct {
+	Field          string
+	ignoreOverride bool
+	embeddedFields []string
+}
+
+func (e *Embed) FromInternal(data map[string]interface{}) {
+	sub, _ := data[e.Field].(map[string]interface{})
+	for _, fieldName := range e.embeddedFields {
+		if v, ok := sub[fieldName]; ok {
+			data[fieldName] = v
+		}
+	}
+	delete(data, e.Field)
+}
+
+func (e *Embed) ToInternal(data map[string]interface{}) {
+	sub := map[string]interface{}{}
+	for _, fieldName := range e.embeddedFields {
+		if v, ok := data[fieldName]; ok {
+			sub[fieldName] = v
+		}
+
+		delete(data, fieldName)
+	}
+
+	data[e.Field] = sub
+}
+
+func (e *Embed) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	internalSchema, err := validateInternalField(e.Field, schema)
+	if err != nil {
+		return err
+	}
+
+	e.embeddedFields = []string{}
+
+	embeddedSchemaID := internalSchema.ResourceFields[e.Field].Type
+	embeddedSchema := schemas.Schema(&schema.Version, embeddedSchemaID)
+	if embeddedSchema == nil {
+		return fmt.Errorf("failed to find schema %s for embedding", embeddedSchemaID)
+	}
+
+	for name, field := range embeddedSchema.ResourceFields {
+		if !e.ignoreOverride {
+			if _, ok := schema.ResourceFields[name]; ok {
+				return fmt.Errorf("embedding field %s on %s will overwrite the field %s",
+					e.Field, schema.ID, name)
+			}
+		}
+		schema.ResourceFields[name] = field
+		e.embeddedFields = append(e.embeddedFields, name)
+	}
+
+	delete(schema.ResourceFields, e.Field)
+	return nil
+}

vendor/github.com/rancher/norman/types/mapping/mapper/enum.go

@@ -0,0 +1,49 @@
+package mapper
+
+import (
+	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/convert"
+)
+
+type Enum struct {
+	Field  string
+	Values map[string][]string
+}
+
+func (e Enum) FromInternal(data map[string]interface{}) {
+	v, ok := data[e.Field]
+	if !ok {
+		return
+	}
+
+	str := convert.ToString(v)
+
+	mapping, ok := e.Values[str]
+	if ok {
+		data[e.Field] = mapping[0]
+	} else {
+		data[e.Field] = v
+	}
+}
+
+func (e Enum) ToInternal(data map[string]interface{}) {
+	v, ok := data[e.Field]
+	if !ok {
+		return
+	}
+
+	str := convert.ToString(v)
+	for newValue, values := range e.Values {
+		for _, value := range values {
+			if str == value {
+				data[e.Field] = newValue
+				return
+			}
+		}
+	}
+}
+
+func (e Enum) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	_, err := validateInternalField(e.Field, schema)
+	return err
+}

vendor/github.com/rancher/norman/types/mapping/mapper/label_field.go

@@ -0,0 +1,25 @@
+package mapper
+
+//type LabelField struct {
+//	Fields []string
+//}
+//
+//func (l LabelField) Forward(data map[string]interface{}) {
+//	for _, field := range l.Fields {
+//		moveForLabel(field).Forward(data)
+//	}
+//
+//}
+//
+//func (l LabelField) Back(data map[string]interface{}) {
+//	for _, field := range l.Fields {
+//		moveForLabel(field).Back(data)
+//	}
+//}
+//
+//func moveForLabel(field string) *Enum {
+//	return &Enum{
+//		From: field,
+//		To:   "metadata/labels/io.cattle.field." + strings.ToLower(field),
+//	}
+//}

vendor/github.com/rancher/norman/types/mapping/mapper/move.go

@@ -0,0 +1,48 @@
+package mapper
+
+import (
+	"fmt"
+
+	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/convert"
+)
+
+type Move struct {
+	From, To string
+}
+
+func (m Move) FromInternal(data map[string]interface{}) {
+	if v, ok := GetValue(data, m.From); ok {
+		data[m.To] = v
+	}
+}
+
+func (m Move) ToInternal(data map[string]interface{}) {
+	if v, ok := GetValue(data, m.To); ok {
+		data[m.From] = v
+	}
+}
+
+func (m Move) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	internalSchema, err := getInternal(schema)
+	if err != nil {
+		return err
+	}
+
+	field, ok := internalSchema.ResourceFields[m.From]
+	if !ok {
+		return fmt.Errorf("missing field %s on internal schema %s", m.From, internalSchema.ID)
+	}
+
+	_, ok = schema.ResourceFields[m.To]
+	if ok {
+		return fmt.Errorf("field %s already exists on schema %s", m.From, internalSchema.ID)
+	}
+
+	delete(schema.ResourceFields, m.From)
+
+	field.CodeName = convert.Capitalize(m.To)
+	schema.ResourceFields[m.To] = field
+
+	return nil
+}

vendor/github.com/rancher/norman/types/mapping/mapper/slice_to_map.go

@@ -0,0 +1,60 @@
+package mapper
+
+import (
+	"fmt"
+
+	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/definition"
+)
+
+type SliceToMap struct {
+	Field string
+	Key   string
+}
+
+func (s SliceToMap) FromInternal(data map[string]interface{}) {
+	datas, _ := data[s.Field].([]interface{})
+	result := map[string]interface{}{}
+
+	for _, item := range datas {
+		if mapItem, ok := item.(map[string]interface{}); ok {
+			name, _ := mapItem[s.Key].(string)
+			delete(mapItem, s.Key)
+			result[name] = mapItem
+		}
+	}
+
+	data[s.Field] = result
+}
+
+func (s SliceToMap) ToInternal(data map[string]interface{}) {
+	datas, _ := data[s.Field].(map[string]interface{})
+	result := []map[string]interface{}{}
+
+	for name, item := range datas {
+		mapItem, _ := item.(map[string]interface{})
+		if mapItem != nil {
+			mapItem[s.Key] = name
+			result = append(result, mapItem)
+		}
+	}
+
+	data[s.Field] = result
+}
+
+func (s SliceToMap) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	internalSchema, err := validateInternalField(s.Field, schema)
+	if err != nil {
+		return err
+	}
+
+	field := internalSchema.ResourceFields[s.Field]
+	if !definition.IsArrayType(field.Type) {
+		return fmt.Errorf("field %s on %s is not an array", s.Field, internalSchema.ID)
+	}
+
+	field.Type = "map[" + definition.SubType(field.Type) + "]"
+	schema.ResourceFields[s.Field] = field
+
+	return nil
+}

vendor/github.com/rancher/norman/types/mapping/mapper/swap.go

@@ -0,0 +1,20 @@
+package mapper
+
+type Swap struct {
+	Left, Right string
+}
+
+func (s Swap) Forward(data map[string]interface{}) {
+	rightValue, rightOk := data[s.Right]
+	leftValue, leftOk := data[s.Left]
+	if rightOk {
+		data[s.Left] = rightValue
+	}
+	if leftOk {
+		data[s.Right] = leftValue
+	}
+}
+
+func (s Swap) Back(data map[string]interface{}) {
+	s.Forward(data)
+}

vendor/github.com/rancher/norman/types/mapping/mapper/type.go

@@ -0,0 +1 @@
+package mapper

vendor/github.com/rancher/norman/types/mapping/mapper/union_embed.go

@@ -0,0 +1,68 @@
+package mapper
+
+import (
+	"fmt"
+
+	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/convert"
+)
+
+type UnionMapping struct {
+	FieldName   string
+	CheckFields []string
+}
+
+type UnionEmbed struct {
+	Fields []UnionMapping
+	embeds map[string]Embed
+}
+
+func (u *UnionEmbed) FromInternal(data map[string]interface{}) {
+	for _, embed := range u.embeds {
+		embed.FromInternal(data)
+	}
+}
+
+func (u *UnionEmbed) ToInternal(data map[string]interface{}) {
+outer:
+	for _, mapper := range u.Fields {
+		if len(mapper.CheckFields) == 0 {
+			continue
+		}
+
+		for _, check := range mapper.CheckFields {
+			v, ok := data[check]
+			if !ok || convert.IsEmpty(v) {
+				continue outer
+			}
+		}
+
+		embed := u.embeds[mapper.FieldName]
+		embed.ToInternal(data)
+		return
+	}
+}
+
+func (u *UnionEmbed) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	u.embeds = map[string]Embed{}
+
+	for _, mapping := range u.Fields {
+		embed := Embed{
+			Field:          mapping.FieldName,
+			ignoreOverride: true,
+		}
+		if err := embed.ModifySchema(schema, schemas); err != nil {
+			return err
+		}
+
+		for _, checkField := range mapping.CheckFields {
+			if _, ok := schema.ResourceFields[checkField]; !ok {
+				return fmt.Errorf("missing check field %s on schema %s", checkField, schema.ID)
+			}
+		}
+
+		u.embeds[mapping.FieldName] = embed
+	}
+
+	return nil
+}

vendor/github.com/rancher/norman/types/mapping/mapper/values.go

@@ -0,0 +1,83 @@
+package mapper
+
+func RemoveValue(data map[string]interface{}, keys ...string) (interface{}, bool) {
+	for i, key := range keys {
+		if i == len(keys)-1 {
+			val, ok := data[key]
+			delete(data, key)
+			return val, ok
+		} else {
+			data, _ = data[key].(map[string]interface{})
+		}
+	}
+
+	return nil, false
+}
+
+func GetSlice(data map[string]interface{}, keys ...string) ([]map[string]interface{}, bool) {
+	val, ok := GetValue(data, keys...)
+	if !ok {
+		return nil, ok
+	}
+
+	slice, typeOk := val.([]map[string]interface{})
+	if typeOk {
+		return slice, typeOk
+	}
+
+	sliceNext, typeOk := val.([]interface{})
+	if !typeOk {
+		return nil, typeOk
+	}
+
+	result := []map[string]interface{}{}
+	for _, val := range sliceNext {
+		if v, ok := val.(map[string]interface{}); ok {
+			result = append(result, v)
+		}
+	}
+
+	return result, true
+
+}
+
+func GetValueN(data map[string]interface{}, keys ...string) interface{} {
+	val, _ := GetValue(data, keys...)
+	return val
+}
+
+func GetValue(data map[string]interface{}, keys ...string) (interface{}, bool) {
+	for i, key := range keys {
+		if i == len(keys)-1 {
+			val, ok := data[key]
+			return val, ok
+		} else {
+			data, _ = data[key].(map[string]interface{})
+		}
+	}
+
+	return nil, false
+}
+
+func PutValue(data map[string]interface{}, val interface{}, keys ...string) {
+	// This is so ugly
+	for i, key := range keys {
+		if i == len(keys)-1 {
+			data[key] = val
+		} else {
+			newData, ok := data[key]
+			if ok {
+				newMap, ok := newData.(map[string]interface{})
+				if ok {
+					data = newMap
+				} else {
+					return
+				}
+			} else {
+				newMap := map[string]interface{}{}
+				data[key] = newMap
+				data = newMap
+			}
+		}
+	}
+}

vendor/github.com/rancher/norman/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{},
 	}
 

vendor/github.com/rancher/norman/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 == "" {

vendor/github.com/rancher/norman/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"`