Update ingress godeps

vendor/k8s.io/kubernetes/pkg/conversion/cloner.go

@@ -25,14 +25,14 @@ import (
 type Cloner struct {
 	// Map from the type to a function which can do the deep copy.
 	deepCopyFuncs          map[reflect.Type]reflect.Value
-	generatedDeepCopyFuncs map[reflect.Type]reflect.Value
+	generatedDeepCopyFuncs map[reflect.Type]func(in interface{}, out interface{}, c *Cloner) error
 }
 
 // NewCloner creates a new Cloner object.
 func NewCloner() *Cloner {
 	c := &Cloner{
 		deepCopyFuncs:          map[reflect.Type]reflect.Value{},
-		generatedDeepCopyFuncs: map[reflect.Type]reflect.Value{},
+		generatedDeepCopyFuncs: map[reflect.Type]func(in interface{}, out interface{}, c *Cloner) error{},
 	}
 	if err := c.RegisterDeepCopyFunc(byteSliceDeepCopy); err != nil {
 		// If one of the deep-copy functions is malformed, detect it immediately.
@@ -42,10 +42,10 @@ func NewCloner() *Cloner {
 }
 
 // Prevent recursing into every byte...
-func byteSliceDeepCopy(in []byte, out *[]byte, c *Cloner) error {
-	if in != nil {
-		*out = make([]byte, len(in))
-		copy(*out, in)
+func byteSliceDeepCopy(in *[]byte, out *[]byte, c *Cloner) error {
+	if *in != nil {
+		*out = make([]byte, len(*in))
+		copy(*out, *in)
 	} else {
 		*out = nil
 	}
@@ -63,10 +63,10 @@ func verifyDeepCopyFunctionSignature(ft reflect.Type) error {
 	if ft.NumOut() != 1 {
 		return fmt.Errorf("expected one 'out' param, got %v", ft)
 	}
-	if ft.In(1).Kind() != reflect.Ptr {
-		return fmt.Errorf("expected pointer arg for 'in' param 1, got: %v", ft)
+	if ft.In(0).Kind() != reflect.Ptr {
+		return fmt.Errorf("expected pointer arg for 'in' param 0, got: %v", ft)
 	}
-	if ft.In(1).Elem() != ft.In(0) {
+	if ft.In(1) != ft.In(0) {
 		return fmt.Errorf("expected 'in' param 0 the same as param 1, got: %v", ft)
 	}
 	var forClonerType Cloner
@@ -103,15 +103,17 @@ func (c *Cloner) RegisterDeepCopyFunc(deepCopyFunc interface{}) error {
 	return nil
 }
 
+// GeneratedDeepCopyFunc bundles an untyped generated deep-copy function of a type
+// with a reflection type object used as a key to lookup the deep-copy function.
+type GeneratedDeepCopyFunc struct {
+	Fn     func(in interface{}, out interface{}, c *Cloner) error
+	InType reflect.Type
+}
+
 // Similar to RegisterDeepCopyFunc, but registers deep copy function that were
 // automatically generated.
-func (c *Cloner) RegisterGeneratedDeepCopyFunc(deepCopyFunc interface{}) error {
-	fv := reflect.ValueOf(deepCopyFunc)
-	ft := fv.Type()
-	if err := verifyDeepCopyFunctionSignature(ft); err != nil {
-		return err
-	}
-	c.generatedDeepCopyFuncs[ft.In(0)] = fv
+func (c *Cloner) RegisterGeneratedDeepCopyFunc(fn GeneratedDeepCopyFunc) error {
+	c.generatedDeepCopyFuncs[fn.InType] = fn.Fn
 	return nil
 }
 
@@ -135,25 +137,35 @@ func (c *Cloner) DeepCopy(in interface{}) (interface{}, error) {
 func (c *Cloner) deepCopy(src reflect.Value) (reflect.Value, error) {
 	inType := src.Type()
 
+	switch src.Kind() {
+	case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
+		if src.IsNil() {
+			return src, nil
+		}
+	}
+
 	if fv, ok := c.deepCopyFuncs[inType]; ok {
 		return c.customDeepCopy(src, fv)
 	}
 	if fv, ok := c.generatedDeepCopyFuncs[inType]; ok {
-		return c.customDeepCopy(src, fv)
+		var outValue reflect.Value
+		outValue = reflect.New(inType.Elem())
+		err := fv(src.Interface(), outValue.Interface(), c)
+		return outValue, err
 	}
 	return c.defaultDeepCopy(src)
 }
 
 func (c *Cloner) customDeepCopy(src, fv reflect.Value) (reflect.Value, error) {
-	outValue := reflect.New(src.Type())
+	outValue := reflect.New(src.Type().Elem())
 	args := []reflect.Value{src, outValue, reflect.ValueOf(c)}
 	result := fv.Call(args)[0].Interface()
 	// This convolution is necessary because nil interfaces won't convert
 	// to error.
 	if result == nil {
-		return outValue.Elem(), nil
+		return outValue, nil
 	}
-	return outValue.Elem(), result.(error)
+	return outValue, result.(error)
 }
 
 func (c *Cloner) defaultDeepCopy(src reflect.Value) (reflect.Value, error) {

vendor/k8s.io/kubernetes/pkg/conversion/converter.go

@@ -213,6 +213,8 @@ type Meta struct {
 	// KeyNameMapping is an optional function which may map the listed key (field name)
 	// into a source and destination value.
 	KeyNameMapping FieldMappingFunc
+	// Context is an optional field that callers may use to pass info to conversion functions.
+	Context interface{}
 }
 
 // scope contains information about an ongoing conversion.