Update vendored dependencies

vendor/k8s.io/apimachinery/pkg/api/meta/OWNERS

@@ -10,7 +10,6 @@ reviewers:
 - liggitt
 - nikhiljindal
 - gmarek
-- kargakis
 - janetkuo
 - ncdc
 - eparis

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/OWNERS

@@ -12,7 +12,6 @@ reviewers:
 - davidopp
 - sttts
 - quinton-hoole
-- kargakis
 - luxas
 - janetkuo
 - justinsb

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto

@@ -101,6 +101,7 @@ message APIResourceList {
 // discover the API at /api, which is the root path of the legacy v1 API.
 // 
 // +protobuf.options.(gogoproto.goproto_stringer)=false
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 message APIVersions {
   // versions are the api versions that are available.
   repeated string versions = 1;
@@ -721,6 +722,8 @@ message Timestamp {
 // TypeMeta describes an individual object in an API response or request
 // with strings representing the type of the object and its API schema version.
 // Structures that are versioned or persisted should inline TypeMeta.
+// 
+// +k8s:deepcopy-gen=false
 message TypeMeta {
   // Kind is a string value representing the REST resource this object represents.
   // Servers may infer this from the endpoint the client submits requests to.
@@ -751,6 +754,8 @@ message Verbs {
 // Event represents a single event to a watched resource.
 // 
 // +protobuf=true
+// +k8s:deepcopy-gen=true
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 message WatchEvent {
   optional string type = 1;
 

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/time.go

@@ -37,11 +37,11 @@ type Time struct {
 	time.Time `protobuf:"-"`
 }
 
-// DeepCopy returns a deep-copy of the Time value.  The underlying time.Time
+// DeepCopyInto creates a deep-copy of the Time value.  The underlying time.Time
 // type is effectively immutable in the time API, so it is safe to
 // copy-by-assign, despite the presence of (unexported) Pointer fields.
-func (t Time) DeepCopy() Time {
-	return t
+func (t *Time) DeepCopyInto(out *Time) {
+	*out = *t
 }
 
 // String returns the representation of the time.

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types.go

@@ -35,6 +35,8 @@ import (
 // TypeMeta describes an individual object in an API response or request
 // with strings representing the type of the object and its API schema version.
 // Structures that are versioned or persisted should inline TypeMeta.
+//
+// +k8s:deepcopy-gen=false
 type TypeMeta struct {
 	// Kind is a string value representing the REST resource this object represents.
 	// Servers may infer this from the endpoint the client submits requests to.
@@ -298,6 +300,8 @@ type OwnerReference struct {
 	BlockOwnerDeletion *bool `json:"blockOwnerDeletion,omitempty" protobuf:"varint,7,opt,name=blockOwnerDeletion"`
 }
 
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
 // ListOptions is the query options to a standard REST list call.
 type ListOptions struct {
 	TypeMeta `json:",inline"`
@@ -330,6 +334,8 @@ type ListOptions struct {
 	TimeoutSeconds *int64 `json:"timeoutSeconds,omitempty" protobuf:"varint,5,opt,name=timeoutSeconds"`
 }
 
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
 // ExportOptions is the query options to the standard REST get call.
 type ExportOptions struct {
 	TypeMeta `json:",inline"`
@@ -339,6 +345,8 @@ type ExportOptions struct {
 	Exact bool `json:"exact" protobuf:"varint,2,opt,name=exact"`
 }
 
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
 // GetOptions is the standard query options to the standard REST get call.
 type GetOptions struct {
 	TypeMeta `json:",inline"`
@@ -370,6 +378,8 @@ const (
 	DeletePropagationForeground DeletionPropagation = "Foreground"
 )
 
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
 // DeleteOptions may be provided when deleting an API object.
 type DeleteOptions struct {
 	TypeMeta `json:",inline"`
@@ -408,6 +418,8 @@ type Preconditions struct {
 	UID *types.UID `json:"uid,omitempty" protobuf:"bytes,1,opt,name=uid,casttype=k8s.io/apimachinery/pkg/types.UID"`
 }
 
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
 // Status is a return value for calls that don't return other objects.
 type Status struct {
 	TypeMeta `json:",inline"`
@@ -660,6 +672,7 @@ const (
 // discover the API at /api, which is the root path of the legacy v1 API.
 //
 // +protobuf.options.(gogoproto.goproto_stringer)=false
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 type APIVersions struct {
 	TypeMeta `json:",inline"`
 	// versions are the api versions that are available.
@@ -674,6 +687,8 @@ type APIVersions struct {
 	ServerAddressByClientCIDRs []ServerAddressByClientCIDR `json:"serverAddressByClientCIDRs" protobuf:"bytes,2,rep,name=serverAddressByClientCIDRs"`
 }
 
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
 // APIGroupList is a list of APIGroup, to allow clients to discover the API at
 // /apis.
 type APIGroupList struct {
@@ -682,6 +697,8 @@ type APIGroupList struct {
 	Groups []APIGroup `json:"groups" protobuf:"bytes,1,rep,name=groups"`
 }
 
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
 // APIGroup contains the name, the supported versions, and the preferred version
 // of a group.
 type APIGroup struct {
@@ -754,6 +771,8 @@ func (vs Verbs) String() string {
 	return fmt.Sprintf("%v", []string(vs))
 }
 
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
 // APIResourceList is a list of APIResource, it is used to expose the name of the
 // resources supported in a specific group and version, and if the resource
 // is namespaced.

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/BUILD

@@ -17,11 +17,15 @@ go_test(
 
 go_library(
     name = "go_default_library",
-    srcs = ["unstructured.go"],
+    srcs = [
+        "unstructured.go",
+        "zz_generated.deepcopy.go",
+    ],
     tags = ["automanaged"],
     deps = [
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/conversion/unstructured:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured.go

@@ -43,6 +43,8 @@ import (
 // type if you are dealing with objects that are not in the server meta v1 schema.
 //
 // TODO: make the serialization part of this type distinct from the field accessors.
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+// +k8s:deepcopy-gen=true
 type Unstructured struct {
 	// Object is a JSON compatible map with string, float, int, bool, []interface{}, or
 	// map[string]interface{}
@@ -143,6 +145,50 @@ func (u *Unstructured) UnmarshalJSON(b []byte) error {
 	return err
 }
 
+func deepCopyJSON(x interface{}) interface{} {
+	switch x := x.(type) {
+	case map[string]interface{}:
+		clone := make(map[string]interface{}, len(x))
+		for k, v := range x {
+			clone[k] = deepCopyJSON(v)
+		}
+		return clone
+	case []interface{}:
+		clone := make([]interface{}, len(x))
+		for i := range x {
+			clone[i] = deepCopyJSON(x[i])
+		}
+		return clone
+	default:
+		// only non-pointer values (float64, int64, bool, string) are left. These can be copied by-value.
+		return x
+	}
+}
+
+func (in *Unstructured) DeepCopy() *Unstructured {
+	if in == nil {
+		return nil
+	}
+	out := new(Unstructured)
+	*out = *in
+	out.Object = deepCopyJSON(in.Object).(map[string]interface{})
+	return out
+}
+
+func (in *UnstructuredList) DeepCopy() *UnstructuredList {
+	if in == nil {
+		return nil
+	}
+	out := new(UnstructuredList)
+	*out = *in
+	out.Object = deepCopyJSON(in.Object).(map[string]interface{})
+	out.Items = make([]Unstructured, len(in.Items))
+	for i := range in.Items {
+		in.Items[i].DeepCopyInto(&out.Items[i])
+	}
+	return out
+}
+
 func getNestedField(obj map[string]interface{}, fields ...string) interface{} {
 	var val interface{} = obj
 	for _, field := range fields {
@@ -541,6 +587,8 @@ func (u *Unstructured) SetClusterName(clusterName string) {
 // UnstructuredList allows lists that do not have Golang structs
 // registered to be manipulated generically. This can be used to deal
 // with the API lists from a plug-in.
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+// +k8s:deepcopy-gen=true
 type UnstructuredList struct {
 	Object map[string]interface{}
 

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/zz_generated.deepcopy.go

@@ -0,0 +1,73 @@
+// +build !ignore_autogenerated
+
+/*
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package unstructured
+
+import (
+	conversion "k8s.io/apimachinery/pkg/conversion"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	reflect "reflect"
+)
+
+// Deprecated: GetGeneratedDeepCopyFuncs returns the generated funcs, since we aren't registering them.
+func GetGeneratedDeepCopyFuncs() []conversion.GeneratedDeepCopyFunc {
+	return []conversion.GeneratedDeepCopyFunc{
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*Unstructured).DeepCopyInto(out.(*Unstructured))
+			return nil
+		}, InType: reflect.TypeOf(&Unstructured{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*UnstructuredList).DeepCopyInto(out.(*UnstructuredList))
+			return nil
+		}, InType: reflect.TypeOf(&UnstructuredList{})},
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Unstructured) DeepCopyInto(out *Unstructured) {
+	clone := in.DeepCopy()
+	*out = *clone
+	return
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (x *Unstructured) DeepCopyObject() runtime.Object {
+	if c := x.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *UnstructuredList) DeepCopyInto(out *UnstructuredList) {
+	clone := in.DeepCopy()
+	*out = *clone
+	return
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (x *UnstructuredList) DeepCopyObject() runtime.Object {
+	if c := x.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/watch.go

@@ -26,6 +26,8 @@ import (
 // Event represents a single event to a watched resource.
 //
 // +protobuf=true
+// +k8s:deepcopy-gen=true
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 type WatchEvent struct {
 	Type string `json:"type" protobuf:"bytes,1,opt,name=type"`
 
@@ -78,3 +80,10 @@ type InternalEvent watch.Event
 
 func (e *InternalEvent) GetObjectKind() schema.ObjectKind { return schema.EmptyObjectKind }
 func (e *WatchEvent) GetObjectKind() schema.ObjectKind    { return schema.EmptyObjectKind }
+func (e *InternalEvent) DeepCopyObject() runtime.Object {
+	if c := e.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1alpha1/BUILD

@@ -10,6 +10,7 @@ load(
 go_library(
     name = "go_default_library",
     srcs = [
+        "deepcopy.go",
         "doc.go",
         "generated.pb.go",
         "register.go",

vendor/k8s.io/apimachinery/pkg/apis/meta/v1alpha1/deepcopy.go

@@ -0,0 +1,61 @@
+/*
+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 v1alpha1
+
+func (in *TableRow) DeepCopy() *TableRow {
+	if in == nil {
+		return nil
+	}
+
+	out := new(TableRow)
+
+	if in.Cells != nil {
+		out.Cells = make([]interface{}, len(in.Cells))
+		for i := range in.Cells {
+			out.Cells[i] = deepCopyJSON(in.Cells[i])
+		}
+	}
+
+	if in.Conditions != nil {
+		out.Conditions = make([]TableRowCondition, len(in.Conditions))
+		for i := range in.Conditions {
+			in.Conditions[i].DeepCopyInto(&out.Conditions[i])
+		}
+	}
+
+	in.Object.DeepCopyInto(&out.Object)
+	return out
+}
+
+func deepCopyJSON(x interface{}) interface{} {
+	switch x := x.(type) {
+	case map[string]interface{}:
+		clone := make(map[string]interface{}, len(x))
+		for k, v := range x {
+			clone[k] = deepCopyJSON(v)
+		}
+		return clone
+	case []interface{}:
+		clone := make([]interface{}, len(x))
+		for i := range x {
+			clone[i] = deepCopyJSON(x[i])
+		}
+		return clone
+	default:
+		return x
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1alpha1/generated.proto

@@ -31,6 +31,7 @@ option go_package = "v1alpha1";
 
 // PartialObjectMetadata is a generic representation of any object with ObjectMeta. It allows clients
 // to get access to a particular ObjectMeta schema without knowing the details of the version.
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 message PartialObjectMetadata {
   // Standard object's metadata.
   // More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata
@@ -39,12 +40,14 @@ message PartialObjectMetadata {
 }
 
 // PartialObjectMetadataList contains a list of objects containing only their metadata
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 message PartialObjectMetadataList {
   // items contains each of the included items.
   repeated PartialObjectMetadata items = 1;
 }
 
 // TableOptions are used when a Table is requested by the caller.
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 message TableOptions {
   // includeObject decides whether to include each object along with its columnar information.
   // Specifying "None" will return no object, specifying "Object" will return the full object contents, and

vendor/k8s.io/apimachinery/pkg/apis/meta/v1alpha1/types.go

@@ -28,6 +28,7 @@ import (
 // Table is a tabular representation of a set of API resources. The server transforms the
 // object into a set of preferred columns for quickly reviewing the objects.
 // +protobuf=false
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 type Table struct {
 	v1.TypeMeta `json:",inline"`
 	// Standard list metadata.
@@ -129,6 +130,7 @@ const (
 )
 
 // TableOptions are used when a Table is requested by the caller.
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 type TableOptions struct {
 	v1.TypeMeta `json:",inline"`
 	// includeObject decides whether to include each object along with its columnar information.
@@ -140,6 +142,7 @@ type TableOptions struct {
 
 // PartialObjectMetadata is a generic representation of any object with ObjectMeta. It allows clients
 // to get access to a particular ObjectMeta schema without knowing the details of the version.
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 type PartialObjectMetadata struct {
 	v1.TypeMeta `json:",inline"`
 	// Standard object's metadata.
@@ -149,6 +152,7 @@ type PartialObjectMetadata struct {
 }
 
 // PartialObjectMetadataList contains a list of objects containing only their metadata
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 type PartialObjectMetadataList struct {
 	v1.TypeMeta `json:",inline"`
 

vendor/k8s.io/apimachinery/pkg/apis/meta/v1alpha1/zz_generated.deepcopy.go

@@ -21,144 +21,210 @@ limitations under the License.
 package v1alpha1
 
 import (
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	conversion "k8s.io/apimachinery/pkg/conversion"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	reflect "reflect"
 )
 
-// GetGeneratedDeepCopyFuncs returns the generated funcs, since we aren't registering them.
+// Deprecated: GetGeneratedDeepCopyFuncs returns the generated funcs, since we aren't registering them.
 func GetGeneratedDeepCopyFuncs() []conversion.GeneratedDeepCopyFunc {
 	return []conversion.GeneratedDeepCopyFunc{
-		{Fn: DeepCopy_v1alpha1_PartialObjectMetadata, InType: reflect.TypeOf(&PartialObjectMetadata{})},
-		{Fn: DeepCopy_v1alpha1_PartialObjectMetadataList, InType: reflect.TypeOf(&PartialObjectMetadataList{})},
-		{Fn: DeepCopy_v1alpha1_Table, InType: reflect.TypeOf(&Table{})},
-		{Fn: DeepCopy_v1alpha1_TableColumnDefinition, InType: reflect.TypeOf(&TableColumnDefinition{})},
-		{Fn: DeepCopy_v1alpha1_TableOptions, InType: reflect.TypeOf(&TableOptions{})},
-		{Fn: DeepCopy_v1alpha1_TableRow, InType: reflect.TypeOf(&TableRow{})},
-		{Fn: DeepCopy_v1alpha1_TableRowCondition, InType: reflect.TypeOf(&TableRowCondition{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*PartialObjectMetadata).DeepCopyInto(out.(*PartialObjectMetadata))
+			return nil
+		}, InType: reflect.TypeOf(&PartialObjectMetadata{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*PartialObjectMetadataList).DeepCopyInto(out.(*PartialObjectMetadataList))
+			return nil
+		}, InType: reflect.TypeOf(&PartialObjectMetadataList{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*Table).DeepCopyInto(out.(*Table))
+			return nil
+		}, InType: reflect.TypeOf(&Table{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*TableColumnDefinition).DeepCopyInto(out.(*TableColumnDefinition))
+			return nil
+		}, InType: reflect.TypeOf(&TableColumnDefinition{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*TableOptions).DeepCopyInto(out.(*TableOptions))
+			return nil
+		}, InType: reflect.TypeOf(&TableOptions{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*TableRow).DeepCopyInto(out.(*TableRow))
+			return nil
+		}, InType: reflect.TypeOf(&TableRow{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*TableRowCondition).DeepCopyInto(out.(*TableRowCondition))
+			return nil
+		}, InType: reflect.TypeOf(&TableRowCondition{})},
 	}
 }
 
-// DeepCopy_v1alpha1_PartialObjectMetadata is an autogenerated deepcopy function.
-func DeepCopy_v1alpha1_PartialObjectMetadata(in interface{}, out interface{}, c *conversion.Cloner) error {
-	{
-		in := in.(*PartialObjectMetadata)
-		out := out.(*PartialObjectMetadata)
-		*out = *in
-		if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil {
-			return err
-		} else {
-			out.ObjectMeta = *newVal.(*v1.ObjectMeta)
-		}
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PartialObjectMetadata) DeepCopyInto(out *PartialObjectMetadata) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	return
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new PartialObjectMetadata.
+func (x *PartialObjectMetadata) DeepCopy() *PartialObjectMetadata {
+	if x == nil {
+		return nil
+	}
+	out := new(PartialObjectMetadata)
+	x.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (x *PartialObjectMetadata) DeepCopyObject() runtime.Object {
+	if c := x.DeepCopy(); c != nil {
+		return c
+	} else {
 		return nil
 	}
 }
 
-// DeepCopy_v1alpha1_PartialObjectMetadataList is an autogenerated deepcopy function.
-func DeepCopy_v1alpha1_PartialObjectMetadataList(in interface{}, out interface{}, c *conversion.Cloner) error {
-	{
-		in := in.(*PartialObjectMetadataList)
-		out := out.(*PartialObjectMetadataList)
-		*out = *in
-		if in.Items != nil {
-			in, out := &in.Items, &out.Items
-			*out = make([]*PartialObjectMetadata, len(*in))
-			for i := range *in {
-				if newVal, err := c.DeepCopy(&(*in)[i]); err != nil {
-					return err
-				} else {
-					(*out)[i] = *newVal.(**PartialObjectMetadata)
-				}
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PartialObjectMetadataList) DeepCopyInto(out *PartialObjectMetadataList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]*PartialObjectMetadata, len(*in))
+		for i := range *in {
+			if (*in)[i] == nil {
+				(*out)[i] = nil
+			} else {
+				(*out)[i] = new(PartialObjectMetadata)
+				(*in)[i].DeepCopyInto((*out)[i])
 			}
 		}
+	}
+	return
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new PartialObjectMetadataList.
+func (x *PartialObjectMetadataList) DeepCopy() *PartialObjectMetadataList {
+	if x == nil {
+		return nil
+	}
+	out := new(PartialObjectMetadataList)
+	x.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (x *PartialObjectMetadataList) DeepCopyObject() runtime.Object {
+	if c := x.DeepCopy(); c != nil {
+		return c
+	} else {
 		return nil
 	}
 }
 
-// DeepCopy_v1alpha1_Table is an autogenerated deepcopy function.
-func DeepCopy_v1alpha1_Table(in interface{}, out interface{}, c *conversion.Cloner) error {
-	{
-		in := in.(*Table)
-		out := out.(*Table)
-		*out = *in
-		if in.ColumnDefinitions != nil {
-			in, out := &in.ColumnDefinitions, &out.ColumnDefinitions
-			*out = make([]TableColumnDefinition, len(*in))
-			copy(*out, *in)
-		}
-		if in.Rows != nil {
-			in, out := &in.Rows, &out.Rows
-			*out = make([]TableRow, len(*in))
-			for i := range *in {
-				if newVal, err := c.DeepCopy(&(*in)[i]); err != nil {
-					return err
-				} else {
-					(*out)[i] = *newVal.(*TableRow)
-				}
-			}
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Table) DeepCopyInto(out *Table) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.ColumnDefinitions != nil {
+		in, out := &in.ColumnDefinitions, &out.ColumnDefinitions
+		*out = make([]TableColumnDefinition, len(*in))
+		copy(*out, *in)
+	}
+	if in.Rows != nil {
+		in, out := &in.Rows, &out.Rows
+		*out = make([]TableRow, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
 		}
+	}
+	return
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new Table.
+func (x *Table) DeepCopy() *Table {
+	if x == nil {
+		return nil
+	}
+	out := new(Table)
+	x.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (x *Table) DeepCopyObject() runtime.Object {
+	if c := x.DeepCopy(); c != nil {
+		return c
+	} else {
 		return nil
 	}
 }
 
-// DeepCopy_v1alpha1_TableColumnDefinition is an autogenerated deepcopy function.
-func DeepCopy_v1alpha1_TableColumnDefinition(in interface{}, out interface{}, c *conversion.Cloner) error {
-	{
-		in := in.(*TableColumnDefinition)
-		out := out.(*TableColumnDefinition)
-		*out = *in
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *TableColumnDefinition) DeepCopyInto(out *TableColumnDefinition) {
+	*out = *in
+	return
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new TableColumnDefinition.
+func (x *TableColumnDefinition) DeepCopy() *TableColumnDefinition {
+	if x == nil {
+		return nil
+	}
+	out := new(TableColumnDefinition)
+	x.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *TableOptions) DeepCopyInto(out *TableOptions) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	return
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new TableOptions.
+func (x *TableOptions) DeepCopy() *TableOptions {
+	if x == nil {
+		return nil
+	}
+	out := new(TableOptions)
+	x.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (x *TableOptions) DeepCopyObject() runtime.Object {
+	if c := x.DeepCopy(); c != nil {
+		return c
+	} else {
 		return nil
 	}
 }
 
-// DeepCopy_v1alpha1_TableOptions is an autogenerated deepcopy function.
-func DeepCopy_v1alpha1_TableOptions(in interface{}, out interface{}, c *conversion.Cloner) error {
-	{
-		in := in.(*TableOptions)
-		out := out.(*TableOptions)
-		*out = *in
-		return nil
-	}
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *TableRow) DeepCopyInto(out *TableRow) {
+	clone := in.DeepCopy()
+	*out = *clone
+	return
 }
 
-// DeepCopy_v1alpha1_TableRow is an autogenerated deepcopy function.
-func DeepCopy_v1alpha1_TableRow(in interface{}, out interface{}, c *conversion.Cloner) error {
-	{
-		in := in.(*TableRow)
-		out := out.(*TableRow)
-		*out = *in
-		if in.Cells != nil {
-			in, out := &in.Cells, &out.Cells
-			*out = make([]interface{}, len(*in))
-			for i := range *in {
-				if newVal, err := c.DeepCopy(&(*in)[i]); err != nil {
-					return err
-				} else {
-					(*out)[i] = *newVal.(*interface{})
-				}
-			}
-		}
-		if in.Conditions != nil {
-			in, out := &in.Conditions, &out.Conditions
-			*out = make([]TableRowCondition, len(*in))
-			copy(*out, *in)
-		}
-		if newVal, err := c.DeepCopy(&in.Object); err != nil {
-			return err
-		} else {
-			out.Object = *newVal.(*runtime.RawExtension)
-		}
-		return nil
-	}
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *TableRowCondition) DeepCopyInto(out *TableRowCondition) {
+	*out = *in
+	return
 }
 
-// DeepCopy_v1alpha1_TableRowCondition is an autogenerated deepcopy function.
-func DeepCopy_v1alpha1_TableRowCondition(in interface{}, out interface{}, c *conversion.Cloner) error {
-	{
-		in := in.(*TableRowCondition)
-		out := out.(*TableRowCondition)
-		*out = *in
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new TableRowCondition.
+func (x *TableRowCondition) DeepCopy() *TableRowCondition {
+	if x == nil {
 		return nil
 	}
+	out := new(TableRowCondition)
+	x.DeepCopyInto(out)
+	return out
 }

vendor/k8s.io/apimachinery/pkg/conversion/unstructured/BUILD

@@ -14,8 +14,6 @@ go_test(
     library = ":go_default_library",
     tags = ["automanaged"],
     deps = [
-        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/diff:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/json:go_default_library",
     ],

vendor/k8s.io/apimachinery/pkg/conversion/unstructured/converter.go

@@ -420,6 +420,12 @@ func toUnstructuredViaJSON(obj interface{}, u *map[string]interface{}) error {
 	return json.Unmarshal(data, u)
 }
 
+var (
+	nullBytes  = []byte("null")
+	trueBytes  = []byte("true")
+	falseBytes = []byte("false")
+)
+
 func toUnstructured(sv, dv reflect.Value) error {
 	st, dt := sv.Type(), dv.Type()
 
@@ -435,33 +441,58 @@ func toUnstructured(sv, dv reflect.Value) error {
 		if err != nil {
 			return err
 		}
-		if bytes.Equal(data, []byte("null")) {
+		switch {
+		case len(data) == 0:
+			return fmt.Errorf("error decoding from json: empty value")
+
+		case bytes.Equal(data, nullBytes):
 			// We're done - we don't need to store anything.
-		} else {
-			switch {
-			case len(data) > 0 && data[0] == '"':
-				var result string
-				err := json.Unmarshal(data, &result)
-				if err != nil {
-					return fmt.Errorf("error decoding from json: %v", err)
-				}
-				dv.Set(reflect.ValueOf(result))
-			case len(data) > 0 && data[0] == '{':
-				result := make(map[string]interface{})
-				err := json.Unmarshal(data, &result)
-				if err != nil {
-					return fmt.Errorf("error decoding from json: %v", err)
-				}
-				dv.Set(reflect.ValueOf(result))
-			default:
-				var result int64
-				err := json.Unmarshal(data, &result)
-				if err != nil {
-					return fmt.Errorf("error decoding from json: %v", err)
-				}
-				dv.Set(reflect.ValueOf(result))
+
+		case bytes.Equal(data, trueBytes):
+			dv.Set(reflect.ValueOf(true))
+
+		case bytes.Equal(data, falseBytes):
+			dv.Set(reflect.ValueOf(false))
+
+		case data[0] == '"':
+			var result string
+			err := json.Unmarshal(data, &result)
+			if err != nil {
+				return fmt.Errorf("error decoding string from json: %v", err)
+			}
+			dv.Set(reflect.ValueOf(result))
+
+		case data[0] == '{':
+			result := make(map[string]interface{})
+			err := json.Unmarshal(data, &result)
+			if err != nil {
+				return fmt.Errorf("error decoding object from json: %v", err)
+			}
+			dv.Set(reflect.ValueOf(result))
+
+		case data[0] == '[':
+			result := make([]interface{}, 0)
+			err := json.Unmarshal(data, &result)
+			if err != nil {
+				return fmt.Errorf("error decoding array from json: %v", err)
+			}
+			dv.Set(reflect.ValueOf(result))
+
+		default:
+			var (
+				resultInt   int64
+				resultFloat float64
+				err         error
+			)
+			if err = json.Unmarshal(data, &resultInt); err == nil {
+				dv.Set(reflect.ValueOf(resultInt))
+			} else if err = json.Unmarshal(data, &resultFloat); err == nil {
+				dv.Set(reflect.ValueOf(resultFloat))
+			} else {
+				return fmt.Errorf("error decoding number from json: %v", err)
 			}
 		}
+
 		return nil
 	}
 

vendor/k8s.io/apimachinery/pkg/fields/selector.go

@@ -50,6 +50,9 @@ type Selector interface {
 
 	// String returns a human readable string that represents this selector.
 	String() string
+
+	// Make a deep copy of the selector.
+	DeepCopySelector() Selector
 }
 
 // Everything returns a selector that matches all fields.
@@ -99,6 +102,15 @@ func (t *hasTerm) String() string {
 	return fmt.Sprintf("%v=%v", t.field, EscapeValue(t.value))
 }
 
+func (t *hasTerm) DeepCopySelector() Selector {
+	if t == nil {
+		return nil
+	}
+	out := new(hasTerm)
+	*out = *t
+	return out
+}
+
 type notHasTerm struct {
 	field, value string
 }
@@ -138,6 +150,15 @@ func (t *notHasTerm) String() string {
 	return fmt.Sprintf("%v!=%v", t.field, EscapeValue(t.value))
 }
 
+func (t *notHasTerm) DeepCopySelector() Selector {
+	if t == nil {
+		return nil
+	}
+	out := new(notHasTerm)
+	*out = *t
+	return out
+}
+
 type andTerm []Selector
 
 func (t andTerm) Matches(ls Fields) bool {
@@ -207,6 +228,17 @@ func (t andTerm) String() string {
 	return strings.Join(terms, ",")
 }
 
+func (t andTerm) DeepCopySelector() Selector {
+	if t == nil {
+		return nil
+	}
+	out := make([]Selector, len(t))
+	for i := range t {
+		out[i] = t[i].DeepCopySelector()
+	}
+	return andTerm(out)
+}
+
 // SelectorFromSet returns a Selector which will match exactly the given Set. A
 // nil Set is considered equivalent to Everything().
 func SelectorFromSet(ls Set) Selector {

vendor/k8s.io/apimachinery/pkg/labels/BUILD

@@ -28,10 +28,12 @@ go_library(
         "doc.go",
         "labels.go",
         "selector.go",
+        "zz_generated.deepcopy.go",
     ],
     tags = ["automanaged"],
     deps = [
         "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/selection:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/validation:go_default_library",

vendor/k8s.io/apimachinery/pkg/labels/selector.go

@@ -51,6 +51,9 @@ type Selector interface {
 	// If there are querying parameters, it will return converted requirements and selectable=true.
 	// If this selector doesn't want to select anything, it will return selectable=false.
 	Requirements() (requirements Requirements, selectable bool)
+
+	// Make a deep copy of the selector.
+	DeepCopySelector() Selector
 }
 
 // Everything returns a selector that matches all labels.
@@ -65,6 +68,7 @@ func (n nothingSelector) Empty() bool                        { return false }
 func (n nothingSelector) String() string                     { return "" }
 func (n nothingSelector) Add(_ ...Requirement) Selector      { return n }
 func (n nothingSelector) Requirements() (Requirements, bool) { return nil, false }
+func (n nothingSelector) DeepCopySelector() Selector         { return n }
 
 // Nothing returns a selector that matches no labels
 func Nothing() Selector {
@@ -78,6 +82,21 @@ func NewSelector() Selector {
 
 type internalSelector []Requirement
 
+func (s internalSelector) DeepCopy() internalSelector {
+	if s == nil {
+		return nil
+	}
+	result := make([]Requirement, len(s))
+	for i := range s {
+		s[i].DeepCopyInto(&result[i])
+	}
+	return result
+}
+
+func (s internalSelector) DeepCopySelector() Selector {
+	return s.DeepCopy()
+}
+
 // ByKey sorts requirements by key to obtain deterministic parser
 type ByKey []Requirement
 
@@ -91,6 +110,7 @@ func (a ByKey) Less(i, j int) bool { return a[i].key < a[j].key }
 // The zero value of Requirement is invalid.
 // Requirement implements both set based match and exact match
 // Requirement should be initialized via NewRequirement constructor for creating a valid Requirement.
+// +k8s:deepcopy-gen=true
 type Requirement struct {
 	key      string
 	operator selection.Operator

vendor/k8s.io/apimachinery/pkg/labels/zz_generated.deepcopy.go

@@ -0,0 +1,57 @@
+// +build !ignore_autogenerated
+
+/*
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package labels
+
+import (
+	conversion "k8s.io/apimachinery/pkg/conversion"
+	reflect "reflect"
+)
+
+// Deprecated: GetGeneratedDeepCopyFuncs returns the generated funcs, since we aren't registering them.
+func GetGeneratedDeepCopyFuncs() []conversion.GeneratedDeepCopyFunc {
+	return []conversion.GeneratedDeepCopyFunc{
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*Requirement).DeepCopyInto(out.(*Requirement))
+			return nil
+		}, InType: reflect.TypeOf(&Requirement{})},
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Requirement) DeepCopyInto(out *Requirement) {
+	*out = *in
+	if in.strValues != nil {
+		in, out := &in.strValues, &out.strValues
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new Requirement.
+func (x *Requirement) DeepCopy() *Requirement {
+	if x == nil {
+		return nil
+	}
+	out := new(Requirement)
+	x.DeepCopyInto(out)
+	return out
+}

vendor/k8s.io/apimachinery/pkg/runtime/embedded.go

@@ -30,6 +30,12 @@ type encodable struct {
 }
 
 func (e encodable) GetObjectKind() schema.ObjectKind { return e.obj.GetObjectKind() }
+func (e encodable) DeepCopyObject() Object {
+	var out encodable = e
+	out.obj = e.obj.DeepCopyObject()
+	copy(out.versions, e.versions)
+	return out
+}
 
 // NewEncodable creates an object that will be encoded with the provided codec on demand.
 // Provided as a convenience for test cases dealing with internal objects.

vendor/k8s.io/apimachinery/pkg/runtime/generated.proto

@@ -89,7 +89,7 @@ message RawExtension {
 // TypeMeta is provided here for convenience. You may use it directly from this package or define
 // your own with the same fields.
 // 
-// +k8s:deepcopy-gen=true
+// +k8s:deepcopy-gen=false
 // +protobuf=true
 // +k8s:openapi-gen=true
 message TypeMeta {
@@ -107,6 +107,7 @@ message TypeMeta {
 // metadata and field mutatation.
 // 
 // +k8s:deepcopy-gen=true
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 // +protobuf=true
 // +k8s:openapi-gen=true
 message Unknown {

vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go

@@ -234,6 +234,7 @@ type SelfLinker interface {
 // to return a no-op ObjectKindAccessor in cases where it is not expected to be serialized.
 type Object interface {
 	GetObjectKind() schema.ObjectKind
+	DeepCopyObject() Object
 }
 
 // Unstructured objects store values as map[string]interface{}, with only values that can be serialized

vendor/k8s.io/apimachinery/pkg/runtime/types.go

@@ -30,7 +30,7 @@ package runtime
 // TypeMeta is provided here for convenience. You may use it directly from this package or define
 // your own with the same fields.
 //
-// +k8s:deepcopy-gen=true
+// +k8s:deepcopy-gen=false
 // +protobuf=true
 // +k8s:openapi-gen=true
 type TypeMeta struct {
@@ -106,6 +106,7 @@ type RawExtension struct {
 // metadata and field mutatation.
 //
 // +k8s:deepcopy-gen=true
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 // +protobuf=true
 // +k8s:openapi-gen=true
 type Unknown struct {
@@ -124,6 +125,9 @@ type Unknown struct {
 
 // VersionedObjects is used by Decoders to give callers a way to access all versions
 // of an object during the decoding process.
+//
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+// +k8s:deepcopy-gen=true
 type VersionedObjects struct {
 	// Objects is the set of objects retrieved during decoding, in order of conversion.
 	// The 0 index is the object as serialized on the wire. If conversion has occurred,

vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go

@@ -25,59 +25,113 @@ import (
 	reflect "reflect"
 )
 
-// GetGeneratedDeepCopyFuncs returns the generated funcs, since we aren't registering them.
+// Deprecated: GetGeneratedDeepCopyFuncs returns the generated funcs, since we aren't registering them.
 func GetGeneratedDeepCopyFuncs() []conversion.GeneratedDeepCopyFunc {
 	return []conversion.GeneratedDeepCopyFunc{
-		{Fn: DeepCopy_runtime_RawExtension, InType: reflect.TypeOf(&RawExtension{})},
-		{Fn: DeepCopy_runtime_TypeMeta, InType: reflect.TypeOf(&TypeMeta{})},
-		{Fn: DeepCopy_runtime_Unknown, InType: reflect.TypeOf(&Unknown{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*RawExtension).DeepCopyInto(out.(*RawExtension))
+			return nil
+		}, InType: reflect.TypeOf(&RawExtension{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*Unknown).DeepCopyInto(out.(*Unknown))
+			return nil
+		}, InType: reflect.TypeOf(&Unknown{})},
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*VersionedObjects).DeepCopyInto(out.(*VersionedObjects))
+			return nil
+		}, InType: reflect.TypeOf(&VersionedObjects{})},
 	}
 }
 
-// DeepCopy_runtime_RawExtension is an autogenerated deepcopy function.
-func DeepCopy_runtime_RawExtension(in interface{}, out interface{}, c *conversion.Cloner) error {
-	{
-		in := in.(*RawExtension)
-		out := out.(*RawExtension)
-		*out = *in
-		if in.Raw != nil {
-			in, out := &in.Raw, &out.Raw
-			*out = make([]byte, len(*in))
-			copy(*out, *in)
-		}
-		// in.Object is kind 'Interface'
-		if in.Object != nil {
-			if newVal, err := c.DeepCopy(&in.Object); err != nil {
-				return err
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RawExtension) DeepCopyInto(out *RawExtension) {
+	*out = *in
+	if in.Raw != nil {
+		in, out := &in.Raw, &out.Raw
+		*out = make([]byte, len(*in))
+		copy(*out, *in)
+	}
+	if in.Object == nil {
+		out.Object = nil
+	} else {
+		out.Object = in.Object.DeepCopyObject()
+	}
+	return
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new RawExtension.
+func (x *RawExtension) DeepCopy() *RawExtension {
+	if x == nil {
+		return nil
+	}
+	out := new(RawExtension)
+	x.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Unknown) DeepCopyInto(out *Unknown) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	if in.Raw != nil {
+		in, out := &in.Raw, &out.Raw
+		*out = make([]byte, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new Unknown.
+func (x *Unknown) DeepCopy() *Unknown {
+	if x == nil {
+		return nil
+	}
+	out := new(Unknown)
+	x.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new Object.
+func (x *Unknown) DeepCopyObject() Object {
+	if c := x.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *VersionedObjects) DeepCopyInto(out *VersionedObjects) {
+	*out = *in
+	if in.Objects != nil {
+		in, out := &in.Objects, &out.Objects
+		*out = make([]Object, len(*in))
+		for i := range *in {
+			if (*in)[i] == nil {
+				(*out)[i] = nil
 			} else {
-				out.Object = *newVal.(*Object)
+				(*out)[i] = (*in)[i].DeepCopyObject()
 			}
 		}
-		return nil
 	}
+	return
 }
 
-// DeepCopy_runtime_TypeMeta is an autogenerated deepcopy function.
-func DeepCopy_runtime_TypeMeta(in interface{}, out interface{}, c *conversion.Cloner) error {
-	{
-		in := in.(*TypeMeta)
-		out := out.(*TypeMeta)
-		*out = *in
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new VersionedObjects.
+func (x *VersionedObjects) DeepCopy() *VersionedObjects {
+	if x == nil {
 		return nil
 	}
+	out := new(VersionedObjects)
+	x.DeepCopyInto(out)
+	return out
 }
 
-// DeepCopy_runtime_Unknown is an autogenerated deepcopy function.
-func DeepCopy_runtime_Unknown(in interface{}, out interface{}, c *conversion.Cloner) error {
-	{
-		in := in.(*Unknown)
-		out := out.(*Unknown)
-		*out = *in
-		if in.Raw != nil {
-			in, out := &in.Raw, &out.Raw
-			*out = make([]byte, len(*in))
-			copy(*out, *in)
-		}
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new Object.
+func (x *VersionedObjects) DeepCopyObject() Object {
+	if c := x.DeepCopy(); c != nil {
+		return c
+	} else {
 		return nil
 	}
 }

vendor/k8s.io/apimachinery/pkg/util/json/BUILD

@@ -8,15 +8,15 @@ load(
     "go_test",
 )
 
+go_library(
+    name = "go_default_library",
+    srcs = ["json.go"],
+    tags = ["automanaged"],
+)
+
 go_test(
     name = "go_default_test",
     srcs = ["json_test.go"],
     library = ":go_default_library",
     tags = ["automanaged"],
 )
-
-go_library(
-    name = "go_default_library",
-    srcs = ["json.go"],
-    tags = ["automanaged"],
-)

vendor/k8s.io/apimachinery/pkg/util/json/json.go

@@ -50,6 +50,18 @@ func Unmarshal(data []byte, v interface{}) error {
 		// If the decode succeeds, post-process the map to convert json.Number objects to int64 or float64
 		return convertMapNumbers(*v)
 
+	case *[]interface{}:
+		// Build a decoder from the given data
+		decoder := json.NewDecoder(bytes.NewBuffer(data))
+		// Preserve numbers, rather than casting to float64 automatically
+		decoder.UseNumber()
+		// Run the decode
+		if err := decoder.Decode(v); err != nil {
+			return err
+		}
+		// If the decode succeeds, post-process the map to convert json.Number objects to int64 or float64
+		return convertSliceNumbers(*v)
+
 	default:
 		return json.Unmarshal(data, v)
 	}

vendor/k8s.io/apimachinery/pkg/util/net/interface.go

@@ -36,19 +36,40 @@ const (
 	familyIPv6 AddressFamily = 6
 )
 
+const (
+	ipv4RouteFile = "/proc/net/route"
+	ipv6RouteFile = "/proc/net/ipv6_route"
+)
+
 type Route struct {
 	Interface   string
 	Destination net.IP
 	Gateway     net.IP
-	// TODO: add more fields here if needed
+	Family      AddressFamily
 }
 
-// getRoutes obtains the IPv4 routes, and filters out non-default routes.
-func getRoutes(input io.Reader) ([]Route, error) {
-	routes := []Route{}
-	if input == nil {
-		return nil, fmt.Errorf("input is nil")
+type RouteFile struct {
+	name  string
+	parse func(input io.Reader) ([]Route, error)
+}
+
+var (
+	v4File = RouteFile{name: ipv4RouteFile, parse: getIPv4DefaultRoutes}
+	v6File = RouteFile{name: ipv6RouteFile, parse: getIPv6DefaultRoutes}
+)
+
+func (rf RouteFile) extract() ([]Route, error) {
+	file, err := os.Open(rf.name)
+	if err != nil {
+		return nil, err
 	}
+	defer file.Close()
+	return rf.parse(file)
+}
+
+// getIPv4DefaultRoutes obtains the IPv4 routes, and filters out non-default routes.
+func getIPv4DefaultRoutes(input io.Reader) ([]Route, error) {
+	routes := []Route{}
 	scanner := bufio.NewReader(input)
 	for {
 		line, err := scanner.ReadString('\n')
@@ -60,11 +81,15 @@ func getRoutes(input io.Reader) ([]Route, error) {
 			continue
 		}
 		fields := strings.Fields(line)
-		dest, err := parseHexToIPv4(fields[1])
+		// Interested in fields:
+		//  0 - interface name
+		//  1 - destination address
+		//  2 - gateway
+		dest, err := parseIP(fields[1], familyIPv4)
 		if err != nil {
 			return nil, err
 		}
-		gw, err := parseHexToIPv4(fields[2])
+		gw, err := parseIP(fields[2], familyIPv4)
 		if err != nil {
 			return nil, err
 		}
@@ -75,15 +100,52 @@ func getRoutes(input io.Reader) ([]Route, error) {
 			Interface:   fields[0],
 			Destination: dest,
 			Gateway:     gw,
+			Family:      familyIPv4,
 		})
 	}
 	return routes, nil
 }
 
-// parseHexToIPv4 takes the hex IP address string from route file and converts it
-// from little endian to big endian for creation of a net.IP address.
-// a net.IP, using big endian ordering.
-func parseHexToIPv4(str string) (net.IP, error) {
+func getIPv6DefaultRoutes(input io.Reader) ([]Route, error) {
+	routes := []Route{}
+	scanner := bufio.NewReader(input)
+	for {
+		line, err := scanner.ReadString('\n')
+		if err == io.EOF {
+			break
+		}
+		fields := strings.Fields(line)
+		// Interested in fields:
+		//  0 - destination address
+		//  4 - gateway
+		//  9 - interface name
+		dest, err := parseIP(fields[0], familyIPv6)
+		if err != nil {
+			return nil, err
+		}
+		gw, err := parseIP(fields[4], familyIPv6)
+		if err != nil {
+			return nil, err
+		}
+		if !dest.Equal(net.IPv6zero) {
+			continue
+		}
+		if gw.Equal(net.IPv6zero) {
+			continue // loopback
+		}
+		routes = append(routes, Route{
+			Interface:   fields[9],
+			Destination: dest,
+			Gateway:     gw,
+			Family:      familyIPv6,
+		})
+	}
+	return routes, nil
+}
+
+// parseIP takes the hex IP address string from route file and converts it
+// to a net.IP address. For IPv4, the value must be converted to big endian.
+func parseIP(str string, family AddressFamily) (net.IP, error) {
 	if str == "" {
 		return nil, fmt.Errorf("input is nil")
 	}
@@ -91,10 +153,17 @@ func parseHexToIPv4(str string) (net.IP, error) {
 	if err != nil {
 		return nil, err
 	}
-	if len(bytes) != net.IPv4len {
-		return nil, fmt.Errorf("invalid IPv4 address in route")
+	if family == familyIPv4 {
+		if len(bytes) != net.IPv4len {
+			return nil, fmt.Errorf("invalid IPv4 address in route")
+		}
+		return net.IP([]byte{bytes[3], bytes[2], bytes[1], bytes[0]}), nil
 	}
-	return net.IP([]byte{bytes[3], bytes[2], bytes[1], bytes[0]}), nil
+	// Must be IPv6
+	if len(bytes) != net.IPv6len {
+		return nil, fmt.Errorf("invalid IPv6 address in route")
+	}
+	return net.IP(bytes), nil
 }
 
 func isInterfaceUp(intf *net.Interface) bool {
@@ -112,17 +181,8 @@ func isLoopbackOrPointToPoint(intf *net.Interface) bool {
 	return intf.Flags&(net.FlagLoopback|net.FlagPointToPoint) != 0
 }
 
-func inFamily(ip net.IP, expectedFamily AddressFamily) bool {
-	ipFamily := familyIPv4
-	if ip.To4() == nil {
-		ipFamily = familyIPv6
-	}
-	return ipFamily == expectedFamily
-}
-
-// getMatchingGlobalIP method checks all the IP addresses of a Interface looking
-// for a valid non-loopback/link-local address of the requested family and returns
-// it, if found.
+// getMatchingGlobalIP returns the first valid global unicast address of the given
+// 'family' from the list of 'addrs'.
 func getMatchingGlobalIP(addrs []net.Addr, family AddressFamily) (net.IP, error) {
 	if len(addrs) > 0 {
 		for i := range addrs {
@@ -131,12 +191,12 @@ func getMatchingGlobalIP(addrs []net.Addr, family AddressFamily) (net.IP, error)
 			if err != nil {
 				return nil, err
 			}
-			if inFamily(ip, family) {
+			if memberOf(ip, family) {
 				if ip.IsGlobalUnicast() {
 					glog.V(4).Infof("IP found %v", ip)
 					return ip, nil
 				} else {
-					glog.V(4).Infof("non-global IP found %v", ip)
+					glog.V(4).Infof("Non-global unicast address found %v", ip)
 				}
 			} else {
 				glog.V(4).Infof("%v is not an IPv%d address", ip, int(family))
@@ -147,6 +207,8 @@ func getMatchingGlobalIP(addrs []net.Addr, family AddressFamily) (net.IP, error)
 	return nil, nil
 }
 
+// getIPFromInterface gets the IPs on an interface and returns a global unicast address, if any. The
+// interface must be up, the IP must in the family requested, and the IP must be a global unicast address.
 func getIPFromInterface(intfName string, forFamily AddressFamily, nw networkInterfacer) (net.IP, error) {
 	intf, err := nw.InterfaceByName(intfName)
 	if err != nil {
@@ -231,21 +293,21 @@ func chooseIPFromHostInterfaces(nw networkInterfacer) (net.IP, error) {
 	return nil, fmt.Errorf("no acceptable interface with global unicast address found on host")
 }
 
-//ChooseHostInterface is a method used fetch an IP for a daemon.
-//It uses data from /proc/net/route file.
-//For a node with no internet connection ,it returns error
-//For a multi n/w interface node it returns the IP of the interface with gateway on it.
+// ChooseHostInterface is a method used fetch an IP for a daemon.
+// If there is no routing info file, it will choose a global IP from the system
+// interfaces. Otherwise, it will use IPv4 and IPv6 route information to return the
+// IP of the interface with a gateway on it (with priority given to IPv4). For a node
+// with no internet connection, it returns error.
 func ChooseHostInterface() (net.IP, error) {
 	var nw networkInterfacer = networkInterface{}
-	inFile, err := os.Open("/proc/net/route")
+	if _, err := os.Stat(ipv4RouteFile); os.IsNotExist(err) {
+		return chooseIPFromHostInterfaces(nw)
+	}
+	routes, err := getAllDefaultRoutes()
 	if err != nil {
-		if os.IsNotExist(err) {
-			return chooseIPFromHostInterfaces(nw)
-		}
 		return nil, err
 	}
-	defer inFile.Close()
-	return chooseHostInterfaceFromRoute(inFile, nw)
+	return chooseHostInterfaceFromRoute(routes, nw)
 }
 
 // networkInterfacer defines an interface for several net library functions. Production
@@ -273,22 +335,33 @@ func (_ networkInterface) Interfaces() ([]net.Interface, error) {
 	return net.Interfaces()
 }
 
-func chooseHostInterfaceFromRoute(inFile io.Reader, nw networkInterfacer) (net.IP, error) {
-	routes, err := getRoutes(inFile)
+// getAllDefaultRoutes obtains IPv4 and IPv6 default routes on the node. If unable
+// to read the IPv4 routing info file, we return an error. If unable to read the IPv6
+// routing info file (which is optional), we'll just use the IPv4 route information.
+// Using all the routing info, if no default routes are found, an error is returned.
+func getAllDefaultRoutes() ([]Route, error) {
+	routes, err := v4File.extract()
 	if err != nil {
 		return nil, err
 	}
+	v6Routes, _ := v6File.extract()
+	routes = append(routes, v6Routes...)
 	if len(routes) == 0 {
 		return nil, fmt.Errorf("No default routes.")
 	}
-	// TODO: append IPv6 routes for processing - currently only have IPv4 routes
+	return routes, nil
+}
+
+// chooseHostInterfaceFromRoute cycles through each default route provided, looking for a
+// global IP address from the interface for the route. Will first look all each IPv4 route for
+// an IPv4 IP, and then will look at each IPv6 route for an IPv6 IP.
+func chooseHostInterfaceFromRoute(routes []Route, nw networkInterfacer) (net.IP, error) {
 	for _, family := range []AddressFamily{familyIPv4, familyIPv6} {
 		glog.V(4).Infof("Looking for default routes with IPv%d addresses", uint(family))
 		for _, route := range routes {
-			// TODO: When have IPv6 routes, filter here to speed up processing
-			// if route.Family != family {
-			// 	continue
-			// }
+			if route.Family != family {
+				continue
+			}
 			glog.V(4).Infof("Default route transits interface %q", route.Interface)
 			finalIP, err := getIPFromInterface(route.Interface, family, nw)
 			if err != nil {

vendor/k8s.io/apimachinery/pkg/util/sets/BUILD

@@ -36,9 +36,9 @@ go_genrule(
         "string.go",
     ],
     cmd = """
-$(location //cmd/libs/go2idl/set-gen) \
+$(location //vendor/k8s.io/kube-gen/cmd/set-gen) \
     --input-dirs ./vendor/k8s.io/apimachinery/pkg/util/sets/types \
-    --output-base $(GENDIR)/vendor/k8s.io/apimachinery/pkg/util \
+    --output-base $$(dirname $$(dirname $(location :byte.go))) \
     --go-header-file $(location //hack/boilerplate:boilerplate.go.txt) \
     --output-package sets
     """,
@@ -46,7 +46,7 @@ $(location //cmd/libs/go2idl/set-gen) \
         "//vendor/k8s.io/apimachinery/pkg/util/sets/types:go_default_library",
     ],
     tools = [
-        "//cmd/libs/go2idl/set-gen",
+        "//vendor/k8s.io/kube-gen/cmd/set-gen",
     ],
 )
 

vendor/k8s.io/apimachinery/pkg/util/wait/wait.go

@@ -17,8 +17,10 @@ limitations under the License.
 package wait
 
 import (
+	"context"
 	"errors"
 	"math/rand"
+	"sync"
 	"time"
 
 	"k8s.io/apimachinery/pkg/util/runtime"
@@ -36,6 +38,40 @@ var ForeverTestTimeout = time.Second * 30
 // NeverStop may be passed to Until to make it never stop.
 var NeverStop <-chan struct{} = make(chan struct{})
 
+// Group allows to start a group of goroutines and wait for their completion.
+type Group struct {
+	wg sync.WaitGroup
+}
+
+func (g *Group) Wait() {
+	g.wg.Wait()
+}
+
+// StartWithChannel starts f in a new goroutine in the group.
+// stopCh is passed to f as an argument. f should stop when stopCh is available.
+func (g *Group) StartWithChannel(stopCh <-chan struct{}, f func(stopCh <-chan struct{})) {
+	g.Start(func() {
+		f(stopCh)
+	})
+}
+
+// StartWithContext starts f in a new goroutine in the group.
+// ctx is passed to f as an argument. f should stop when ctx.Done() is available.
+func (g *Group) StartWithContext(ctx context.Context, f func(context.Context)) {
+	g.Start(func() {
+		f(ctx)
+	})
+}
+
+// Start starts f in a new goroutine in the group.
+func (g *Group) Start(f func()) {
+	g.wg.Add(1)
+	go func() {
+		defer g.wg.Done()
+		f()
+	}()
+}
+
 // Forever calls f every period for ever.
 //
 // Forever is syntactic sugar on top of Until.

vendor/k8s.io/apimachinery/pkg/watch/BUILD

@@ -17,10 +17,12 @@ go_library(
         "streamwatcher.go",
         "until.go",
         "watch.go",
+        "zz_generated.deepcopy.go",
     ],
     tags = ["automanaged"],
     deps = [
         "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/net:go_default_library",
@@ -52,6 +54,7 @@ go_test(
     library = ":go_default_library",
     tags = ["automanaged"],
     deps = [
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
     ],

vendor/k8s.io/apimachinery/pkg/watch/mux.go

@@ -84,6 +84,13 @@ type functionFakeRuntimeObject func()
 func (obj functionFakeRuntimeObject) GetObjectKind() schema.ObjectKind {
 	return schema.EmptyObjectKind
 }
+func (obj functionFakeRuntimeObject) DeepCopyObject() runtime.Object {
+	if obj == nil {
+		return nil
+	}
+	// funcs are immutable. Hence, just return the original func.
+	return obj
+}
 
 // Execute f, blocking the incoming queue (and waiting for it to drain first).
 // The purpose of this terrible hack is so that watchers added after an event

vendor/k8s.io/apimachinery/pkg/watch/watch.go

@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"sync"
 
-	"k8s.io/apimachinery/pkg/runtime"
-
 	"github.com/golang/glog"
+
+	"k8s.io/apimachinery/pkg/runtime"
 )
 
 // Interface can be implemented by anything that knows how to watch and report changes.
@@ -50,6 +50,7 @@ const (
 )
 
 // Event represents a single event to a watched resource.
+// +k8s:deepcopy-gen=true
 type Event struct {
 	Type EventType
 

vendor/k8s.io/apimachinery/pkg/watch/zz_generated.deepcopy.go

@@ -0,0 +1,57 @@
+// +build !ignore_autogenerated
+
+/*
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package watch
+
+import (
+	conversion "k8s.io/apimachinery/pkg/conversion"
+	reflect "reflect"
+)
+
+// Deprecated: GetGeneratedDeepCopyFuncs returns the generated funcs, since we aren't registering them.
+func GetGeneratedDeepCopyFuncs() []conversion.GeneratedDeepCopyFunc {
+	return []conversion.GeneratedDeepCopyFunc{
+		{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*Event).DeepCopyInto(out.(*Event))
+			return nil
+		}, InType: reflect.TypeOf(&Event{})},
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Event) DeepCopyInto(out *Event) {
+	*out = *in
+	if in.Object == nil {
+		out.Object = nil
+	} else {
+		out.Object = in.Object.DeepCopyObject()
+	}
+	return
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, creating a new Event.
+func (x *Event) DeepCopy() *Event {
+	if x == nil {
+		return nil
+	}
+	out := new(Event)
+	x.DeepCopyInto(out)
+	return out
+}