Merge pull request #51940 from atlassian/unstructured-helpers

Automatic merge from submit-queue (batch tested with PRs 54787, 51940). If you want to cherry-pick this change to another branch, please follow the instructions <a href="https://github.com/kubernetes/community/blob/master/contributors/devel/cherry-picks.md">here</a>.

Useful helper functions for Unstructured

**Which issue this PR fixes**:
Fixes #40790

**Release note**:
```release-note
NONE
```
/kind feature
/sig api-machinery
/area client-libraries
/assign @sttts @liggitt

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/BUILD

@@ -8,21 +8,29 @@ load(
 
 go_test(
     name = "go_default_test",
-    srcs = ["unstructured_test.go"],
+    srcs = [
+        "helpers_test.go",
+        "unstructured_list_test.go",
+    ],
     importpath = "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
     library = ":go_default_library",
-    deps = ["//vendor/github.com/stretchr/testify/assert:go_default_library"],
+    deps = [
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/github.com/stretchr/testify/require:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+    ],
 )
 
 go_library(
     name = "go_default_library",
     srcs = [
+        "helpers.go",
         "unstructured.go",
+        "unstructured_list.go",
         "zz_generated.deepcopy.go",
     ],
     importpath = "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
     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",

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/helpers.go

@@ -0,0 +1,470 @@
+/*
+Copyright 2015 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 unstructured
+
+import (
+	gojson "encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/conversion/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/json"
+)
+
+// NestedFieldCopy returns a deep copy of the value of a nested field.
+// false is returned if the value is missing.
+// nil, true is returned for a nil field.
+func NestedFieldCopy(obj map[string]interface{}, fields ...string) (interface{}, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return nil, false
+	}
+	return unstructured.DeepCopyJSONValue(val), true
+}
+
+func nestedFieldNoCopy(obj map[string]interface{}, fields ...string) (interface{}, bool) {
+	var val interface{} = obj
+	for _, field := range fields {
+		if m, ok := val.(map[string]interface{}); ok {
+			val, ok = m[field]
+			if !ok {
+				return nil, false
+			}
+		} else {
+			// Expected map[string]interface{}, got something else
+			return nil, false
+		}
+	}
+	return val, true
+}
+
+// NestedString returns the string value of a nested field.
+// Returns false if value is not found or is not a string.
+func NestedString(obj map[string]interface{}, fields ...string) (string, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return "", false
+	}
+	s, ok := val.(string)
+	return s, ok
+}
+
+// NestedBool returns the bool value of a nested field.
+// Returns false if value is not found or is not a bool.
+func NestedBool(obj map[string]interface{}, fields ...string) (bool, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return false, false
+	}
+	b, ok := val.(bool)
+	return b, ok
+}
+
+// NestedFloat64 returns the bool value of a nested field.
+// Returns false if value is not found or is not a float64.
+func NestedFloat64(obj map[string]interface{}, fields ...string) (float64, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return 0, false
+	}
+	f, ok := val.(float64)
+	return f, ok
+}
+
+// NestedInt64 returns the int64 value of a nested field.
+// Returns false if value is not found or is not an int64.
+func NestedInt64(obj map[string]interface{}, fields ...string) (int64, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return 0, false
+	}
+	i, ok := val.(int64)
+	return i, ok
+}
+
+// NestedStringSlice returns a copy of []string value of a nested field.
+// Returns false if value is not found, is not a []interface{} or contains non-string items in the slice.
+func NestedStringSlice(obj map[string]interface{}, fields ...string) ([]string, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return nil, false
+	}
+	if m, ok := val.([]interface{}); ok {
+		strSlice := make([]string, 0, len(m))
+		for _, v := range m {
+			if str, ok := v.(string); ok {
+				strSlice = append(strSlice, str)
+			} else {
+				return nil, false
+			}
+		}
+		return strSlice, true
+	}
+	return nil, false
+}
+
+// NestedSlice returns a deep copy of []interface{} value of a nested field.
+// Returns false if value is not found or is not a []interface{}.
+func NestedSlice(obj map[string]interface{}, fields ...string) ([]interface{}, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return nil, false
+	}
+	if _, ok := val.([]interface{}); ok {
+		return unstructured.DeepCopyJSONValue(val).([]interface{}), true
+	}
+	return nil, false
+}
+
+// NestedStringMap returns a copy of map[string]string value of a nested field.
+// Returns false if value is not found, is not a map[string]interface{} or contains non-string values in the map.
+func NestedStringMap(obj map[string]interface{}, fields ...string) (map[string]string, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return nil, false
+	}
+	if m, ok := val.(map[string]interface{}); ok {
+		strMap := make(map[string]string, len(m))
+		for k, v := range m {
+			if str, ok := v.(string); ok {
+				strMap[k] = str
+			} else {
+				return nil, false
+			}
+		}
+		return strMap, true
+	}
+	return nil, false
+}
+
+// NestedMap returns a deep copy of map[string]interface{} value of a nested field.
+// Returns false if value is not found or is not a map[string]interface{}.
+func NestedMap(obj map[string]interface{}, fields ...string) (map[string]interface{}, bool) {
+	val, ok := nestedFieldNoCopy(obj, fields...)
+	if !ok {
+		return nil, false
+	}
+	if m, ok := val.(map[string]interface{}); ok {
+		return unstructured.DeepCopyJSON(m), true
+	}
+	return nil, false
+}
+
+// SetNestedField sets the value of a nested field to a deep copy of the value provided.
+// Returns false if value cannot be set because one of the nesting levels is not a map[string]interface{}.
+func SetNestedField(obj map[string]interface{}, value interface{}, fields ...string) bool {
+	return setNestedFieldNoCopy(obj, unstructured.DeepCopyJSONValue(value), fields...)
+}
+
+func setNestedFieldNoCopy(obj map[string]interface{}, value interface{}, fields ...string) bool {
+	m := obj
+	for _, field := range fields[:len(fields)-1] {
+		if val, ok := m[field]; ok {
+			if valMap, ok := val.(map[string]interface{}); ok {
+				m = valMap
+			} else {
+				return false
+			}
+		} else {
+			newVal := make(map[string]interface{})
+			m[field] = newVal
+			m = newVal
+		}
+	}
+	m[fields[len(fields)-1]] = value
+	return true
+}
+
+// SetNestedStringSlice sets the string slice value of a nested field.
+// Returns false if value cannot be set because one of the nesting levels is not a map[string]interface{}.
+func SetNestedStringSlice(obj map[string]interface{}, value []string, fields ...string) bool {
+	m := make([]interface{}, 0, len(value)) // convert []string into []interface{}
+	for _, v := range value {
+		m = append(m, v)
+	}
+	return setNestedFieldNoCopy(obj, m, fields...)
+}
+
+// SetNestedSlice sets the slice value of a nested field.
+// Returns false if value cannot be set because one of the nesting levels is not a map[string]interface{}.
+func SetNestedSlice(obj map[string]interface{}, value []interface{}, fields ...string) bool {
+	return SetNestedField(obj, value, fields...)
+}
+
+// SetNestedStringMap sets the map[string]string value of a nested field.
+// Returns false if value cannot be set because one of the nesting levels is not a map[string]interface{}.
+func SetNestedStringMap(obj map[string]interface{}, value map[string]string, fields ...string) bool {
+	m := make(map[string]interface{}, len(value)) // convert map[string]string into map[string]interface{}
+	for k, v := range value {
+		m[k] = v
+	}
+	return setNestedFieldNoCopy(obj, m, fields...)
+}
+
+// SetNestedMap sets the map[string]interface{} value of a nested field.
+// Returns false if value cannot be set because one of the nesting levels is not a map[string]interface{}.
+func SetNestedMap(obj map[string]interface{}, value map[string]interface{}, fields ...string) bool {
+	return SetNestedField(obj, value, fields...)
+}
+
+// RemoveNestedField removes the nested field from the obj.
+func RemoveNestedField(obj map[string]interface{}, fields ...string) {
+	m := obj
+	for _, field := range fields[:len(fields)-1] {
+		if x, ok := m[field].(map[string]interface{}); ok {
+			m = x
+		} else {
+			return
+		}
+	}
+	delete(m, fields[len(fields)-1])
+}
+
+func getNestedString(obj map[string]interface{}, fields ...string) string {
+	val, ok := NestedString(obj, fields...)
+	if !ok {
+		return ""
+	}
+	return val
+}
+
+func extractOwnerReference(v map[string]interface{}) metav1.OwnerReference {
+	// though this field is a *bool, but when decoded from JSON, it's
+	// unmarshalled as bool.
+	var controllerPtr *bool
+	if controller, ok := NestedBool(v, "controller"); ok {
+		controllerPtr = &controller
+	}
+	var blockOwnerDeletionPtr *bool
+	if blockOwnerDeletion, ok := NestedBool(v, "blockOwnerDeletion"); ok {
+		blockOwnerDeletionPtr = &blockOwnerDeletion
+	}
+	return metav1.OwnerReference{
+		Kind:               getNestedString(v, "kind"),
+		Name:               getNestedString(v, "name"),
+		APIVersion:         getNestedString(v, "apiVersion"),
+		UID:                types.UID(getNestedString(v, "uid")),
+		Controller:         controllerPtr,
+		BlockOwnerDeletion: blockOwnerDeletionPtr,
+	}
+}
+
+func setOwnerReference(src metav1.OwnerReference) map[string]interface{} {
+	ret := map[string]interface{}{
+		"kind":       src.Kind,
+		"name":       src.Name,
+		"apiVersion": src.APIVersion,
+		"uid":        string(src.UID),
+	}
+	// json.Unmarshal() extracts boolean json fields as bool, not as *bool and hence extractOwnerReference()
+	// expects bool or a missing field, not *bool. So if pointer is nil, fields are omitted from the ret object.
+	// If pointer is non-nil, they are set to the referenced value.
+	if src.Controller != nil {
+		ret["controller"] = *src.Controller
+	}
+	if src.BlockOwnerDeletion != nil {
+		ret["blockOwnerDeletion"] = *src.BlockOwnerDeletion
+	}
+	return ret
+}
+
+var converter = unstructured.NewConverter(false)
+
+// UnstructuredJSONScheme is capable of converting JSON data into the Unstructured
+// type, which can be used for generic access to objects without a predefined scheme.
+// TODO: move into serializer/json.
+var UnstructuredJSONScheme runtime.Codec = unstructuredJSONScheme{}
+
+type unstructuredJSONScheme struct{}
+
+func (s unstructuredJSONScheme) Decode(data []byte, _ *schema.GroupVersionKind, obj runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
+	var err error
+	if obj != nil {
+		err = s.decodeInto(data, obj)
+	} else {
+		obj, err = s.decode(data)
+	}
+
+	if err != nil {
+		return nil, nil, err
+	}
+
+	gvk := obj.GetObjectKind().GroupVersionKind()
+	if len(gvk.Kind) == 0 {
+		return nil, &gvk, runtime.NewMissingKindErr(string(data))
+	}
+
+	return obj, &gvk, nil
+}
+
+func (unstructuredJSONScheme) Encode(obj runtime.Object, w io.Writer) error {
+	switch t := obj.(type) {
+	case *Unstructured:
+		return json.NewEncoder(w).Encode(t.Object)
+	case *UnstructuredList:
+		items := make([]interface{}, 0, len(t.Items))
+		for _, i := range t.Items {
+			items = append(items, i.Object)
+		}
+		listObj := make(map[string]interface{}, len(t.Object)+1)
+		for k, v := range t.Object { // Make a shallow copy
+			listObj[k] = v
+		}
+		listObj["items"] = items
+		return json.NewEncoder(w).Encode(listObj)
+	case *runtime.Unknown:
+		// TODO: Unstructured needs to deal with ContentType.
+		_, err := w.Write(t.Raw)
+		return err
+	default:
+		return json.NewEncoder(w).Encode(t)
+	}
+}
+
+func (s unstructuredJSONScheme) decode(data []byte) (runtime.Object, error) {
+	type detector struct {
+		Items gojson.RawMessage
+	}
+	var det detector
+	if err := json.Unmarshal(data, &det); err != nil {
+		return nil, err
+	}
+
+	if det.Items != nil {
+		list := &UnstructuredList{}
+		err := s.decodeToList(data, list)
+		return list, err
+	}
+
+	// No Items field, so it wasn't a list.
+	unstruct := &Unstructured{}
+	err := s.decodeToUnstructured(data, unstruct)
+	return unstruct, err
+}
+
+func (s unstructuredJSONScheme) decodeInto(data []byte, obj runtime.Object) error {
+	switch x := obj.(type) {
+	case *Unstructured:
+		return s.decodeToUnstructured(data, x)
+	case *UnstructuredList:
+		return s.decodeToList(data, x)
+	case *runtime.VersionedObjects:
+		o, err := s.decode(data)
+		if err == nil {
+			x.Objects = []runtime.Object{o}
+		}
+		return err
+	default:
+		return json.Unmarshal(data, x)
+	}
+}
+
+func (unstructuredJSONScheme) decodeToUnstructured(data []byte, unstruct *Unstructured) error {
+	m := make(map[string]interface{})
+	if err := json.Unmarshal(data, &m); err != nil {
+		return err
+	}
+
+	unstruct.Object = m
+
+	return nil
+}
+
+func (s unstructuredJSONScheme) decodeToList(data []byte, list *UnstructuredList) error {
+	type decodeList struct {
+		Items []gojson.RawMessage
+	}
+
+	var dList decodeList
+	if err := json.Unmarshal(data, &dList); err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(data, &list.Object); err != nil {
+		return err
+	}
+
+	// For typed lists, e.g., a PodList, API server doesn't set each item's
+	// APIVersion and Kind. We need to set it.
+	listAPIVersion := list.GetAPIVersion()
+	listKind := list.GetKind()
+	itemKind := strings.TrimSuffix(listKind, "List")
+
+	delete(list.Object, "items")
+	list.Items = make([]Unstructured, 0, len(dList.Items))
+	for _, i := range dList.Items {
+		unstruct := &Unstructured{}
+		if err := s.decodeToUnstructured([]byte(i), unstruct); err != nil {
+			return err
+		}
+		// This is hacky. Set the item's Kind and APIVersion to those inferred
+		// from the List.
+		if len(unstruct.GetKind()) == 0 && len(unstruct.GetAPIVersion()) == 0 {
+			unstruct.SetKind(itemKind)
+			unstruct.SetAPIVersion(listAPIVersion)
+		}
+		list.Items = append(list.Items, *unstruct)
+	}
+	return nil
+}
+
+// UnstructuredObjectConverter is an ObjectConverter for use with
+// Unstructured objects. Since it has no schema or type information,
+// it will only succeed for no-op conversions. This is provided as a
+// sane implementation for APIs that require an object converter.
+type UnstructuredObjectConverter struct{}
+
+func (UnstructuredObjectConverter) Convert(in, out, context interface{}) error {
+	unstructIn, ok := in.(*Unstructured)
+	if !ok {
+		return fmt.Errorf("input type %T in not valid for unstructured conversion", in)
+	}
+
+	unstructOut, ok := out.(*Unstructured)
+	if !ok {
+		return fmt.Errorf("output type %T in not valid for unstructured conversion", out)
+	}
+
+	// maybe deep copy the map? It is documented in the
+	// ObjectConverter interface that this function is not
+	// guaranteeed to not mutate the input. Or maybe set the input
+	// object to nil.
+	unstructOut.Object = unstructIn.Object
+	return nil
+}
+
+func (UnstructuredObjectConverter) ConvertToVersion(in runtime.Object, target runtime.GroupVersioner) (runtime.Object, error) {
+	if kind := in.GetObjectKind().GroupVersionKind(); !kind.Empty() {
+		gvk, ok := target.KindForGroupVersionKinds([]schema.GroupVersionKind{kind})
+		if !ok {
+			// TODO: should this be a typed error?
+			return nil, fmt.Errorf("%v is unstructured and is not suitable for converting to %q", kind, target)
+		}
+		in.GetObjectKind().SetGroupVersionKind(gvk)
+	}
+	return in, nil
+}
+
+func (UnstructuredObjectConverter) ConvertFieldLabel(version, kind, label, value string) (string, string, error) {
+	return "", "", errors.New("unstructured cannot convert field labels")
+}

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/helpers_test.go

@@ -0,0 +1,60 @@
+/*
+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 unstructured
+
+import (
+	"io/ioutil"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestCodecOfUnstructuredList tests that there are no data races in Encode().
+// i.e. that it does not mutate the object being encoded.
+func TestCodecOfUnstructuredList(t *testing.T) {
+	var wg sync.WaitGroup
+	concurrency := 10
+	list := UnstructuredList{
+		Object: map[string]interface{}{},
+	}
+	wg.Add(concurrency)
+	for i := 0; i < concurrency; i++ {
+		go func() {
+			defer wg.Done()
+			assert.NoError(t, UnstructuredJSONScheme.Encode(&list, ioutil.Discard))
+		}()
+	}
+	wg.Wait()
+}
+
+func TestRemoveNestedField(t *testing.T) {
+	obj := map[string]interface{}{
+		"x": map[string]interface{}{
+			"y": 1,
+			"a": "foo",
+		},
+	}
+	RemoveNestedField(obj, "x", "a")
+	assert.Len(t, obj["x"], 1)
+	RemoveNestedField(obj, "x", "y")
+	assert.Empty(t, obj["x"])
+	RemoveNestedField(obj, "x")
+	assert.Empty(t, obj)
+	RemoveNestedField(obj, "x") // Remove of a non-existent field
+	assert.Empty(t, obj)
+}

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured.go

@@ -18,20 +18,13 @@ package unstructured
 
 import (
 	"bytes"
-	gojson "encoding/json"
-	"errors"
 	"fmt"
-	"io"
-	"strings"
-
-	"github.com/golang/glog"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/conversion/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/util/json"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 )
 
@@ -54,13 +47,10 @@ type Unstructured struct {
 
 var _ metav1.Object = &Unstructured{}
 var _ runtime.Unstructured = &Unstructured{}
-var _ runtime.Unstructured = &UnstructuredList{}
 
-func (obj *Unstructured) GetObjectKind() schema.ObjectKind     { return obj }
+func (obj *Unstructured) GetObjectKind() schema.ObjectKind { return obj }
-func (obj *UnstructuredList) GetObjectKind() schema.ObjectKind { return obj }
 
-func (obj *Unstructured) IsUnstructuredObject()     {}
+func (obj *Unstructured) IsUnstructuredObject() {}
-func (obj *UnstructuredList) IsUnstructuredObject() {}
 
 func (obj *Unstructured) IsList() bool {
 	if obj.Object != nil {
@@ -69,7 +59,6 @@ func (obj *Unstructured) IsList() bool {
 	}
 	return false
 }
-func (obj *UnstructuredList) IsList() bool { return true }
 
 func (obj *Unstructured) EachListItem(fn func(runtime.Object) error) error {
 	if obj.Object == nil {
@@ -95,15 +84,6 @@ func (obj *Unstructured) EachListItem(fn func(runtime.Object) error) error {
 	return nil
 }
 
-func (obj *UnstructuredList) EachListItem(fn func(runtime.Object) error) error {
-	for i := range obj.Items {
-		if err := fn(&obj.Items[i]); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 func (obj *Unstructured) UnstructuredContent() map[string]interface{} {
 	if obj.Object == nil {
 		obj.Object = make(map[string]interface{})
@@ -111,25 +91,6 @@ func (obj *Unstructured) UnstructuredContent() map[string]interface{} {
 	return obj.Object
 }
 
-// UnstructuredContent returns a map contain an overlay of the Items field onto
-// the Object field. Items always overwrites overlay. Changing "items" in the
-// returned object will affect items in the underlying Items field, but changing
-// the "items" slice itself will have no effect.
-// TODO: expose SetUnstructuredContent on runtime.Unstructured that allows
-// items to be changed.
-func (obj *UnstructuredList) UnstructuredContent() map[string]interface{} {
-	out := obj.Object
-	if out == nil {
-		out = make(map[string]interface{})
-	}
-	items := make([]interface{}, len(obj.Items))
-	for i, item := range obj.Items {
-		items[i] = item.Object
-	}
-	out["items"] = items
-	return out
-}
-
 // MarshalJSON ensures that the unstructured object produces proper
 // JSON when passed to Go's standard JSON library.
 func (u *Unstructured) MarshalJSON() ([]byte, error) {
@@ -155,223 +116,52 @@ func (in *Unstructured) DeepCopy() *Unstructured {
 	return out
 }
 
-func (in *UnstructuredList) DeepCopy() *UnstructuredList {
-	if in == nil {
-		return nil
-	}
-	out := new(UnstructuredList)
-	*out = *in
-	out.Object = unstructured.DeepCopyJSON(in.Object)
-	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 {
-		if _, ok := val.(map[string]interface{}); !ok {
-			return nil
-		}
-		val = val.(map[string]interface{})[field]
-	}
-	return val
-}
-
-func getNestedString(obj map[string]interface{}, fields ...string) string {
-	if str, ok := getNestedField(obj, fields...).(string); ok {
-		return str
-	}
-	return ""
-}
-
-func getNestedInt64(obj map[string]interface{}, fields ...string) int64 {
-	if str, ok := getNestedField(obj, fields...).(int64); ok {
-		return str
-	}
-	return 0
-}
-
-func getNestedInt64Pointer(obj map[string]interface{}, fields ...string) *int64 {
-	nested := getNestedField(obj, fields...)
-	switch n := nested.(type) {
-	case int64:
-		return &n
-	case *int64:
-		return n
-	default:
-		return nil
-	}
-}
-
-func getNestedSlice(obj map[string]interface{}, fields ...string) []string {
-	if m, ok := getNestedField(obj, fields...).([]interface{}); ok {
-		strSlice := make([]string, 0, len(m))
-		for _, v := range m {
-			if str, ok := v.(string); ok {
-				strSlice = append(strSlice, str)
-			}
-		}
-		return strSlice
-	}
-	return nil
-}
-
-func getNestedMap(obj map[string]interface{}, fields ...string) map[string]string {
-	if m, ok := getNestedField(obj, fields...).(map[string]interface{}); ok {
-		strMap := make(map[string]string, len(m))
-		for k, v := range m {
-			if str, ok := v.(string); ok {
-				strMap[k] = str
-			}
-		}
-		return strMap
-	}
-	return nil
-}
-
-func setNestedField(obj map[string]interface{}, value interface{}, fields ...string) {
-	m := obj
-	if len(fields) > 1 {
-		for _, field := range fields[0 : len(fields)-1] {
-			if _, ok := m[field].(map[string]interface{}); !ok {
-				m[field] = make(map[string]interface{})
-			}
-			m = m[field].(map[string]interface{})
-		}
-	}
-	m[fields[len(fields)-1]] = value
-}
-
-func setNestedSlice(obj map[string]interface{}, value []string, fields ...string) {
-	m := make([]interface{}, 0, len(value))
-	for _, v := range value {
-		m = append(m, v)
-	}
-	setNestedField(obj, m, fields...)
-}
-
-func setNestedMap(obj map[string]interface{}, value map[string]string, fields ...string) {
-	m := make(map[string]interface{}, len(value))
-	for k, v := range value {
-		m[k] = v
-	}
-	setNestedField(obj, m, fields...)
-}
-
 func (u *Unstructured) setNestedField(value interface{}, fields ...string) {
 	if u.Object == nil {
 		u.Object = make(map[string]interface{})
 	}
-	setNestedField(u.Object, value, fields...)
+	SetNestedField(u.Object, value, fields...)
 }
 
 func (u *Unstructured) setNestedSlice(value []string, fields ...string) {
 	if u.Object == nil {
 		u.Object = make(map[string]interface{})
 	}
-	setNestedSlice(u.Object, value, fields...)
+	SetNestedStringSlice(u.Object, value, fields...)
 }
 
 func (u *Unstructured) setNestedMap(value map[string]string, fields ...string) {
 	if u.Object == nil {
 		u.Object = make(map[string]interface{})
 	}
-	setNestedMap(u.Object, value, fields...)
+	SetNestedStringMap(u.Object, value, fields...)
-}
-
-func extractOwnerReference(src interface{}) metav1.OwnerReference {
-	v := src.(map[string]interface{})
-	// though this field is a *bool, but when decoded from JSON, it's
-	// unmarshalled as bool.
-	var controllerPtr *bool
-	controller, ok := (getNestedField(v, "controller")).(bool)
-	if !ok {
-		controllerPtr = nil
-	} else {
-		controllerCopy := controller
-		controllerPtr = &controllerCopy
-	}
-	var blockOwnerDeletionPtr *bool
-	blockOwnerDeletion, ok := (getNestedField(v, "blockOwnerDeletion")).(bool)
-	if !ok {
-		blockOwnerDeletionPtr = nil
-	} else {
-		blockOwnerDeletionCopy := blockOwnerDeletion
-		blockOwnerDeletionPtr = &blockOwnerDeletionCopy
-	}
-	return metav1.OwnerReference{
-		Kind:               getNestedString(v, "kind"),
-		Name:               getNestedString(v, "name"),
-		APIVersion:         getNestedString(v, "apiVersion"),
-		UID:                (types.UID)(getNestedString(v, "uid")),
-		Controller:         controllerPtr,
-		BlockOwnerDeletion: blockOwnerDeletionPtr,
-	}
-}
-
-func setOwnerReference(src metav1.OwnerReference) map[string]interface{} {
-	ret := make(map[string]interface{})
-	setNestedField(ret, src.Kind, "kind")
-	setNestedField(ret, src.Name, "name")
-	setNestedField(ret, src.APIVersion, "apiVersion")
-	setNestedField(ret, string(src.UID), "uid")
-	// json.Unmarshal() extracts boolean json fields as bool, not as *bool and hence extractOwnerReference()
-	// expects bool or a missing field, not *bool. So if pointer is nil, fields are omitted from the ret object.
-	// If pointer is non-nil, they are set to the referenced value.
-	if src.Controller != nil {
-		setNestedField(ret, *src.Controller, "controller")
-	}
-	if src.BlockOwnerDeletion != nil {
-		setNestedField(ret, *src.BlockOwnerDeletion, "blockOwnerDeletion")
-	}
-	return ret
-}
-
-func getOwnerReferences(object map[string]interface{}) ([]map[string]interface{}, error) {
-	field := getNestedField(object, "metadata", "ownerReferences")
-	if field == nil {
-		return nil, fmt.Errorf("cannot find field metadata.ownerReferences in %v", object)
-	}
-	ownerReferences, ok := field.([]map[string]interface{})
-	if ok {
-		return ownerReferences, nil
-	}
-	// TODO: This is hacky...
-	interfaces, ok := field.([]interface{})
-	if !ok {
-		return nil, fmt.Errorf("expect metadata.ownerReferences to be a slice in %#v", object)
-	}
-	ownerReferences = make([]map[string]interface{}, 0, len(interfaces))
-	for i := 0; i < len(interfaces); i++ {
-		r, ok := interfaces[i].(map[string]interface{})
-		if !ok {
-			return nil, fmt.Errorf("expect element metadata.ownerReferences to be a map[string]interface{} in %#v", object)
-		}
-		ownerReferences = append(ownerReferences, r)
-	}
-	return ownerReferences, nil
 }
 
 func (u *Unstructured) GetOwnerReferences() []metav1.OwnerReference {
-	original, err := getOwnerReferences(u.Object)
+	field, ok := nestedFieldNoCopy(u.Object, "metadata", "ownerReferences")
-	if err != nil {
+	if !ok {
-		glog.V(6).Info(err)
+		return nil
+	}
+	original, ok := field.([]interface{})
+	if !ok {
 		return nil
 	}
 	ret := make([]metav1.OwnerReference, 0, len(original))
-	for i := 0; i < len(original); i++ {
+	for _, obj := range original {
-		ret = append(ret, extractOwnerReference(original[i]))
+		o, ok := obj.(map[string]interface{})
+		if !ok {
+			// expected map[string]interface{}, got something else
+			return nil
+		}
+		ret = append(ret, extractOwnerReference(o))
 	}
 	return ret
 }
 
 func (u *Unstructured) SetOwnerReferences(references []metav1.OwnerReference) {
-	var newReferences = make([]map[string]interface{}, 0, len(references))
+	newReferences := make([]interface{}, 0, len(references))
-	for i := 0; i < len(references); i++ {
+	for _, reference := range references {
-		newReferences = append(newReferences, setOwnerReference(references[i]))
+		newReferences = append(newReferences, setOwnerReference(reference))
 	}
 	u.setNestedField(newReferences, "metadata", "ownerReferences")
 }
@@ -433,7 +223,11 @@ func (u *Unstructured) SetResourceVersion(version string) {
 }
 
 func (u *Unstructured) GetGeneration() int64 {
-	return getNestedInt64(u.Object, "metadata", "generation")
+	val, ok := NestedInt64(u.Object, "metadata", "generation")
+	if !ok {
+		return 0
+	}
+	return val
 }
 
 func (u *Unstructured) SetGeneration(generation int64) {
@@ -478,7 +272,7 @@ func (u *Unstructured) GetDeletionTimestamp() *metav1.Time {
 
 func (u *Unstructured) SetDeletionTimestamp(timestamp *metav1.Time) {
 	if timestamp == nil {
-		u.setNestedField(nil, "metadata", "deletionTimestamp")
+		RemoveNestedField(u.Object, "metadata", "deletionTimestamp")
 		return
 	}
 	ts, _ := timestamp.MarshalQueryParameter()
@@ -486,15 +280,27 @@ func (u *Unstructured) SetDeletionTimestamp(timestamp *metav1.Time) {
 }
 
 func (u *Unstructured) GetDeletionGracePeriodSeconds() *int64 {
-	return getNestedInt64Pointer(u.Object, "metadata", "deletionGracePeriodSeconds")
+	val, ok := NestedInt64(u.Object, "metadata", "deletionGracePeriodSeconds")
+	if !ok {
+		return nil
+	}
+	return &val
 }
 
 func (u *Unstructured) SetDeletionGracePeriodSeconds(deletionGracePeriodSeconds *int64) {
-	u.setNestedField(deletionGracePeriodSeconds, "metadata", "deletionGracePeriodSeconds")
+	if deletionGracePeriodSeconds == nil {
+		RemoveNestedField(u.Object, "metadata", "deletionGracePeriodSeconds")
+		return
+	}
+	u.setNestedField(*deletionGracePeriodSeconds, "metadata", "deletionGracePeriodSeconds")
 }
 
 func (u *Unstructured) GetLabels() map[string]string {
-	return getNestedMap(u.Object, "metadata", "labels")
+	m, ok := NestedStringMap(u.Object, "metadata", "labels")
+	if !ok {
+		return nil
+	}
+	return m
 }
 
 func (u *Unstructured) SetLabels(labels map[string]string) {
@@ -502,7 +308,11 @@ func (u *Unstructured) SetLabels(labels map[string]string) {
 }
 
 func (u *Unstructured) GetAnnotations() map[string]string {
-	return getNestedMap(u.Object, "metadata", "annotations")
+	m, ok := NestedStringMap(u.Object, "metadata", "annotations")
+	if !ok {
+		return nil
+	}
+	return m
 }
 
 func (u *Unstructured) SetAnnotations(annotations map[string]string) {
@@ -523,15 +333,14 @@ func (u *Unstructured) GroupVersionKind() schema.GroupVersionKind {
 	return gvk
 }
 
-var converter = unstructured.NewConverter(false)
-
 func (u *Unstructured) GetInitializers() *metav1.Initializers {
-	field := getNestedField(u.Object, "metadata", "initializers")
+	field, ok := nestedFieldNoCopy(u.Object, "metadata", "initializers")
-	if field == nil {
+	if !ok {
 		return nil
 	}
 	obj, ok := field.(map[string]interface{})
 	if !ok {
+		// expected map[string]interface{}, got something else
 		return nil
 	}
 	out := &metav1.Initializers{}
@@ -542,22 +351,23 @@ func (u *Unstructured) GetInitializers() *metav1.Initializers {
 }
 
 func (u *Unstructured) SetInitializers(initializers *metav1.Initializers) {
-	if u.Object == nil {
-		u.Object = make(map[string]interface{})
-	}
 	if initializers == nil {
-		setNestedField(u.Object, nil, "metadata", "initializers")
+		RemoveNestedField(u.Object, "metadata", "initializers")
 		return
 	}
 	out, err := converter.ToUnstructured(initializers)
 	if err != nil {
 		utilruntime.HandleError(fmt.Errorf("unable to retrieve initializers for object: %v", err))
 	}
-	setNestedField(u.Object, out, "metadata", "initializers")
+	u.setNestedField(out, "metadata", "initializers")
 }
 
 func (u *Unstructured) GetFinalizers() []string {
-	return getNestedSlice(u.Object, "metadata", "finalizers")
+	val, ok := NestedStringSlice(u.Object, "metadata", "finalizers")
+	if !ok {
+		return nil
+	}
+	return val
 }
 
 func (u *Unstructured) SetFinalizers(finalizers []string) {
@@ -571,272 +381,3 @@ func (u *Unstructured) GetClusterName() string {
 func (u *Unstructured) SetClusterName(clusterName string) {
 	u.setNestedField(clusterName, "metadata", "clusterName")
 }
-
-// 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{}
-
-	// Items is a list of unstructured objects.
-	Items []Unstructured `json:"items"`
-}
-
-var _ metav1.ListInterface = &UnstructuredList{}
-
-// MarshalJSON ensures that the unstructured list object produces proper
-// JSON when passed to Go's standard JSON library.
-func (u *UnstructuredList) MarshalJSON() ([]byte, error) {
-	var buf bytes.Buffer
-	err := UnstructuredJSONScheme.Encode(u, &buf)
-	return buf.Bytes(), err
-}
-
-// UnmarshalJSON ensures that the unstructured list object properly
-// decodes JSON when passed to Go's standard JSON library.
-func (u *UnstructuredList) UnmarshalJSON(b []byte) error {
-	_, _, err := UnstructuredJSONScheme.Decode(b, nil, u)
-	return err
-}
-
-func (u *UnstructuredList) setNestedField(value interface{}, fields ...string) {
-	if u.Object == nil {
-		u.Object = make(map[string]interface{})
-	}
-	setNestedField(u.Object, value, fields...)
-}
-
-func (u *UnstructuredList) GetAPIVersion() string {
-	return getNestedString(u.Object, "apiVersion")
-}
-
-func (u *UnstructuredList) SetAPIVersion(version string) {
-	u.setNestedField(version, "apiVersion")
-}
-
-func (u *UnstructuredList) GetKind() string {
-	return getNestedString(u.Object, "kind")
-}
-
-func (u *UnstructuredList) SetKind(kind string) {
-	u.setNestedField(kind, "kind")
-}
-
-func (u *UnstructuredList) GetResourceVersion() string {
-	return getNestedString(u.Object, "metadata", "resourceVersion")
-}
-
-func (u *UnstructuredList) SetResourceVersion(version string) {
-	u.setNestedField(version, "metadata", "resourceVersion")
-}
-
-func (u *UnstructuredList) GetSelfLink() string {
-	return getNestedString(u.Object, "metadata", "selfLink")
-}
-
-func (u *UnstructuredList) SetSelfLink(selfLink string) {
-	u.setNestedField(selfLink, "metadata", "selfLink")
-}
-
-func (u *UnstructuredList) GetContinue() string {
-	return getNestedString(u.Object, "metadata", "continue")
-}
-
-func (u *UnstructuredList) SetContinue(c string) {
-	u.setNestedField(c, "metadata", "continue")
-}
-
-func (u *UnstructuredList) SetGroupVersionKind(gvk schema.GroupVersionKind) {
-	u.SetAPIVersion(gvk.GroupVersion().String())
-	u.SetKind(gvk.Kind)
-}
-
-func (u *UnstructuredList) GroupVersionKind() schema.GroupVersionKind {
-	gv, err := schema.ParseGroupVersion(u.GetAPIVersion())
-	if err != nil {
-		return schema.GroupVersionKind{}
-	}
-	gvk := gv.WithKind(u.GetKind())
-	return gvk
-}
-
-// UnstructuredJSONScheme is capable of converting JSON data into the Unstructured
-// type, which can be used for generic access to objects without a predefined scheme.
-// TODO: move into serializer/json.
-var UnstructuredJSONScheme runtime.Codec = unstructuredJSONScheme{}
-
-type unstructuredJSONScheme struct{}
-
-func (s unstructuredJSONScheme) Decode(data []byte, _ *schema.GroupVersionKind, obj runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
-	var err error
-	if obj != nil {
-		err = s.decodeInto(data, obj)
-	} else {
-		obj, err = s.decode(data)
-	}
-
-	if err != nil {
-		return nil, nil, err
-	}
-
-	gvk := obj.GetObjectKind().GroupVersionKind()
-	if len(gvk.Kind) == 0 {
-		return nil, &gvk, runtime.NewMissingKindErr(string(data))
-	}
-
-	return obj, &gvk, nil
-}
-
-func (unstructuredJSONScheme) Encode(obj runtime.Object, w io.Writer) error {
-	switch t := obj.(type) {
-	case *Unstructured:
-		return json.NewEncoder(w).Encode(t.Object)
-	case *UnstructuredList:
-		items := make([]map[string]interface{}, 0, len(t.Items))
-		for _, i := range t.Items {
-			items = append(items, i.Object)
-		}
-		listObj := make(map[string]interface{}, len(t.Object)+1)
-		for k, v := range t.Object { // Make a shallow copy
-			listObj[k] = v
-		}
-		listObj["items"] = items
-		return json.NewEncoder(w).Encode(listObj)
-	case *runtime.Unknown:
-		// TODO: Unstructured needs to deal with ContentType.
-		_, err := w.Write(t.Raw)
-		return err
-	default:
-		return json.NewEncoder(w).Encode(t)
-	}
-}
-
-func (s unstructuredJSONScheme) decode(data []byte) (runtime.Object, error) {
-	type detector struct {
-		Items gojson.RawMessage
-	}
-	var det detector
-	if err := json.Unmarshal(data, &det); err != nil {
-		return nil, err
-	}
-
-	if det.Items != nil {
-		list := &UnstructuredList{}
-		err := s.decodeToList(data, list)
-		return list, err
-	}
-
-	// No Items field, so it wasn't a list.
-	unstruct := &Unstructured{}
-	err := s.decodeToUnstructured(data, unstruct)
-	return unstruct, err
-}
-
-func (s unstructuredJSONScheme) decodeInto(data []byte, obj runtime.Object) error {
-	switch x := obj.(type) {
-	case *Unstructured:
-		return s.decodeToUnstructured(data, x)
-	case *UnstructuredList:
-		return s.decodeToList(data, x)
-	case *runtime.VersionedObjects:
-		o, err := s.decode(data)
-		if err == nil {
-			x.Objects = []runtime.Object{o}
-		}
-		return err
-	default:
-		return json.Unmarshal(data, x)
-	}
-}
-
-func (unstructuredJSONScheme) decodeToUnstructured(data []byte, unstruct *Unstructured) error {
-	m := make(map[string]interface{})
-	if err := json.Unmarshal(data, &m); err != nil {
-		return err
-	}
-
-	unstruct.Object = m
-
-	return nil
-}
-
-func (s unstructuredJSONScheme) decodeToList(data []byte, list *UnstructuredList) error {
-	type decodeList struct {
-		Items []gojson.RawMessage
-	}
-
-	var dList decodeList
-	if err := json.Unmarshal(data, &dList); err != nil {
-		return err
-	}
-
-	if err := json.Unmarshal(data, &list.Object); err != nil {
-		return err
-	}
-
-	// For typed lists, e.g., a PodList, API server doesn't set each item's
-	// APIVersion and Kind. We need to set it.
-	listAPIVersion := list.GetAPIVersion()
-	listKind := list.GetKind()
-	itemKind := strings.TrimSuffix(listKind, "List")
-
-	delete(list.Object, "items")
-	list.Items = nil
-	for _, i := range dList.Items {
-		unstruct := &Unstructured{}
-		if err := s.decodeToUnstructured([]byte(i), unstruct); err != nil {
-			return err
-		}
-		// This is hacky. Set the item's Kind and APIVersion to those inferred
-		// from the List.
-		if len(unstruct.GetKind()) == 0 && len(unstruct.GetAPIVersion()) == 0 {
-			unstruct.SetKind(itemKind)
-			unstruct.SetAPIVersion(listAPIVersion)
-		}
-		list.Items = append(list.Items, *unstruct)
-	}
-	return nil
-}
-
-// UnstructuredObjectConverter is an ObjectConverter for use with
-// Unstructured objects. Since it has no schema or type information,
-// it will only succeed for no-op conversions. This is provided as a
-// sane implementation for APIs that require an object converter.
-type UnstructuredObjectConverter struct{}
-
-func (UnstructuredObjectConverter) Convert(in, out, context interface{}) error {
-	unstructIn, ok := in.(*Unstructured)
-	if !ok {
-		return fmt.Errorf("input type %T in not valid for unstructured conversion", in)
-	}
-
-	unstructOut, ok := out.(*Unstructured)
-	if !ok {
-		return fmt.Errorf("output type %T in not valid for unstructured conversion", out)
-	}
-
-	// maybe deep copy the map? It is documented in the
-	// ObjectConverter interface that this function is not
-	// guaranteeed to not mutate the input. Or maybe set the input
-	// object to nil.
-	unstructOut.Object = unstructIn.Object
-	return nil
-}
-
-func (UnstructuredObjectConverter) ConvertToVersion(in runtime.Object, target runtime.GroupVersioner) (runtime.Object, error) {
-	if kind := in.GetObjectKind().GroupVersionKind(); !kind.Empty() {
-		gvk, ok := target.KindForGroupVersionKinds([]schema.GroupVersionKind{kind})
-		if !ok {
-			// TODO: should this be a typed error?
-			return nil, fmt.Errorf("%v is unstructured and is not suitable for converting to %q", kind, target)
-		}
-		in.GetObjectKind().SetGroupVersionKind(gvk)
-	}
-	return in, nil
-}
-
-func (UnstructuredObjectConverter) ConvertFieldLabel(version, kind, label, value string) (string, string, error) {
-	return "", "", errors.New("unstructured cannot convert field labels")
-}

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured_list.go

@@ -0,0 +1,165 @@
+/*
+Copyright 2015 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 unstructured
+
+import (
+	"bytes"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/conversion/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+var _ runtime.Unstructured = &UnstructuredList{}
+var _ metav1.ListInterface = &UnstructuredList{}
+
+// 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{}
+
+	// Items is a list of unstructured objects.
+	Items []Unstructured `json:"items"`
+}
+
+func (u *UnstructuredList) GetObjectKind() schema.ObjectKind { return u }
+
+func (u *UnstructuredList) IsUnstructuredObject() {}
+
+func (u *UnstructuredList) IsList() bool { return true }
+
+func (u *UnstructuredList) EachListItem(fn func(runtime.Object) error) error {
+	for i := range u.Items {
+		if err := fn(&u.Items[i]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// UnstructuredContent returns a map contain an overlay of the Items field onto
+// the Object field. Items always overwrites overlay. Changing "items" in the
+// returned object will affect items in the underlying Items field, but changing
+// the "items" slice itself will have no effect.
+// TODO: expose SetUnstructuredContent on runtime.Unstructured that allows
+// items to be changed.
+func (u *UnstructuredList) UnstructuredContent() map[string]interface{} {
+	out := u.Object
+	if out == nil {
+		out = make(map[string]interface{})
+	}
+	items := make([]interface{}, len(u.Items))
+	for i, item := range u.Items {
+		items[i] = item.Object
+	}
+	out["items"] = items
+	return out
+}
+
+func (u *UnstructuredList) DeepCopy() *UnstructuredList {
+	if u == nil {
+		return nil
+	}
+	out := new(UnstructuredList)
+	*out = *u
+	out.Object = unstructured.DeepCopyJSON(u.Object)
+	out.Items = make([]Unstructured, len(u.Items))
+	for i := range u.Items {
+		u.Items[i].DeepCopyInto(&out.Items[i])
+	}
+	return out
+}
+
+// MarshalJSON ensures that the unstructured list object produces proper
+// JSON when passed to Go's standard JSON library.
+func (u *UnstructuredList) MarshalJSON() ([]byte, error) {
+	var buf bytes.Buffer
+	err := UnstructuredJSONScheme.Encode(u, &buf)
+	return buf.Bytes(), err
+}
+
+// UnmarshalJSON ensures that the unstructured list object properly
+// decodes JSON when passed to Go's standard JSON library.
+func (u *UnstructuredList) UnmarshalJSON(b []byte) error {
+	_, _, err := UnstructuredJSONScheme.Decode(b, nil, u)
+	return err
+}
+
+func (u *UnstructuredList) GetAPIVersion() string {
+	return getNestedString(u.Object, "apiVersion")
+}
+
+func (u *UnstructuredList) SetAPIVersion(version string) {
+	u.setNestedField(version, "apiVersion")
+}
+
+func (u *UnstructuredList) GetKind() string {
+	return getNestedString(u.Object, "kind")
+}
+
+func (u *UnstructuredList) SetKind(kind string) {
+	u.setNestedField(kind, "kind")
+}
+
+func (u *UnstructuredList) GetResourceVersion() string {
+	return getNestedString(u.Object, "metadata", "resourceVersion")
+}
+
+func (u *UnstructuredList) SetResourceVersion(version string) {
+	u.setNestedField(version, "metadata", "resourceVersion")
+}
+
+func (u *UnstructuredList) GetSelfLink() string {
+	return getNestedString(u.Object, "metadata", "selfLink")
+}
+
+func (u *UnstructuredList) SetSelfLink(selfLink string) {
+	u.setNestedField(selfLink, "metadata", "selfLink")
+}
+
+func (u *UnstructuredList) GetContinue() string {
+	return getNestedString(u.Object, "metadata", "continue")
+}
+
+func (u *UnstructuredList) SetContinue(c string) {
+	u.setNestedField(c, "metadata", "continue")
+}
+
+func (u *UnstructuredList) SetGroupVersionKind(gvk schema.GroupVersionKind) {
+	u.SetAPIVersion(gvk.GroupVersion().String())
+	u.SetKind(gvk.Kind)
+}
+
+func (u *UnstructuredList) GroupVersionKind() schema.GroupVersionKind {
+	gv, err := schema.ParseGroupVersion(u.GetAPIVersion())
+	if err != nil {
+		return schema.GroupVersionKind{}
+	}
+	gvk := gv.WithKind(u.GetKind())
+	return gvk
+}
+
+func (u *UnstructuredList) setNestedField(value interface{}, fields ...string) {
+	if u.Object == nil {
+		u.Object = make(map[string]interface{})
+	}
+	SetNestedField(u.Object, value, fields...)
+}

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured_list_test.go

@@ -17,30 +17,13 @@ limitations under the License.
 package unstructured
 
 import (
-	"io/ioutil"
-	"sync"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
 
-// TestCodecOfUnstructuredList tests that there are no data races in Encode().
+	"github.com/stretchr/testify/assert"
-// i.e. that it does not mutate the object being encoded.
+	"github.com/stretchr/testify/require"
-func TestCodecOfUnstructuredList(t *testing.T) {
+)
-	var wg sync.WaitGroup
-	concurrency := 10
-	list := UnstructuredList{
-		Object: map[string]interface{}{},
-	}
-	wg.Add(concurrency)
-	for i := 0; i < concurrency; i++ {
-		go func() {
-			defer wg.Done()
-			assert.NoError(t, UnstructuredJSONScheme.Encode(&list, ioutil.Discard))
-		}()
-	}
-	wg.Wait()
-}
 
 func TestUnstructuredList(t *testing.T) {
 	list := &UnstructuredList{
@@ -51,12 +34,10 @@ func TestUnstructuredList(t *testing.T) {
 	}
 	content := list.UnstructuredContent()
 	items := content["items"].([]interface{})
-	if len(items) != 1 {
+	require.Len(t, items, 1)
-		t.Fatalf("unexpected items: %#v", items)
+	val, ok := NestedFieldCopy(items[0].(map[string]interface{}), "metadata", "name")
-	}
+	require.True(t, ok)
-	if getNestedField(items[0].(map[string]interface{}), "metadata", "name") != "test" {
+	assert.Equal(t, "test", val)
-		t.Fatalf("unexpected fields: %#v", items[0])
-	}
 }
 
 func TestNilDeletionTimestamp(t *testing.T) {
@@ -70,9 +51,14 @@ func TestNilDeletionTimestamp(t *testing.T) {
 	if del != nil {
 		t.Errorf("unexpected non-nil deletion timestamp: %v", del)
 	}
+	_, ok := u.Object["metadata"]
+	assert.False(t, ok)
+
+	now := metav1.Now()
+	u.SetDeletionTimestamp(&now)
+	assert.Equal(t, now.Unix(), u.GetDeletionTimestamp().Unix())
+	u.SetDeletionTimestamp(nil)
 	metadata := u.Object["metadata"].(map[string]interface{})
-	deletionTimestamp := metadata["deletionTimestamp"]
+	_, ok = metadata["deletionTimestamp"]
-	if deletionTimestamp != nil {
+	assert.False(t, ok)
-		t.Errorf("unexpected deletion timestamp field: %q", deletionTimestamp)
-	}
 }

staging/src/k8s.io/apimachinery/pkg/conversion/unstructured/converter.go

@@ -426,21 +426,23 @@ func (c *converterImpl) ToUnstructured(obj interface{}) (map[string]interface{},
 // DeepCopyJSON deep copies the passed value, assuming it is a valid JSON representation i.e. only contains
 // types produced by json.Unmarshal().
 func DeepCopyJSON(x map[string]interface{}) map[string]interface{} {
-	return deepCopyJSON(x).(map[string]interface{})
+	return DeepCopyJSONValue(x).(map[string]interface{})
 }
 
-func deepCopyJSON(x interface{}) interface{} {
+// DeepCopyJSONValue deep copies the passed value, assuming it is a valid JSON representation i.e. only contains
+// types produced by json.Unmarshal().
+func DeepCopyJSONValue(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)
+			clone[k] = DeepCopyJSONValue(v)
 		}
 		return clone
 	case []interface{}:
 		clone := make([]interface{}, len(x))
 		for i, v := range x {
-			clone[i] = deepCopyJSON(v)
+			clone[i] = DeepCopyJSONValue(v)
 		}
 		return clone
 	case string, int64, bool, float64, nil, encodingjson.Number:

staging/src/k8s.io/apimachinery/pkg/test/apis_meta_v1_unstructed_unstructure_test.go

@@ -84,6 +84,7 @@ func TestDecode(t *testing.T) {
 			json: []byte(`{"apiVersion": "test", "kind": "test_list", "items": []}`),
 			want: &unstructured.UnstructuredList{
 				Object: map[string]interface{}{"apiVersion": "test", "kind": "test_list"},
+				Items:  []unstructured.Unstructured{},
 			},
 		},
 		{
@@ -147,14 +148,14 @@ func TestUnstructuredGetters(t *testing.T) {
 				"annotations": map[string]interface{}{
 					"test_annotation": "test_value",
 				},
-				"ownerReferences": []map[string]interface{}{
+				"ownerReferences": []interface{}{
-					{
+					map[string]interface{}{
 						"kind":       "Pod",
 						"name":       "poda",
 						"apiVersion": "v1",
 						"uid":        "1",
 					},
-					{
+					map[string]interface{}{
 						"kind":       "Pod",
 						"name":       "podb",
 						"apiVersion": "v1",
@@ -273,7 +274,7 @@ func TestUnstructuredSetters(t *testing.T) {
 				"selfLink":                   "test_selfLink",
 				"creationTimestamp":          "2009-11-10T23:00:00Z",
 				"deletionTimestamp":          "2010-11-10T23:00:00Z",
-				"deletionGracePeriodSeconds": &ten,
+				"deletionGracePeriodSeconds": ten,
 				"generation":                 ten,
 				"labels": map[string]interface{}{
 					"test_label": "test_value",
@@ -281,14 +282,14 @@ func TestUnstructuredSetters(t *testing.T) {
 				"annotations": map[string]interface{}{
 					"test_annotation": "test_value",
 				},
-				"ownerReferences": []map[string]interface{}{
+				"ownerReferences": []interface{}{
-					{
+					map[string]interface{}{
 						"kind":       "Pod",
 						"name":       "poda",
 						"apiVersion": "v1",
 						"uid":        "1",
 					},
-					{
+					map[string]interface{}{
 						"kind":               "Pod",
 						"name":               "podb",
 						"apiVersion":         "v1",