vendor files

vendor/k8s.io/kubernetes/pkg/api/OWNERS

@@ -0,0 +1,4 @@
+approvers:
+- api-approvers
+reviewers:
+- api-reviewers

vendor/k8s.io/kubernetes/pkg/api/endpoints/BUILD

@@ -0,0 +1,43 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/endpoints",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/util/hash:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/endpoints",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//vendor/github.com/davecgh/go-spew/spew:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/endpoints/OWNERS

@@ -0,0 +1,8 @@
+reviewers:
+- thockin
+- smarterclayton
+- mikedanese
+- sttts
+- eparis
+- resouer
+- david-mcmahon

vendor/k8s.io/kubernetes/pkg/api/endpoints/util.go

@@ -0,0 +1,226 @@
+/*
+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 endpoints
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/hex"
+	"hash"
+	"sort"
+
+	"k8s.io/apimachinery/pkg/types"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	hashutil "k8s.io/kubernetes/pkg/util/hash"
+)
+
+// RepackSubsets takes a slice of EndpointSubset objects, expands it to the full
+// representation, and then repacks that into the canonical layout.  This
+// ensures that code which operates on these objects can rely on the common
+// form for things like comparison.  The result is a newly allocated slice.
+func RepackSubsets(subsets []api.EndpointSubset) []api.EndpointSubset {
+	// First map each unique port definition to the sets of hosts that
+	// offer it.
+	allAddrs := map[addressKey]*api.EndpointAddress{}
+	portToAddrReadyMap := map[api.EndpointPort]addressSet{}
+	for i := range subsets {
+		for _, port := range subsets[i].Ports {
+			for k := range subsets[i].Addresses {
+				mapAddressByPort(&subsets[i].Addresses[k], port, true, allAddrs, portToAddrReadyMap)
+			}
+			for k := range subsets[i].NotReadyAddresses {
+				mapAddressByPort(&subsets[i].NotReadyAddresses[k], port, false, allAddrs, portToAddrReadyMap)
+			}
+		}
+	}
+
+	// Next, map the sets of hosts to the sets of ports they offer.
+	// Go does not allow maps or slices as keys to maps, so we have
+	// to synthesize an artificial key and do a sort of 2-part
+	// associative entity.
+	type keyString string
+	keyToAddrReadyMap := map[keyString]addressSet{}
+	addrReadyMapKeyToPorts := map[keyString][]api.EndpointPort{}
+	for port, addrs := range portToAddrReadyMap {
+		key := keyString(hashAddresses(addrs))
+		keyToAddrReadyMap[key] = addrs
+		addrReadyMapKeyToPorts[key] = append(addrReadyMapKeyToPorts[key], port)
+	}
+
+	// Next, build the N-to-M association the API wants.
+	final := []api.EndpointSubset{}
+	for key, ports := range addrReadyMapKeyToPorts {
+		var readyAddrs, notReadyAddrs []api.EndpointAddress
+		for addr, ready := range keyToAddrReadyMap[key] {
+			if ready {
+				readyAddrs = append(readyAddrs, *addr)
+			} else {
+				notReadyAddrs = append(notReadyAddrs, *addr)
+			}
+		}
+		final = append(final, api.EndpointSubset{Addresses: readyAddrs, NotReadyAddresses: notReadyAddrs, Ports: ports})
+	}
+
+	// Finally, sort it.
+	return SortSubsets(final)
+}
+
+// The sets of hosts must be de-duped, using IP+UID as the key.
+type addressKey struct {
+	ip  string
+	uid types.UID
+}
+
+// mapAddressByPort adds an address into a map by its ports, registering the address with a unique pointer, and preserving
+// any existing ready state.
+func mapAddressByPort(addr *api.EndpointAddress, port api.EndpointPort, ready bool, allAddrs map[addressKey]*api.EndpointAddress, portToAddrReadyMap map[api.EndpointPort]addressSet) *api.EndpointAddress {
+	// use addressKey to distinguish between two endpoints that are identical addresses
+	// but may have come from different hosts, for attribution. For instance, Mesos
+	// assigns pods the node IP, but the pods are distinct.
+	key := addressKey{ip: addr.IP}
+	if addr.TargetRef != nil {
+		key.uid = addr.TargetRef.UID
+	}
+
+	// Accumulate the address. The full EndpointAddress structure is preserved for use when
+	// we rebuild the subsets so that the final TargetRef has all of the necessary data.
+	existingAddress := allAddrs[key]
+	if existingAddress == nil {
+		// Make a copy so we don't write to the
+		// input args of this function.
+		existingAddress = &api.EndpointAddress{}
+		*existingAddress = *addr
+		allAddrs[key] = existingAddress
+	}
+
+	// Remember that this port maps to this address.
+	if _, found := portToAddrReadyMap[port]; !found {
+		portToAddrReadyMap[port] = addressSet{}
+	}
+	// if we have not yet recorded this port for this address, or if the previous
+	// state was ready, write the current ready state. not ready always trumps
+	// ready.
+	if wasReady, found := portToAddrReadyMap[port][existingAddress]; !found || wasReady {
+		portToAddrReadyMap[port][existingAddress] = ready
+	}
+	return existingAddress
+}
+
+type addressSet map[*api.EndpointAddress]bool
+
+type addrReady struct {
+	addr  *api.EndpointAddress
+	ready bool
+}
+
+func hashAddresses(addrs addressSet) string {
+	// Flatten the list of addresses into a string so it can be used as a
+	// map key.  Unfortunately, DeepHashObject is implemented in terms of
+	// spew, and spew does not handle non-primitive map keys well.  So
+	// first we collapse it into a slice, sort the slice, then hash that.
+	slice := make([]addrReady, 0, len(addrs))
+	for k, ready := range addrs {
+		slice = append(slice, addrReady{k, ready})
+	}
+	sort.Sort(addrsReady(slice))
+	hasher := md5.New()
+	hashutil.DeepHashObject(hasher, slice)
+	return hex.EncodeToString(hasher.Sum(nil)[0:])
+}
+
+func lessAddrReady(a, b addrReady) bool {
+	// ready is not significant to hashing since we can't have duplicate addresses
+	return LessEndpointAddress(a.addr, b.addr)
+}
+
+type addrsReady []addrReady
+
+func (sl addrsReady) Len() int      { return len(sl) }
+func (sl addrsReady) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
+func (sl addrsReady) Less(i, j int) bool {
+	return lessAddrReady(sl[i], sl[j])
+}
+
+func LessEndpointAddress(a, b *api.EndpointAddress) bool {
+	ipComparison := bytes.Compare([]byte(a.IP), []byte(b.IP))
+	if ipComparison != 0 {
+		return ipComparison < 0
+	}
+	if b.TargetRef == nil {
+		return false
+	}
+	if a.TargetRef == nil {
+		return true
+	}
+	return a.TargetRef.UID < b.TargetRef.UID
+}
+
+type addrPtrsByIpAndUID []*api.EndpointAddress
+
+func (sl addrPtrsByIpAndUID) Len() int      { return len(sl) }
+func (sl addrPtrsByIpAndUID) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
+func (sl addrPtrsByIpAndUID) Less(i, j int) bool {
+	return LessEndpointAddress(sl[i], sl[j])
+}
+
+// SortSubsets sorts an array of EndpointSubset objects in place.  For ease of
+// use it returns the input slice.
+func SortSubsets(subsets []api.EndpointSubset) []api.EndpointSubset {
+	for i := range subsets {
+		ss := &subsets[i]
+		sort.Sort(addrsByIpAndUID(ss.Addresses))
+		sort.Sort(addrsByIpAndUID(ss.NotReadyAddresses))
+		sort.Sort(portsByHash(ss.Ports))
+	}
+	sort.Sort(subsetsByHash(subsets))
+	return subsets
+}
+
+func hashObject(hasher hash.Hash, obj interface{}) []byte {
+	hashutil.DeepHashObject(hasher, obj)
+	return hasher.Sum(nil)
+}
+
+type subsetsByHash []api.EndpointSubset
+
+func (sl subsetsByHash) Len() int      { return len(sl) }
+func (sl subsetsByHash) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
+func (sl subsetsByHash) Less(i, j int) bool {
+	hasher := md5.New()
+	h1 := hashObject(hasher, sl[i])
+	h2 := hashObject(hasher, sl[j])
+	return bytes.Compare(h1, h2) < 0
+}
+
+type addrsByIpAndUID []api.EndpointAddress
+
+func (sl addrsByIpAndUID) Len() int      { return len(sl) }
+func (sl addrsByIpAndUID) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
+func (sl addrsByIpAndUID) Less(i, j int) bool {
+	return LessEndpointAddress(&sl[i], &sl[j])
+}
+
+type portsByHash []api.EndpointPort
+
+func (sl portsByHash) Len() int      { return len(sl) }
+func (sl portsByHash) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
+func (sl portsByHash) Less(i, j int) bool {
+	hasher := md5.New()
+	h1 := hashObject(hasher, sl[i])
+	h2 := hashObject(hasher, sl[j])
+	return bytes.Compare(h1, h2) < 0
+}

vendor/k8s.io/kubernetes/pkg/api/endpoints/util_test.go

@@ -0,0 +1,464 @@
+/*
+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 endpoints
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+	"k8s.io/apimachinery/pkg/types"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+func podRef(uid string) *api.ObjectReference {
+	ref := api.ObjectReference{UID: types.UID(uid)}
+	return &ref
+}
+
+func TestPackSubsets(t *testing.T) {
+	// The downside of table-driven tests is that some things have to live outside the table.
+	fooObjRef := api.ObjectReference{Name: "foo"}
+	barObjRef := api.ObjectReference{Name: "bar"}
+
+	testCases := []struct {
+		name   string
+		given  []api.EndpointSubset
+		expect []api.EndpointSubset
+	}{
+		{
+			name:   "empty everything",
+			given:  []api.EndpointSubset{{Addresses: []api.EndpointAddress{}, Ports: []api.EndpointPort{}}},
+			expect: []api.EndpointSubset{},
+		}, {
+			name:   "empty addresses",
+			given:  []api.EndpointSubset{{Addresses: []api.EndpointAddress{}, Ports: []api.EndpointPort{{Port: 111}}}},
+			expect: []api.EndpointSubset{},
+		}, {
+			name:   "empty ports",
+			given:  []api.EndpointSubset{{Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}}, Ports: []api.EndpointPort{}}},
+			expect: []api.EndpointSubset{},
+		}, {
+			name:   "empty ports",
+			given:  []api.EndpointSubset{{NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4"}}, Ports: []api.EndpointPort{}}},
+			expect: []api.EndpointSubset{},
+		}, {
+			name: "one set, one ip, one port",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one ip, one port (IPv6)",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "beef::1:2:3:4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "beef::1:2:3:4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one notReady ip, one port",
+			given: []api.EndpointSubset{{
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one ip, one UID, one port",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one notReady ip, one UID, one port",
+			given: []api.EndpointSubset{{
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one ip, empty UID, one port",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one notReady ip, empty UID, one port",
+			given: []api.EndpointSubset{{
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("")}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("")}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, two ips, one port",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}, {IP: "5.6.7.8"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}, {IP: "5.6.7.8"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, two mixed ips, one port",
+			given: []api.EndpointSubset{{
+				Addresses:         []api.EndpointAddress{{IP: "1.2.3.4"}},
+				NotReadyAddresses: []api.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses:         []api.EndpointAddress{{IP: "1.2.3.4"}},
+				NotReadyAddresses: []api.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, two duplicate ips, one port, notReady is covered by ready",
+			given: []api.EndpointSubset{{
+				Addresses:         []api.EndpointAddress{{IP: "1.2.3.4"}},
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one ip, two ports",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}, {Port: 222}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}, {Port: 222}},
+			}},
+		}, {
+			name: "one set, dup ips, one port",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}, {IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, dup ips, one port (IPv6)",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "beef::1"}, {IP: "beef::1"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "beef::1"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, dup ips with target-refs, one port",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{
+					{IP: "1.2.3.4", TargetRef: &fooObjRef},
+					{IP: "1.2.3.4", TargetRef: &barObjRef},
+				},
+				Ports: []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: &fooObjRef}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, dup mixed ips with target-refs, one port",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{
+					{IP: "1.2.3.4", TargetRef: &fooObjRef},
+				},
+				NotReadyAddresses: []api.EndpointAddress{
+					{IP: "1.2.3.4", TargetRef: &barObjRef},
+				},
+				Ports: []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				// finding the same address twice is considered an error on input, only the first address+port
+				// reference is preserved
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: &fooObjRef}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one ip, dup ports",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}, {Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, dup ip, dup port",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, dup mixed ip, dup port",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, dup ip, two ports",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 222}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}, {Port: 222}},
+			}},
+		}, {
+			name: "two sets, dup ip, dup uids, two ports",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []api.EndpointPort{{Port: 222}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []api.EndpointPort{{Port: 111}, {Port: 222}},
+			}},
+		}, {
+			name: "two sets, dup mixed ip, dup uids, two ports",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:             []api.EndpointPort{{Port: 222}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:             []api.EndpointPort{{Port: 222}},
+			}},
+		}, {
+			name: "two sets, two ips, dup port",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}, {IP: "5.6.7.8"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two set, dup ip, two uids, dup ports",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-2")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{
+					{IP: "1.2.3.4", TargetRef: podRef("uid-1")},
+					{IP: "1.2.3.4", TargetRef: podRef("uid-2")},
+				},
+				Ports: []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two set, dup ip, with and without uid, dup ports",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-2")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{
+					{IP: "1.2.3.4"},
+					{IP: "1.2.3.4", TargetRef: podRef("uid-2")},
+				},
+				Ports: []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, two ips, two dup ip with uid, dup port, wrong order",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "5.6.7.8", TargetRef: podRef("uid-1")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{
+					{IP: "1.2.3.4"},
+					{IP: "1.2.3.4", TargetRef: podRef("uid-1")},
+					{IP: "5.6.7.8"},
+					{IP: "5.6.7.8", TargetRef: podRef("uid-1")},
+				},
+				Ports: []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, two mixed ips, two dup ip with uid, dup port, wrong order, ends up with split addresses",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []api.EndpointAddress{{IP: "5.6.7.8", TargetRef: podRef("uid-1")}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []api.EndpointPort{{Port: 111}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{
+					{IP: "5.6.7.8"},
+				},
+				NotReadyAddresses: []api.EndpointAddress{
+					{IP: "1.2.3.4"},
+					{IP: "1.2.3.4", TargetRef: podRef("uid-1")},
+					{IP: "5.6.7.8", TargetRef: podRef("uid-1")},
+				},
+				Ports: []api.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, two ips, two ports",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:     []api.EndpointPort{{Port: 222}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:     []api.EndpointPort{{Port: 222}},
+			}},
+		}, {
+			name: "four sets, three ips, three ports, jumbled",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:     []api.EndpointPort{{Port: 222}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.6"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:     []api.EndpointPort{{Port: 333}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}, {IP: "1.2.3.6"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:     []api.EndpointPort{{Port: 222}, {Port: 333}},
+			}},
+		}, {
+			name: "four sets, three mixed ips, three ports, jumbled",
+			given: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:             []api.EndpointPort{{Port: 222}},
+			}, {
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.6"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:             []api.EndpointPort{{Port: 333}},
+			}},
+			expect: []api.EndpointSubset{{
+				Addresses: []api.EndpointAddress{{IP: "1.2.3.4"}, {IP: "1.2.3.6"}},
+				Ports:     []api.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []api.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:             []api.EndpointPort{{Port: 222}, {Port: 333}},
+			}},
+		},
+	}
+
+	for _, tc := range testCases {
+		result := RepackSubsets(tc.given)
+		if !reflect.DeepEqual(result, SortSubsets(tc.expect)) {
+			t.Errorf("case %q: expected %s, got %s", tc.name, spew.Sprintf("%#v", SortSubsets(tc.expect)), spew.Sprintf("%#v", result))
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/events/BUILD

@@ -0,0 +1,38 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["sorted_event_list.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/events",
+    deps = ["//pkg/apis/core:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["sorted_event_list_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/events",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/events/OWNERS

@@ -0,0 +1,2 @@
+reviewers:
+- gmarek

vendor/k8s.io/kubernetes/pkg/api/events/sorted_event_list.go

@@ -0,0 +1,36 @@
+/*
+Copyright 2014 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 events
+
+import (
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+// SortableEvents implements sort.Interface for []api.Event based on the Timestamp field
+type SortableEvents []api.Event
+
+func (list SortableEvents) Len() int {
+	return len(list)
+}
+
+func (list SortableEvents) Swap(i, j int) {
+	list[i], list[j] = list[j], list[i]
+}
+
+func (list SortableEvents) Less(i, j int) bool {
+	return list[i].LastTimestamp.Time.Before(list[j].LastTimestamp.Time)
+}

vendor/k8s.io/kubernetes/pkg/api/events/sorted_event_list_test.go

@@ -0,0 +1,66 @@
+/*
+Copyright 2014 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 events
+
+import (
+	"sort"
+	"testing"
+	"time"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+func TestSortableEvents(t *testing.T) {
+	// Arrange
+	list := SortableEvents([]api.Event{
+		{
+			Source:         api.EventSource{Component: "kubelet"},
+			Message:        "Item 1",
+			FirstTimestamp: metav1.NewTime(time.Date(2014, time.January, 15, 0, 0, 0, 0, time.UTC)),
+			LastTimestamp:  metav1.NewTime(time.Date(2014, time.January, 15, 0, 0, 0, 0, time.UTC)),
+			Count:          1,
+			Type:           api.EventTypeNormal,
+		},
+		{
+			Source:         api.EventSource{Component: "scheduler"},
+			Message:        "Item 2",
+			FirstTimestamp: metav1.NewTime(time.Date(1987, time.June, 17, 0, 0, 0, 0, time.UTC)),
+			LastTimestamp:  metav1.NewTime(time.Date(1987, time.June, 17, 0, 0, 0, 0, time.UTC)),
+			Count:          1,
+			Type:           api.EventTypeNormal,
+		},
+		{
+			Source:         api.EventSource{Component: "kubelet"},
+			Message:        "Item 3",
+			FirstTimestamp: metav1.NewTime(time.Date(2002, time.December, 25, 0, 0, 0, 0, time.UTC)),
+			LastTimestamp:  metav1.NewTime(time.Date(2002, time.December, 25, 0, 0, 0, 0, time.UTC)),
+			Count:          1,
+			Type:           api.EventTypeNormal,
+		},
+	})
+
+	// Act
+	sort.Sort(list)
+
+	// Assert
+	if list[0].Message != "Item 2" ||
+		list[1].Message != "Item 3" ||
+		list[2].Message != "Item 1" {
+		t.Fatal("List is not sorted by time. List: ", list)
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/legacyscheme/BUILD

@@ -0,0 +1,28 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["scheme.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/legacyscheme",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apimachinery/announced:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apimachinery/registered:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/k8s.io/kubernetes/pkg/api/legacyscheme/scheme.go

@@ -0,0 +1,46 @@
+/*
+Copyright 2014 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 legacyscheme
+
+import (
+	"os"
+
+	"k8s.io/apimachinery/pkg/apimachinery/announced"
+	"k8s.io/apimachinery/pkg/apimachinery/registered"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
+)
+
+// GroupFactoryRegistry is the APIGroupFactoryRegistry (overlaps a bit with Registry, see comments in package for details)
+var GroupFactoryRegistry = make(announced.APIGroupFactoryRegistry)
+
+// Registry is an instance of an API registry.  This is an interim step to start removing the idea of a global
+// API registry.
+var Registry = registered.NewOrDie(os.Getenv("KUBE_API_VERSIONS"))
+
+// Scheme is the default instance of runtime.Scheme to which types in the Kubernetes API are already registered.
+// NOTE: If you are copying this file to start a new api group, STOP! Copy the
+// extensions group instead. This Scheme is special and should appear ONLY in
+// the api group, unless you really know what you're doing.
+// TODO(lavalamp): make the above error impossible.
+var Scheme = runtime.NewScheme()
+
+// Codecs provides access to encoding and decoding for the scheme
+var Codecs = serializer.NewCodecFactory(Scheme)
+
+// ParameterCodec handles versioning of objects that are converted to query parameters.
+var ParameterCodec = runtime.NewParameterCodec(Scheme)

vendor/k8s.io/kubernetes/pkg/api/persistentvolume/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/persistentvolume",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/features:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/persistentvolume",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/features:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/api/persistentvolume/OWNERS

@@ -0,0 +1,4 @@
+reviewers:
+- smarterclayton
+- jsafrane
+- david-mcmahon

vendor/k8s.io/kubernetes/pkg/api/persistentvolume/util.go

@@ -0,0 +1,116 @@
+/*
+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 persistentvolume
+
+import (
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+func getClaimRefNamespace(pv *api.PersistentVolume) string {
+	if pv.Spec.ClaimRef != nil {
+		return pv.Spec.ClaimRef.Namespace
+	}
+	return ""
+}
+
+// Visitor is called with each object's namespace and name, and returns true if visiting should continue
+type Visitor func(namespace, name string) (shouldContinue bool)
+
+// VisitPVSecretNames invokes the visitor function with the name of every secret
+// referenced by the PV spec. If visitor returns false, visiting is short-circuited.
+// Returns true if visiting completed, false if visiting was short-circuited.
+func VisitPVSecretNames(pv *api.PersistentVolume, visitor Visitor) bool {
+	source := &pv.Spec.PersistentVolumeSource
+	switch {
+	case source.AzureFile != nil:
+		if source.AzureFile.SecretNamespace != nil && len(*source.AzureFile.SecretNamespace) > 0 {
+			if len(source.AzureFile.SecretName) > 0 && !visitor(*source.AzureFile.SecretNamespace, source.AzureFile.SecretName) {
+				return false
+			}
+		} else {
+			if len(source.AzureFile.SecretName) > 0 && !visitor(getClaimRefNamespace(pv), source.AzureFile.SecretName) {
+				return false
+			}
+		}
+		return true
+	case source.CephFS != nil:
+		if source.CephFS.SecretRef != nil {
+			// previously persisted PV objects use claimRef namespace
+			ns := getClaimRefNamespace(pv)
+			if len(source.CephFS.SecretRef.Namespace) > 0 {
+				// use the secret namespace if namespace is set
+				ns = source.CephFS.SecretRef.Namespace
+			}
+			if !visitor(ns, source.CephFS.SecretRef.Name) {
+				return false
+			}
+		}
+	case source.FlexVolume != nil:
+		if source.FlexVolume.SecretRef != nil && !visitor(getClaimRefNamespace(pv), source.FlexVolume.SecretRef.Name) {
+			return false
+		}
+	case source.RBD != nil:
+		if source.RBD.SecretRef != nil {
+			// previously persisted PV objects use claimRef namespace
+			ns := getClaimRefNamespace(pv)
+			if len(source.RBD.SecretRef.Namespace) > 0 {
+				// use the secret namespace if namespace is set
+				ns = source.RBD.SecretRef.Namespace
+			}
+			if !visitor(ns, source.RBD.SecretRef.Name) {
+				return false
+			}
+		}
+	case source.ScaleIO != nil:
+		if source.ScaleIO.SecretRef != nil {
+			ns := getClaimRefNamespace(pv)
+			if source.ScaleIO.SecretRef != nil && len(source.ScaleIO.SecretRef.Namespace) > 0 {
+				ns = source.ScaleIO.SecretRef.Namespace
+			}
+			if !visitor(ns, source.ScaleIO.SecretRef.Name) {
+				return false
+			}
+		}
+	case source.ISCSI != nil:
+		if source.ISCSI.SecretRef != nil {
+			// previously persisted PV objects use claimRef namespace
+			ns := getClaimRefNamespace(pv)
+			if len(source.ISCSI.SecretRef.Namespace) > 0 {
+				// use the secret namespace if namespace is set
+				ns = source.ISCSI.SecretRef.Namespace
+			}
+			if !visitor(ns, source.ISCSI.SecretRef.Name) {
+				return false
+			}
+		}
+	case source.StorageOS != nil:
+		if source.StorageOS.SecretRef != nil && !visitor(source.StorageOS.SecretRef.Namespace, source.StorageOS.SecretRef.Name) {
+			return false
+		}
+	}
+	return true
+}
+
+// DropDisabledAlphaFields removes disabled fields from the pv spec.
+// This should be called from PrepareForCreate/PrepareForUpdate for all resources containing a pv spec.
+func DropDisabledAlphaFields(pvSpec *api.PersistentVolumeSpec) {
+	if !utilfeature.DefaultFeatureGate.Enabled(features.BlockVolume) {
+		pvSpec.VolumeMode = nil
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/persistentvolume/util_test.go

@@ -0,0 +1,275 @@
+/*
+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 persistentvolume
+
+import (
+	"reflect"
+	"testing"
+
+	"strings"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+func TestPVSecrets(t *testing.T) {
+	// Stub containing all possible secret references in a PV.
+	// The names of the referenced secrets match struct paths detected by reflection.
+	secretNamespace := "Spec.PersistentVolumeSource.AzureFile.SecretNamespace"
+	pvs := []*api.PersistentVolume{
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				AzureFile: &api.AzureFilePersistentVolumeSource{
+					SecretName: "Spec.PersistentVolumeSource.AzureFile.SecretName"}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				AzureFile: &api.AzureFilePersistentVolumeSource{
+					SecretName:      "Spec.PersistentVolumeSource.AzureFile.SecretName",
+					SecretNamespace: &secretNamespace}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				CephFS: &api.CephFSPersistentVolumeSource{
+					SecretRef: &api.SecretReference{
+						Name:      "Spec.PersistentVolumeSource.CephFS.SecretRef",
+						Namespace: "cephfs"}}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				CephFS: &api.CephFSPersistentVolumeSource{
+					SecretRef: &api.SecretReference{
+						Name: "Spec.PersistentVolumeSource.CephFS.SecretRef"}}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				FlexVolume: &api.FlexVolumeSource{
+					SecretRef: &api.LocalObjectReference{
+						Name: "Spec.PersistentVolumeSource.FlexVolume.SecretRef"}}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				RBD: &api.RBDPersistentVolumeSource{
+					SecretRef: &api.SecretReference{
+						Name: "Spec.PersistentVolumeSource.RBD.SecretRef"}}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				RBD: &api.RBDPersistentVolumeSource{
+					SecretRef: &api.SecretReference{
+						Name:      "Spec.PersistentVolumeSource.RBD.SecretRef",
+						Namespace: "rbdns"}}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				ScaleIO: &api.ScaleIOPersistentVolumeSource{
+					SecretRef: &api.SecretReference{
+						Name: "Spec.PersistentVolumeSource.ScaleIO.SecretRef"}}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				ScaleIO: &api.ScaleIOPersistentVolumeSource{
+					SecretRef: &api.SecretReference{
+						Name:      "Spec.PersistentVolumeSource.ScaleIO.SecretRef",
+						Namespace: "scaleions"}}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				ISCSI: &api.ISCSIPersistentVolumeSource{
+					SecretRef: &api.SecretReference{
+						Name:      "Spec.PersistentVolumeSource.ISCSI.SecretRef",
+						Namespace: "iscsi"}}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				ISCSI: &api.ISCSIPersistentVolumeSource{
+					SecretRef: &api.SecretReference{
+						Name: "Spec.PersistentVolumeSource.ISCSI.SecretRef"}}}}},
+		{Spec: api.PersistentVolumeSpec{
+			ClaimRef: &api.ObjectReference{Namespace: "claimrefns", Name: "claimrefname"},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				StorageOS: &api.StorageOSPersistentVolumeSource{
+					SecretRef: &api.ObjectReference{
+						Name:      "Spec.PersistentVolumeSource.StorageOS.SecretRef",
+						Namespace: "storageosns"}}}}},
+	}
+	extractedNames := sets.NewString()
+	extractedNamesWithNamespace := sets.NewString()
+	for _, pv := range pvs {
+		VisitPVSecretNames(pv, func(namespace, name string) bool {
+			extractedNames.Insert(name)
+			extractedNamesWithNamespace.Insert(namespace + "/" + name)
+			return true
+		})
+	}
+
+	// excludedSecretPaths holds struct paths to fields with "secret" in the name that are not actually references to secret API objects
+	excludedSecretPaths := sets.NewString(
+		"Spec.PersistentVolumeSource.CephFS.SecretFile",
+		"Spec.PersistentVolumeSource.AzureFile.SecretNamespace",
+	)
+	// expectedSecretPaths holds struct paths to fields with "secret" in the name that are references to secret API objects.
+	// every path here should be represented as an example in the PV stub above, with the secret name set to the path.
+	expectedSecretPaths := sets.NewString(
+		"Spec.PersistentVolumeSource.AzureFile.SecretName",
+		"Spec.PersistentVolumeSource.CephFS.SecretRef",
+		"Spec.PersistentVolumeSource.FlexVolume.SecretRef",
+		"Spec.PersistentVolumeSource.RBD.SecretRef",
+		"Spec.PersistentVolumeSource.ScaleIO.SecretRef",
+		"Spec.PersistentVolumeSource.ISCSI.SecretRef",
+		"Spec.PersistentVolumeSource.StorageOS.SecretRef",
+	)
+	secretPaths := collectSecretPaths(t, nil, "", reflect.TypeOf(&api.PersistentVolume{}))
+	secretPaths = secretPaths.Difference(excludedSecretPaths)
+	if missingPaths := expectedSecretPaths.Difference(secretPaths); len(missingPaths) > 0 {
+		t.Logf("Missing expected secret paths:\n%s", strings.Join(missingPaths.List(), "\n"))
+		t.Error("Missing expected secret paths. Verify VisitPVSecretNames() is correctly finding the missing paths, then correct expectedSecretPaths")
+	}
+	if extraPaths := secretPaths.Difference(expectedSecretPaths); len(extraPaths) > 0 {
+		t.Logf("Extra secret paths:\n%s", strings.Join(extraPaths.List(), "\n"))
+		t.Error("Extra fields with 'secret' in the name found. Verify VisitPVSecretNames() is including these fields if appropriate, then correct expectedSecretPaths")
+	}
+
+	if missingNames := expectedSecretPaths.Difference(extractedNames); len(missingNames) > 0 {
+		t.Logf("Missing expected secret names:\n%s", strings.Join(missingNames.List(), "\n"))
+		t.Error("Missing expected secret names. Verify the PV stub above includes these references, then verify VisitPVSecretNames() is correctly finding the missing names")
+	}
+	if extraNames := extractedNames.Difference(expectedSecretPaths); len(extraNames) > 0 {
+		t.Logf("Extra secret names:\n%s", strings.Join(extraNames.List(), "\n"))
+		t.Error("Extra secret names extracted. Verify VisitPVSecretNames() is correctly extracting secret names")
+	}
+
+	expectedNamespacedNames := sets.NewString(
+		"claimrefns/Spec.PersistentVolumeSource.AzureFile.SecretName",
+		"Spec.PersistentVolumeSource.AzureFile.SecretNamespace/Spec.PersistentVolumeSource.AzureFile.SecretName",
+		"claimrefns/Spec.PersistentVolumeSource.CephFS.SecretRef",
+		"cephfs/Spec.PersistentVolumeSource.CephFS.SecretRef",
+		"claimrefns/Spec.PersistentVolumeSource.FlexVolume.SecretRef",
+		"claimrefns/Spec.PersistentVolumeSource.RBD.SecretRef",
+		"rbdns/Spec.PersistentVolumeSource.RBD.SecretRef",
+		"claimrefns/Spec.PersistentVolumeSource.ScaleIO.SecretRef",
+		"scaleions/Spec.PersistentVolumeSource.ScaleIO.SecretRef",
+		"claimrefns/Spec.PersistentVolumeSource.ISCSI.SecretRef",
+		"iscsi/Spec.PersistentVolumeSource.ISCSI.SecretRef",
+		"storageosns/Spec.PersistentVolumeSource.StorageOS.SecretRef",
+	)
+	if missingNames := expectedNamespacedNames.Difference(extractedNamesWithNamespace); len(missingNames) > 0 {
+		t.Logf("Missing expected namespaced names:\n%s", strings.Join(missingNames.List(), "\n"))
+		t.Error("Missing expected namespaced names. Verify the PV stub above includes these references, then verify VisitPVSecretNames() is correctly finding the missing names")
+	}
+	if extraNames := extractedNamesWithNamespace.Difference(expectedNamespacedNames); len(extraNames) > 0 {
+		t.Logf("Extra namespaced names:\n%s", strings.Join(extraNames.List(), "\n"))
+		t.Error("Extra namespaced names extracted. Verify VisitPVSecretNames() is correctly extracting secret names")
+	}
+}
+
+// collectSecretPaths traverses the object, computing all the struct paths that lead to fields with "secret" in the name.
+func collectSecretPaths(t *testing.T, path *field.Path, name string, tp reflect.Type) sets.String {
+	secretPaths := sets.NewString()
+
+	if tp.Kind() == reflect.Ptr {
+		secretPaths.Insert(collectSecretPaths(t, path, name, tp.Elem()).List()...)
+		return secretPaths
+	}
+
+	if strings.Contains(strings.ToLower(name), "secret") {
+		secretPaths.Insert(path.String())
+	}
+
+	switch tp.Kind() {
+	case reflect.Ptr:
+		secretPaths.Insert(collectSecretPaths(t, path, name, tp.Elem()).List()...)
+	case reflect.Struct:
+		for i := 0; i < tp.NumField(); i++ {
+			field := tp.Field(i)
+			secretPaths.Insert(collectSecretPaths(t, path.Child(field.Name), field.Name, field.Type).List()...)
+		}
+	case reflect.Interface:
+		t.Errorf("cannot find secret fields in interface{} field %s", path.String())
+	case reflect.Map:
+		secretPaths.Insert(collectSecretPaths(t, path.Key("*"), "", tp.Elem()).List()...)
+	case reflect.Slice:
+		secretPaths.Insert(collectSecretPaths(t, path.Key("*"), "", tp.Elem()).List()...)
+	default:
+		// all primitive types
+	}
+
+	return secretPaths
+}
+
+func newHostPathType(pathType string) *api.HostPathType {
+	hostPathType := new(api.HostPathType)
+	*hostPathType = api.HostPathType(pathType)
+	return hostPathType
+}
+
+func TestDropAlphaPVVolumeMode(t *testing.T) {
+	vmode := api.PersistentVolumeFilesystem
+
+	// PersistentVolume with VolumeMode set
+	pv := api.PersistentVolume{
+		Spec: api.PersistentVolumeSpec{
+			AccessModes: []api.PersistentVolumeAccessMode{api.ReadWriteOnce},
+			PersistentVolumeSource: api.PersistentVolumeSource{
+				HostPath: &api.HostPathVolumeSource{
+					Path: "/foo",
+					Type: newHostPathType(string(api.HostPathDirectory)),
+				},
+			},
+			StorageClassName: "test-storage-class",
+			VolumeMode:       &vmode,
+		},
+	}
+
+	// Enable alpha feature BlockVolume
+	err1 := utilfeature.DefaultFeatureGate.Set("BlockVolume=true")
+	if err1 != nil {
+		t.Fatalf("Failed to enable feature gate for BlockVolume: %v", err1)
+	}
+
+	// now test dropping the fields - should not be dropped
+	DropDisabledAlphaFields(&pv.Spec)
+
+	// check to make sure VolumeDevices is still present
+	// if featureset is set to true
+	if utilfeature.DefaultFeatureGate.Enabled(features.BlockVolume) {
+		if pv.Spec.VolumeMode == nil {
+			t.Error("VolumeMode in pv.Spec should not have been dropped based on feature-gate")
+		}
+	}
+
+	// Disable alpha feature BlockVolume
+	err := utilfeature.DefaultFeatureGate.Set("BlockVolume=false")
+	if err != nil {
+		t.Fatalf("Failed to disable feature gate for BlockVolume: %v", err)
+	}
+
+	// now test dropping the fields
+	DropDisabledAlphaFields(&pv.Spec)
+
+	// check to make sure VolumeDevices is nil
+	// if featureset is set to false
+	if !utilfeature.DefaultFeatureGate.Enabled(features.BlockVolume) {
+		if pv.Spec.VolumeMode != nil {
+			t.Error("DropDisabledAlphaFields VolumeMode for pv.Spec failed")
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/persistentvolumeclaim/BUILD

@@ -0,0 +1,43 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/persistentvolumeclaim",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/features:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/persistentvolumeclaim",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/features:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/api/persistentvolumeclaim/OWNERS

@@ -0,0 +1,4 @@
+reviewers:
+- smarterclayton
+- jsafrane
+- david-mcmahon

vendor/k8s.io/kubernetes/pkg/api/persistentvolumeclaim/util.go

@@ -0,0 +1,31 @@
+/*
+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 persistentvolumeclaim
+
+import (
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+// DropDisabledAlphaFields removes disabled fields from the pvc spec.
+// This should be called from PrepareForCreate/PrepareForUpdate for all resources containing a pvc spec.
+func DropDisabledAlphaFields(pvcSpec *core.PersistentVolumeClaimSpec) {
+	if !utilfeature.DefaultFeatureGate.Enabled(features.BlockVolume) {
+		pvcSpec.VolumeMode = nil
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/persistentvolumeclaim/util_test.go

@@ -0,0 +1,71 @@
+/*
+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 persistentvolumeclaim
+
+import (
+	"testing"
+
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+func TestDropAlphaPVCVolumeMode(t *testing.T) {
+	vmode := core.PersistentVolumeFilesystem
+
+	// PersistentVolume with VolumeMode set
+	pvc := core.PersistentVolumeClaim{
+		Spec: core.PersistentVolumeClaimSpec{
+			AccessModes: []core.PersistentVolumeAccessMode{core.ReadWriteOnce},
+			VolumeMode:  &vmode,
+		},
+	}
+
+	// Enable alpha feature BlockVolume
+	err1 := utilfeature.DefaultFeatureGate.Set("BlockVolume=true")
+	if err1 != nil {
+		t.Fatalf("Failed to enable feature gate for BlockVolume: %v", err1)
+	}
+
+	// now test dropping the fields - should not be dropped
+	DropDisabledAlphaFields(&pvc.Spec)
+
+	// check to make sure VolumeDevices is still present
+	// if featureset is set to true
+	if utilfeature.DefaultFeatureGate.Enabled(features.BlockVolume) {
+		if pvc.Spec.VolumeMode == nil {
+			t.Error("VolumeMode in pvc.Spec should not have been dropped based on feature-gate")
+		}
+	}
+
+	// Disable alpha feature BlockVolume
+	err := utilfeature.DefaultFeatureGate.Set("BlockVolume=false")
+	if err != nil {
+		t.Fatalf("Failed to disable feature gate for BlockVolume: %v", err)
+	}
+
+	// now test dropping the fields
+	DropDisabledAlphaFields(&pvc.Spec)
+
+	// check to make sure VolumeDevices is nil
+	// if featureset is set to false
+	if !utilfeature.DefaultFeatureGate.Enabled(features.BlockVolume) {
+		if pvc.Spec.VolumeMode != nil {
+			t.Error("DropDisabledAlphaFields VolumeMode for pvc.Spec failed")
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/pod/BUILD

@@ -0,0 +1,46 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/pod",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/features:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/pod",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/features:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/api/pod/OWNERS

@@ -0,0 +1,4 @@
+reviewers:
+- smarterclayton
+- thockin
+- david-mcmahon

vendor/k8s.io/kubernetes/pkg/api/pod/util.go

@@ -0,0 +1,278 @@
+/*
+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 pod
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+// Visitor is called with each object name, and returns true if visiting should continue
+type Visitor func(name string) (shouldContinue bool)
+
+// VisitPodSecretNames invokes the visitor function with the name of every secret
+// referenced by the pod spec. If visitor returns false, visiting is short-circuited.
+// Transitive references (e.g. pod -> pvc -> pv -> secret) are not visited.
+// Returns true if visiting completed, false if visiting was short-circuited.
+func VisitPodSecretNames(pod *api.Pod, visitor Visitor) bool {
+	for _, reference := range pod.Spec.ImagePullSecrets {
+		if !visitor(reference.Name) {
+			return false
+		}
+	}
+	for i := range pod.Spec.InitContainers {
+		if !visitContainerSecretNames(&pod.Spec.InitContainers[i], visitor) {
+			return false
+		}
+	}
+	for i := range pod.Spec.Containers {
+		if !visitContainerSecretNames(&pod.Spec.Containers[i], visitor) {
+			return false
+		}
+	}
+	var source *api.VolumeSource
+	for i := range pod.Spec.Volumes {
+		source = &pod.Spec.Volumes[i].VolumeSource
+		switch {
+		case source.AzureFile != nil:
+			if len(source.AzureFile.SecretName) > 0 && !visitor(source.AzureFile.SecretName) {
+				return false
+			}
+		case source.CephFS != nil:
+			if source.CephFS.SecretRef != nil && !visitor(source.CephFS.SecretRef.Name) {
+				return false
+			}
+		case source.FlexVolume != nil:
+			if source.FlexVolume.SecretRef != nil && !visitor(source.FlexVolume.SecretRef.Name) {
+				return false
+			}
+		case source.Projected != nil:
+			for j := range source.Projected.Sources {
+				if source.Projected.Sources[j].Secret != nil {
+					if !visitor(source.Projected.Sources[j].Secret.Name) {
+						return false
+					}
+				}
+			}
+		case source.RBD != nil:
+			if source.RBD.SecretRef != nil && !visitor(source.RBD.SecretRef.Name) {
+				return false
+			}
+		case source.Secret != nil:
+			if !visitor(source.Secret.SecretName) {
+				return false
+			}
+		case source.ScaleIO != nil:
+			if source.ScaleIO.SecretRef != nil && !visitor(source.ScaleIO.SecretRef.Name) {
+				return false
+			}
+		case source.ISCSI != nil:
+			if source.ISCSI.SecretRef != nil && !visitor(source.ISCSI.SecretRef.Name) {
+				return false
+			}
+		case source.StorageOS != nil:
+			if source.StorageOS.SecretRef != nil && !visitor(source.StorageOS.SecretRef.Name) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func visitContainerSecretNames(container *api.Container, visitor Visitor) bool {
+	for _, env := range container.EnvFrom {
+		if env.SecretRef != nil {
+			if !visitor(env.SecretRef.Name) {
+				return false
+			}
+		}
+	}
+	for _, envVar := range container.Env {
+		if envVar.ValueFrom != nil && envVar.ValueFrom.SecretKeyRef != nil {
+			if !visitor(envVar.ValueFrom.SecretKeyRef.Name) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// VisitPodConfigmapNames invokes the visitor function with the name of every configmap
+// referenced by the pod spec. If visitor returns false, visiting is short-circuited.
+// Transitive references (e.g. pod -> pvc -> pv -> secret) are not visited.
+// Returns true if visiting completed, false if visiting was short-circuited.
+func VisitPodConfigmapNames(pod *api.Pod, visitor Visitor) bool {
+	for i := range pod.Spec.InitContainers {
+		if !visitContainerConfigmapNames(&pod.Spec.InitContainers[i], visitor) {
+			return false
+		}
+	}
+	for i := range pod.Spec.Containers {
+		if !visitContainerConfigmapNames(&pod.Spec.Containers[i], visitor) {
+			return false
+		}
+	}
+	var source *api.VolumeSource
+	for i := range pod.Spec.Volumes {
+		source = &pod.Spec.Volumes[i].VolumeSource
+		switch {
+		case source.Projected != nil:
+			for j := range source.Projected.Sources {
+				if source.Projected.Sources[j].ConfigMap != nil {
+					if !visitor(source.Projected.Sources[j].ConfigMap.Name) {
+						return false
+					}
+				}
+			}
+		case source.ConfigMap != nil:
+			if !visitor(source.ConfigMap.Name) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func visitContainerConfigmapNames(container *api.Container, visitor Visitor) bool {
+	for _, env := range container.EnvFrom {
+		if env.ConfigMapRef != nil {
+			if !visitor(env.ConfigMapRef.Name) {
+				return false
+			}
+		}
+	}
+	for _, envVar := range container.Env {
+		if envVar.ValueFrom != nil && envVar.ValueFrom.ConfigMapKeyRef != nil {
+			if !visitor(envVar.ValueFrom.ConfigMapKeyRef.Name) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// IsPodReady returns true if a pod is ready; false otherwise.
+func IsPodReady(pod *api.Pod) bool {
+	return IsPodReadyConditionTrue(pod.Status)
+}
+
+// IsPodReadyConditionTrue retruns true if a pod is ready; false otherwise.
+func IsPodReadyConditionTrue(status api.PodStatus) bool {
+	condition := GetPodReadyCondition(status)
+	return condition != nil && condition.Status == api.ConditionTrue
+}
+
+// GetPodReadyCondition extracts the pod ready condition from the given status and returns that.
+// Returns nil if the condition is not present.
+func GetPodReadyCondition(status api.PodStatus) *api.PodCondition {
+	_, condition := GetPodCondition(&status, api.PodReady)
+	return condition
+}
+
+// GetPodCondition extracts the provided condition from the given status and returns that.
+// Returns nil and -1 if the condition is not present, and the index of the located condition.
+func GetPodCondition(status *api.PodStatus, conditionType api.PodConditionType) (int, *api.PodCondition) {
+	if status == nil {
+		return -1, nil
+	}
+	for i := range status.Conditions {
+		if status.Conditions[i].Type == conditionType {
+			return i, &status.Conditions[i]
+		}
+	}
+	return -1, nil
+}
+
+// UpdatePodCondition updates existing pod condition or creates a new one. Sets LastTransitionTime to now if the
+// status has changed.
+// Returns true if pod condition has changed or has been added.
+func UpdatePodCondition(status *api.PodStatus, condition *api.PodCondition) bool {
+	condition.LastTransitionTime = metav1.Now()
+	// Try to find this pod condition.
+	conditionIndex, oldCondition := GetPodCondition(status, condition.Type)
+
+	if oldCondition == nil {
+		// We are adding new pod condition.
+		status.Conditions = append(status.Conditions, *condition)
+		return true
+	}
+	// We are updating an existing condition, so we need to check if it has changed.
+	if condition.Status == oldCondition.Status {
+		condition.LastTransitionTime = oldCondition.LastTransitionTime
+	}
+
+	isEqual := condition.Status == oldCondition.Status &&
+		condition.Reason == oldCondition.Reason &&
+		condition.Message == oldCondition.Message &&
+		condition.LastProbeTime.Equal(&oldCondition.LastProbeTime) &&
+		condition.LastTransitionTime.Equal(&oldCondition.LastTransitionTime)
+
+	status.Conditions[conditionIndex] = *condition
+	// Return true if one of the fields have changed.
+	return !isEqual
+}
+
+// DropDisabledAlphaFields removes disabled fields from the pod spec.
+// This should be called from PrepareForCreate/PrepareForUpdate for all resources containing a pod spec.
+func DropDisabledAlphaFields(podSpec *api.PodSpec) {
+	if !utilfeature.DefaultFeatureGate.Enabled(features.PodPriority) {
+		podSpec.Priority = nil
+		podSpec.PriorityClassName = ""
+	}
+
+	if !utilfeature.DefaultFeatureGate.Enabled(features.LocalStorageCapacityIsolation) {
+		for i := range podSpec.Volumes {
+			if podSpec.Volumes[i].EmptyDir != nil {
+				podSpec.Volumes[i].EmptyDir.SizeLimit = nil
+			}
+		}
+	}
+
+	for i := range podSpec.Containers {
+		DropDisabledVolumeMountsAlphaFields(podSpec.Containers[i].VolumeMounts)
+	}
+	for i := range podSpec.InitContainers {
+		DropDisabledVolumeMountsAlphaFields(podSpec.InitContainers[i].VolumeMounts)
+	}
+
+	DropDisabledVolumeDevicesAlphaFields(podSpec)
+}
+
+// DropDisabledVolumeMountsAlphaFields removes disabled fields from []VolumeMount.
+// This should be called from PrepareForCreate/PrepareForUpdate for all resources containing a VolumeMount
+func DropDisabledVolumeMountsAlphaFields(volumeMounts []api.VolumeMount) {
+	if !utilfeature.DefaultFeatureGate.Enabled(features.MountPropagation) {
+		for i := range volumeMounts {
+			volumeMounts[i].MountPropagation = nil
+		}
+	}
+}
+
+// DropDisabledVolumeDevicesAlphaFields removes disabled fields from []VolumeDevice.
+// This should be called from PrepareForCreate/PrepareForUpdate for all resources containing a VolumeDevice
+func DropDisabledVolumeDevicesAlphaFields(podSpec *api.PodSpec) {
+	if !utilfeature.DefaultFeatureGate.Enabled(features.BlockVolume) {
+		for i := range podSpec.Containers {
+			podSpec.Containers[i].VolumeDevices = nil
+		}
+		for i := range podSpec.InitContainers {
+			podSpec.InitContainers[i].VolumeDevices = nil
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/pod/util_test.go

@@ -0,0 +1,340 @@
+/*
+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 pod
+
+import (
+	"reflect"
+	"testing"
+
+	"strings"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+func TestPodSecrets(t *testing.T) {
+	// Stub containing all possible secret references in a pod.
+	// The names of the referenced secrets match struct paths detected by reflection.
+	pod := &api.Pod{
+		Spec: api.PodSpec{
+			Containers: []api.Container{{
+				EnvFrom: []api.EnvFromSource{{
+					SecretRef: &api.SecretEnvSource{
+						LocalObjectReference: api.LocalObjectReference{
+							Name: "Spec.Containers[*].EnvFrom[*].SecretRef"}}}},
+				Env: []api.EnvVar{{
+					ValueFrom: &api.EnvVarSource{
+						SecretKeyRef: &api.SecretKeySelector{
+							LocalObjectReference: api.LocalObjectReference{
+								Name: "Spec.Containers[*].Env[*].ValueFrom.SecretKeyRef"}}}}}}},
+			ImagePullSecrets: []api.LocalObjectReference{{
+				Name: "Spec.ImagePullSecrets"}},
+			InitContainers: []api.Container{{
+				EnvFrom: []api.EnvFromSource{{
+					SecretRef: &api.SecretEnvSource{
+						LocalObjectReference: api.LocalObjectReference{
+							Name: "Spec.InitContainers[*].EnvFrom[*].SecretRef"}}}},
+				Env: []api.EnvVar{{
+					ValueFrom: &api.EnvVarSource{
+						SecretKeyRef: &api.SecretKeySelector{
+							LocalObjectReference: api.LocalObjectReference{
+								Name: "Spec.InitContainers[*].Env[*].ValueFrom.SecretKeyRef"}}}}}}},
+			Volumes: []api.Volume{{
+				VolumeSource: api.VolumeSource{
+					AzureFile: &api.AzureFileVolumeSource{
+						SecretName: "Spec.Volumes[*].VolumeSource.AzureFile.SecretName"}}}, {
+				VolumeSource: api.VolumeSource{
+					CephFS: &api.CephFSVolumeSource{
+						SecretRef: &api.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.CephFS.SecretRef"}}}}, {
+				VolumeSource: api.VolumeSource{
+					FlexVolume: &api.FlexVolumeSource{
+						SecretRef: &api.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.FlexVolume.SecretRef"}}}}, {
+				VolumeSource: api.VolumeSource{
+					Projected: &api.ProjectedVolumeSource{
+						Sources: []api.VolumeProjection{{
+							Secret: &api.SecretProjection{
+								LocalObjectReference: api.LocalObjectReference{
+									Name: "Spec.Volumes[*].VolumeSource.Projected.Sources[*].Secret"}}}}}}}, {
+				VolumeSource: api.VolumeSource{
+					RBD: &api.RBDVolumeSource{
+						SecretRef: &api.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.RBD.SecretRef"}}}}, {
+				VolumeSource: api.VolumeSource{
+					Secret: &api.SecretVolumeSource{
+						SecretName: "Spec.Volumes[*].VolumeSource.Secret.SecretName"}}}, {
+				VolumeSource: api.VolumeSource{
+					Secret: &api.SecretVolumeSource{
+						SecretName: "Spec.Volumes[*].VolumeSource.Secret"}}}, {
+				VolumeSource: api.VolumeSource{
+					ScaleIO: &api.ScaleIOVolumeSource{
+						SecretRef: &api.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.ScaleIO.SecretRef"}}}}, {
+				VolumeSource: api.VolumeSource{
+					ISCSI: &api.ISCSIVolumeSource{
+						SecretRef: &api.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.ISCSI.SecretRef"}}}}, {
+				VolumeSource: api.VolumeSource{
+					StorageOS: &api.StorageOSVolumeSource{
+						SecretRef: &api.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.StorageOS.SecretRef"}}}}},
+		},
+	}
+	extractedNames := sets.NewString()
+	VisitPodSecretNames(pod, func(name string) bool {
+		extractedNames.Insert(name)
+		return true
+	})
+
+	// excludedSecretPaths holds struct paths to fields with "secret" in the name that are not actually references to secret API objects
+	excludedSecretPaths := sets.NewString(
+		"Spec.Volumes[*].VolumeSource.CephFS.SecretFile",
+	)
+	// expectedSecretPaths holds struct paths to fields with "secret" in the name that are references to secret API objects.
+	// every path here should be represented as an example in the Pod stub above, with the secret name set to the path.
+	expectedSecretPaths := sets.NewString(
+		"Spec.Containers[*].EnvFrom[*].SecretRef",
+		"Spec.Containers[*].Env[*].ValueFrom.SecretKeyRef",
+		"Spec.ImagePullSecrets",
+		"Spec.InitContainers[*].EnvFrom[*].SecretRef",
+		"Spec.InitContainers[*].Env[*].ValueFrom.SecretKeyRef",
+		"Spec.Volumes[*].VolumeSource.AzureFile.SecretName",
+		"Spec.Volumes[*].VolumeSource.CephFS.SecretRef",
+		"Spec.Volumes[*].VolumeSource.FlexVolume.SecretRef",
+		"Spec.Volumes[*].VolumeSource.Projected.Sources[*].Secret",
+		"Spec.Volumes[*].VolumeSource.RBD.SecretRef",
+		"Spec.Volumes[*].VolumeSource.Secret",
+		"Spec.Volumes[*].VolumeSource.Secret.SecretName",
+		"Spec.Volumes[*].VolumeSource.ScaleIO.SecretRef",
+		"Spec.Volumes[*].VolumeSource.ISCSI.SecretRef",
+		"Spec.Volumes[*].VolumeSource.StorageOS.SecretRef",
+	)
+	secretPaths := collectResourcePaths(t, "secret", nil, "", reflect.TypeOf(&api.Pod{}))
+	secretPaths = secretPaths.Difference(excludedSecretPaths)
+	if missingPaths := expectedSecretPaths.Difference(secretPaths); len(missingPaths) > 0 {
+		t.Logf("Missing expected secret paths:\n%s", strings.Join(missingPaths.List(), "\n"))
+		t.Error("Missing expected secret paths. Verify VisitPodSecretNames() is correctly finding the missing paths, then correct expectedSecretPaths")
+	}
+	if extraPaths := secretPaths.Difference(expectedSecretPaths); len(extraPaths) > 0 {
+		t.Logf("Extra secret paths:\n%s", strings.Join(extraPaths.List(), "\n"))
+		t.Error("Extra fields with 'secret' in the name found. Verify VisitPodSecretNames() is including these fields if appropriate, then correct expectedSecretPaths")
+	}
+
+	if missingNames := expectedSecretPaths.Difference(extractedNames); len(missingNames) > 0 {
+		t.Logf("Missing expected secret names:\n%s", strings.Join(missingNames.List(), "\n"))
+		t.Error("Missing expected secret names. Verify the pod stub above includes these references, then verify VisitPodSecretNames() is correctly finding the missing names")
+	}
+	if extraNames := extractedNames.Difference(expectedSecretPaths); len(extraNames) > 0 {
+		t.Logf("Extra secret names:\n%s", strings.Join(extraNames.List(), "\n"))
+		t.Error("Extra secret names extracted. Verify VisitPodSecretNames() is correctly extracting secret names")
+	}
+}
+
+// collectResourcePaths traverses the object, computing all the struct paths that lead to fields with resourcename in the name.
+func collectResourcePaths(t *testing.T, resourcename string, path *field.Path, name string, tp reflect.Type) sets.String {
+	resourcename = strings.ToLower(resourcename)
+	resourcePaths := sets.NewString()
+
+	if tp.Kind() == reflect.Ptr {
+		resourcePaths.Insert(collectResourcePaths(t, resourcename, path, name, tp.Elem()).List()...)
+		return resourcePaths
+	}
+
+	if strings.Contains(strings.ToLower(name), resourcename) {
+		resourcePaths.Insert(path.String())
+	}
+
+	switch tp.Kind() {
+	case reflect.Ptr:
+		resourcePaths.Insert(collectResourcePaths(t, resourcename, path, name, tp.Elem()).List()...)
+	case reflect.Struct:
+		for i := 0; i < tp.NumField(); i++ {
+			field := tp.Field(i)
+			resourcePaths.Insert(collectResourcePaths(t, resourcename, path.Child(field.Name), field.Name, field.Type).List()...)
+		}
+	case reflect.Interface:
+		t.Errorf("cannot find %s fields in interface{} field %s", resourcename, path.String())
+	case reflect.Map:
+		resourcePaths.Insert(collectResourcePaths(t, resourcename, path.Key("*"), "", tp.Elem()).List()...)
+	case reflect.Slice:
+		resourcePaths.Insert(collectResourcePaths(t, resourcename, path.Key("*"), "", tp.Elem()).List()...)
+	default:
+		// all primitive types
+	}
+
+	return resourcePaths
+}
+
+func TestPodConfigmaps(t *testing.T) {
+	// Stub containing all possible ConfigMap references in a pod.
+	// The names of the referenced ConfigMaps match struct paths detected by reflection.
+	pod := &api.Pod{
+		Spec: api.PodSpec{
+			Containers: []api.Container{{
+				EnvFrom: []api.EnvFromSource{{
+					ConfigMapRef: &api.ConfigMapEnvSource{
+						LocalObjectReference: api.LocalObjectReference{
+							Name: "Spec.Containers[*].EnvFrom[*].ConfigMapRef"}}}},
+				Env: []api.EnvVar{{
+					ValueFrom: &api.EnvVarSource{
+						ConfigMapKeyRef: &api.ConfigMapKeySelector{
+							LocalObjectReference: api.LocalObjectReference{
+								Name: "Spec.Containers[*].Env[*].ValueFrom.ConfigMapKeyRef"}}}}}}},
+			InitContainers: []api.Container{{
+				EnvFrom: []api.EnvFromSource{{
+					ConfigMapRef: &api.ConfigMapEnvSource{
+						LocalObjectReference: api.LocalObjectReference{
+							Name: "Spec.InitContainers[*].EnvFrom[*].ConfigMapRef"}}}},
+				Env: []api.EnvVar{{
+					ValueFrom: &api.EnvVarSource{
+						ConfigMapKeyRef: &api.ConfigMapKeySelector{
+							LocalObjectReference: api.LocalObjectReference{
+								Name: "Spec.InitContainers[*].Env[*].ValueFrom.ConfigMapKeyRef"}}}}}}},
+			Volumes: []api.Volume{{
+				VolumeSource: api.VolumeSource{
+					Projected: &api.ProjectedVolumeSource{
+						Sources: []api.VolumeProjection{{
+							ConfigMap: &api.ConfigMapProjection{
+								LocalObjectReference: api.LocalObjectReference{
+									Name: "Spec.Volumes[*].VolumeSource.Projected.Sources[*].ConfigMap"}}}}}}}, {
+				VolumeSource: api.VolumeSource{
+					ConfigMap: &api.ConfigMapVolumeSource{
+						LocalObjectReference: api.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.ConfigMap"}}}}},
+		},
+	}
+	extractedNames := sets.NewString()
+	VisitPodConfigmapNames(pod, func(name string) bool {
+		extractedNames.Insert(name)
+		return true
+	})
+
+	// expectedPaths holds struct paths to fields with "ConfigMap" in the name that are references to ConfigMap API objects.
+	// every path here should be represented as an example in the Pod stub above, with the ConfigMap name set to the path.
+	expectedPaths := sets.NewString(
+		"Spec.Containers[*].EnvFrom[*].ConfigMapRef",
+		"Spec.Containers[*].Env[*].ValueFrom.ConfigMapKeyRef",
+		"Spec.InitContainers[*].EnvFrom[*].ConfigMapRef",
+		"Spec.InitContainers[*].Env[*].ValueFrom.ConfigMapKeyRef",
+		"Spec.Volumes[*].VolumeSource.Projected.Sources[*].ConfigMap",
+		"Spec.Volumes[*].VolumeSource.ConfigMap",
+	)
+	collectPaths := collectResourcePaths(t, "ConfigMap", nil, "", reflect.TypeOf(&api.Pod{}))
+	if missingPaths := expectedPaths.Difference(collectPaths); len(missingPaths) > 0 {
+		t.Logf("Missing expected paths:\n%s", strings.Join(missingPaths.List(), "\n"))
+		t.Error("Missing expected paths. Verify VisitPodConfigmapNames() is correctly finding the missing paths, then correct expectedPaths")
+	}
+	if extraPaths := collectPaths.Difference(expectedPaths); len(extraPaths) > 0 {
+		t.Logf("Extra paths:\n%s", strings.Join(extraPaths.List(), "\n"))
+		t.Error("Extra fields with resource in the name found. Verify VisitPodConfigmapNames() is including these fields if appropriate, then correct expectedPaths")
+	}
+
+	if missingNames := expectedPaths.Difference(extractedNames); len(missingNames) > 0 {
+		t.Logf("Missing expected names:\n%s", strings.Join(missingNames.List(), "\n"))
+		t.Error("Missing expected names. Verify the pod stub above includes these references, then verify VisitPodConfigmapNames() is correctly finding the missing names")
+	}
+	if extraNames := extractedNames.Difference(expectedPaths); len(extraNames) > 0 {
+		t.Logf("Extra names:\n%s", strings.Join(extraNames.List(), "\n"))
+		t.Error("Extra names extracted. Verify VisitPodConfigmapNames() is correctly extracting resource names")
+	}
+}
+
+func TestDropAlphaVolumeDevices(t *testing.T) {
+	testPod := api.Pod{
+		Spec: api.PodSpec{
+			RestartPolicy: api.RestartPolicyNever,
+			Containers: []api.Container{
+				{
+					Name:  "container1",
+					Image: "testimage",
+					VolumeDevices: []api.VolumeDevice{
+						{
+							Name:       "myvolume",
+							DevicePath: "/usr/test",
+						},
+					},
+				},
+			},
+			InitContainers: []api.Container{
+				{
+					Name:  "container1",
+					Image: "testimage",
+					VolumeDevices: []api.VolumeDevice{
+						{
+							Name:       "myvolume",
+							DevicePath: "/usr/test",
+						},
+					},
+				},
+			},
+			Volumes: []api.Volume{
+				{
+					Name: "myvolume",
+					VolumeSource: api.VolumeSource{
+						HostPath: &api.HostPathVolumeSource{
+							Path: "/dev/xvdc",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	// Enable alpha feature BlockVolume
+	err1 := utilfeature.DefaultFeatureGate.Set("BlockVolume=true")
+	if err1 != nil {
+		t.Fatalf("Failed to enable feature gate for BlockVolume: %v", err1)
+	}
+
+	// now test dropping the fields - should not be dropped
+	DropDisabledAlphaFields(&testPod.Spec)
+
+	// check to make sure VolumeDevices is still present
+	// if featureset is set to true
+	if utilfeature.DefaultFeatureGate.Enabled(features.BlockVolume) {
+		if testPod.Spec.Containers[0].VolumeDevices == nil {
+			t.Error("VolumeDevices in Container should not have been dropped based on feature-gate")
+		}
+		if testPod.Spec.InitContainers[0].VolumeDevices == nil {
+			t.Error("VolumeDevices in Container should not have been dropped based on feature-gate")
+		}
+	}
+
+	// Disable alpha feature BlockVolume
+	err := utilfeature.DefaultFeatureGate.Set("BlockVolume=false")
+	if err != nil {
+		t.Fatalf("Failed to disable feature gate for BlockVolume: %v", err)
+	}
+
+	// now test dropping the fields
+	DropDisabledAlphaFields(&testPod.Spec)
+
+	// check to make sure VolumeDevices is nil
+	// if featureset is set to false
+	if !utilfeature.DefaultFeatureGate.Enabled(features.BlockVolume) {
+		if testPod.Spec.Containers[0].VolumeDevices != nil {
+			t.Error("DropDisabledAlphaFields for Containers failed")
+		}
+		if testPod.Spec.InitContainers[0].VolumeDevices != nil {
+			t.Error("DropDisabledAlphaFields for InitContainers failed")
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/ref/BUILD

@@ -0,0 +1,46 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["ref_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/ref",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/apis/core:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["ref.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/ref",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/ref/ref.go

@@ -0,0 +1,122 @@
+/*
+Copyright 2014 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 ref
+
+import (
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+var (
+	// Errors that could be returned by GetReference.
+	ErrNilObject  = errors.New("can't reference a nil object")
+	ErrNoSelfLink = errors.New("selfLink was empty, can't make reference")
+)
+
+// GetReference returns an ObjectReference which refers to the given
+// object, or an error if the object doesn't follow the conventions
+// that would allow this.
+// TODO: should take a meta.Interface see http://issue.k8s.io/7127
+func GetReference(scheme *runtime.Scheme, obj runtime.Object) (*api.ObjectReference, error) {
+	if obj == nil {
+		return nil, ErrNilObject
+	}
+	if ref, ok := obj.(*api.ObjectReference); ok {
+		// Don't make a reference to a reference.
+		return ref, nil
+	}
+
+	gvk := obj.GetObjectKind().GroupVersionKind()
+
+	// if the object referenced is actually persisted, we can just get kind from meta
+	// if we are building an object reference to something not yet persisted, we should fallback to scheme
+	kind := gvk.Kind
+	if len(kind) == 0 {
+		// TODO: this is wrong
+		gvks, _, err := scheme.ObjectKinds(obj)
+		if err != nil {
+			return nil, err
+		}
+		kind = gvks[0].Kind
+	}
+
+	// An object that implements only List has enough metadata to build a reference
+	var listMeta metav1.Common
+	objectMeta, err := meta.Accessor(obj)
+	if err != nil {
+		listMeta, err = meta.CommonAccessor(obj)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		listMeta = objectMeta
+	}
+
+	// if the object referenced is actually persisted, we can also get version from meta
+	version := gvk.GroupVersion().String()
+	if len(version) == 0 {
+		selfLink := listMeta.GetSelfLink()
+		if len(selfLink) == 0 {
+			return nil, ErrNoSelfLink
+		}
+		selfLinkUrl, err := url.Parse(selfLink)
+		if err != nil {
+			return nil, err
+		}
+		// example paths: /<prefix>/<version>/*
+		parts := strings.Split(selfLinkUrl.Path, "/")
+		if len(parts) < 3 {
+			return nil, fmt.Errorf("unexpected self link format: '%v'; got version '%v'", selfLink, version)
+		}
+		version = parts[2]
+	}
+
+	// only has list metadata
+	if objectMeta == nil {
+		return &api.ObjectReference{
+			Kind:            kind,
+			APIVersion:      version,
+			ResourceVersion: listMeta.GetResourceVersion(),
+		}, nil
+	}
+
+	return &api.ObjectReference{
+		Kind:            kind,
+		APIVersion:      version,
+		Name:            objectMeta.GetName(),
+		Namespace:       objectMeta.GetNamespace(),
+		UID:             objectMeta.GetUID(),
+		ResourceVersion: objectMeta.GetResourceVersion(),
+	}, nil
+}
+
+// GetPartialReference is exactly like GetReference, but allows you to set the FieldPath.
+func GetPartialReference(scheme *runtime.Scheme, obj runtime.Object, fieldPath string) (*api.ObjectReference, error) {
+	ref, err := GetReference(scheme, obj)
+	if err != nil {
+		return nil, err
+	}
+	ref.FieldPath = fieldPath
+	return ref, nil
+}

vendor/k8s.io/kubernetes/pkg/api/ref/ref_test.go

@@ -0,0 +1,148 @@
+/*
+Copyright 2014 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 ref
+
+import (
+	"reflect"
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+type FakeAPIObject struct{}
+
+func (obj *FakeAPIObject) GetObjectKind() schema.ObjectKind { return schema.EmptyObjectKind }
+func (obj *FakeAPIObject) DeepCopyObject() runtime.Object {
+	if obj == nil {
+		return nil
+	}
+	clone := *obj
+	return &clone
+}
+
+type ExtensionAPIObject struct {
+	metav1.TypeMeta
+	metav1.ObjectMeta
+}
+
+func (obj *ExtensionAPIObject) DeepCopyObject() runtime.Object {
+	panic("ExtensionAPIObject does not support DeepCopy")
+}
+
+func TestGetReference(t *testing.T) {
+
+	// when vendoring kube, if you don't force the set of registered versions (like make test does)
+	// then you run into trouble because the types aren't registered in the scheme by anything.  This does the
+	// register manually to allow unit test execution
+	if _, _, err := legacyscheme.Scheme.ObjectKinds(&api.Pod{}); err != nil {
+		api.AddToScheme(legacyscheme.Scheme)
+	}
+
+	table := map[string]struct {
+		obj       runtime.Object
+		ref       *api.ObjectReference
+		fieldPath string
+		shouldErr bool
+	}{
+		"pod": {
+			obj: &api.Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:            "foo",
+					UID:             "bar",
+					ResourceVersion: "42",
+					SelfLink:        "/api/version1/pods/foo",
+				},
+			},
+			fieldPath: ".desiredState.containers[0]",
+			ref: &api.ObjectReference{
+				Kind:            "Pod",
+				APIVersion:      "version1",
+				Name:            "foo",
+				UID:             "bar",
+				ResourceVersion: "42",
+				FieldPath:       ".desiredState.containers[0]",
+			},
+		},
+		"serviceList": {
+			obj: &api.ServiceList{
+				ListMeta: metav1.ListMeta{
+					ResourceVersion: "42",
+					SelfLink:        "/api/version2/services",
+				},
+			},
+			ref: &api.ObjectReference{
+				Kind:            "ServiceList",
+				APIVersion:      "version2",
+				ResourceVersion: "42",
+			},
+		},
+		"extensionAPIObject": {
+			obj: &ExtensionAPIObject{
+				TypeMeta: metav1.TypeMeta{
+					Kind: "ExtensionAPIObject",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Name:            "foo",
+					UID:             "bar",
+					ResourceVersion: "42",
+					SelfLink:        "/custom_prefix/version1/extensions/foo",
+				},
+			},
+			ref: &api.ObjectReference{
+				Kind:            "ExtensionAPIObject",
+				APIVersion:      "version1",
+				Name:            "foo",
+				UID:             "bar",
+				ResourceVersion: "42",
+			},
+		},
+		"badSelfLink": {
+			obj: &api.ServiceList{
+				ListMeta: metav1.ListMeta{
+					ResourceVersion: "42",
+					SelfLink:        "version2/services",
+				},
+			},
+			shouldErr: true,
+		},
+		"error": {
+			obj:       &FakeAPIObject{},
+			ref:       nil,
+			shouldErr: true,
+		},
+		"errorNil": {
+			obj:       nil,
+			ref:       nil,
+			shouldErr: true,
+		},
+	}
+
+	for name, item := range table {
+		ref, err := GetPartialReference(legacyscheme.Scheme, item.obj, item.fieldPath)
+		if e, a := item.shouldErr, (err != nil); e != a {
+			t.Errorf("%v: expected %v, got %v, err %v", name, e, a, err)
+			continue
+		}
+		if e, a := item.ref, ref; !reflect.DeepEqual(e, a) {
+			t.Errorf("%v: expected %#v, got %#v", name, e, a)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/resource/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["helpers.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/resource",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["helpers_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/resource",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/api/resource/helpers.go

@@ -0,0 +1,123 @@
+/*
+Copyright 2014 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 resource
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+
+	"k8s.io/apimachinery/pkg/api/resource"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+// PodRequestsAndLimits returns a dictionary of all defined resources summed up for all
+// containers of the pod.
+func PodRequestsAndLimits(pod *api.Pod) (reqs map[api.ResourceName]resource.Quantity, limits map[api.ResourceName]resource.Quantity, err error) {
+	reqs, limits = map[api.ResourceName]resource.Quantity{}, map[api.ResourceName]resource.Quantity{}
+	for _, container := range pod.Spec.Containers {
+		for name, quantity := range container.Resources.Requests {
+			if value, ok := reqs[name]; !ok {
+				reqs[name] = *quantity.Copy()
+			} else {
+				value.Add(quantity)
+				reqs[name] = value
+			}
+		}
+		for name, quantity := range container.Resources.Limits {
+			if value, ok := limits[name]; !ok {
+				limits[name] = *quantity.Copy()
+			} else {
+				value.Add(quantity)
+				limits[name] = value
+			}
+		}
+	}
+	// init containers define the minimum of any resource
+	for _, container := range pod.Spec.InitContainers {
+		for name, quantity := range container.Resources.Requests {
+			value, ok := reqs[name]
+			if !ok {
+				reqs[name] = *quantity.Copy()
+				continue
+			}
+			if quantity.Cmp(value) > 0 {
+				reqs[name] = *quantity.Copy()
+			}
+		}
+		for name, quantity := range container.Resources.Limits {
+			value, ok := limits[name]
+			if !ok {
+				limits[name] = *quantity.Copy()
+				continue
+			}
+			if quantity.Cmp(value) > 0 {
+				limits[name] = *quantity.Copy()
+			}
+		}
+	}
+	return
+}
+
+// ExtractContainerResourceValue extracts the value of a resource
+// in an already known container
+func ExtractContainerResourceValue(fs *api.ResourceFieldSelector, container *api.Container) (string, error) {
+	divisor := resource.Quantity{}
+	if divisor.Cmp(fs.Divisor) == 0 {
+		divisor = resource.MustParse("1")
+	} else {
+		divisor = fs.Divisor
+	}
+
+	switch fs.Resource {
+	case "limits.cpu":
+		return convertResourceCPUToString(container.Resources.Limits.Cpu(), divisor)
+	case "limits.memory":
+		return convertResourceMemoryToString(container.Resources.Limits.Memory(), divisor)
+	case "limits.ephemeral-storage":
+		return convertResourceEphemeralStorageToString(container.Resources.Limits.StorageEphemeral(), divisor)
+	case "requests.cpu":
+		return convertResourceCPUToString(container.Resources.Requests.Cpu(), divisor)
+	case "requests.memory":
+		return convertResourceMemoryToString(container.Resources.Requests.Memory(), divisor)
+	case "requests.ephemeral-storage":
+		return convertResourceEphemeralStorageToString(container.Resources.Requests.StorageEphemeral(), divisor)
+	}
+
+	return "", fmt.Errorf("unsupported container resource : %v", fs.Resource)
+}
+
+// convertResourceCPUToString converts cpu value to the format of divisor and returns
+// ceiling of the value.
+func convertResourceCPUToString(cpu *resource.Quantity, divisor resource.Quantity) (string, error) {
+	c := int64(math.Ceil(float64(cpu.MilliValue()) / float64(divisor.MilliValue())))
+	return strconv.FormatInt(c, 10), nil
+}
+
+// convertResourceMemoryToString converts memory value to the format of divisor and returns
+// ceiling of the value.
+func convertResourceMemoryToString(memory *resource.Quantity, divisor resource.Quantity) (string, error) {
+	m := int64(math.Ceil(float64(memory.Value()) / float64(divisor.Value())))
+	return strconv.FormatInt(m, 10), nil
+}
+
+// convertResourceEphemeralStorageToString converts ephemeral storage value to the format of divisor and returns
+// ceiling of the value.
+func convertResourceEphemeralStorageToString(ephemeralStorage *resource.Quantity, divisor resource.Quantity) (string, error) {
+	m := int64(math.Ceil(float64(ephemeralStorage.Value()) / float64(divisor.Value())))
+	return strconv.FormatInt(m, 10), nil
+}

vendor/k8s.io/kubernetes/pkg/api/resource/helpers_test.go

@@ -0,0 +1,82 @@
+/*
+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 resource
+
+import (
+	"testing"
+	"time"
+
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+func TestResourceHelpers(t *testing.T) {
+	cpuLimit := resource.MustParse("10")
+	memoryLimit := resource.MustParse("10G")
+	resourceSpec := api.ResourceRequirements{
+		Limits: api.ResourceList{
+			api.ResourceCPU:    cpuLimit,
+			api.ResourceMemory: memoryLimit,
+		},
+	}
+	if res := resourceSpec.Limits.Cpu(); res.Cmp(cpuLimit) != 0 {
+		t.Errorf("expected cpulimit %v, got %v", cpuLimit, res)
+	}
+	if res := resourceSpec.Limits.Memory(); res.Cmp(memoryLimit) != 0 {
+		t.Errorf("expected memorylimit %v, got %v", memoryLimit, res)
+	}
+	resourceSpec = api.ResourceRequirements{
+		Limits: api.ResourceList{
+			api.ResourceMemory: memoryLimit,
+		},
+	}
+	if res := resourceSpec.Limits.Cpu(); res.Value() != 0 {
+		t.Errorf("expected cpulimit %v, got %v", 0, res)
+	}
+	if res := resourceSpec.Limits.Memory(); res.Cmp(memoryLimit) != 0 {
+		t.Errorf("expected memorylimit %v, got %v", memoryLimit, res)
+	}
+}
+
+func TestDefaultResourceHelpers(t *testing.T) {
+	resourceList := api.ResourceList{}
+	if resourceList.Cpu().Format != resource.DecimalSI {
+		t.Errorf("expected %v, actual %v", resource.DecimalSI, resourceList.Cpu().Format)
+	}
+	if resourceList.Memory().Format != resource.BinarySI {
+		t.Errorf("expected %v, actual %v", resource.BinarySI, resourceList.Memory().Format)
+	}
+}
+
+func newPod(now metav1.Time, ready bool, beforeSec int) *api.Pod {
+	conditionStatus := api.ConditionFalse
+	if ready {
+		conditionStatus = api.ConditionTrue
+	}
+	return &api.Pod{
+		Status: api.PodStatus{
+			Conditions: []api.PodCondition{
+				{
+					Type:               api.PodReady,
+					LastTransitionTime: metav1.NewTime(now.Time.Add(-1 * time.Duration(beforeSec) * time.Second)),
+					Status:             conditionStatus,
+				},
+			},
+		},
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/service/BUILD

@@ -0,0 +1,41 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/service",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/util/net/sets:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/service",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/util/net/sets:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/service/OWNERS

@@ -0,0 +1,4 @@
+reviewers:
+- justinsb
+- freehan
+- david-mcmahon

vendor/k8s.io/kubernetes/pkg/api/service/util.go

@@ -0,0 +1,85 @@
+/*
+Copyright 2016 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 service
+
+import (
+	"fmt"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	netsets "k8s.io/kubernetes/pkg/util/net/sets"
+	"strings"
+)
+
+const (
+	defaultLoadBalancerSourceRanges = "0.0.0.0/0"
+)
+
+// IsAllowAll checks whether the netsets.IPNet allows traffic from 0.0.0.0/0
+func IsAllowAll(ipnets netsets.IPNet) bool {
+	for _, s := range ipnets.StringSlice() {
+		if s == "0.0.0.0/0" {
+			return true
+		}
+	}
+	return false
+}
+
+// GetLoadBalancerSourceRanges first try to parse and verify LoadBalancerSourceRanges field from a service.
+// If the field is not specified, turn to parse and verify the AnnotationLoadBalancerSourceRangesKey annotation from a service,
+// extracting the source ranges to allow, and if not present returns a default (allow-all) value.
+func GetLoadBalancerSourceRanges(service *api.Service) (netsets.IPNet, error) {
+	var ipnets netsets.IPNet
+	var err error
+	// if SourceRange field is specified, ignore sourceRange annotation
+	if len(service.Spec.LoadBalancerSourceRanges) > 0 {
+		specs := service.Spec.LoadBalancerSourceRanges
+		ipnets, err = netsets.ParseIPNets(specs...)
+
+		if err != nil {
+			return nil, fmt.Errorf("service.Spec.LoadBalancerSourceRanges: %v is not valid. Expecting a list of IP ranges. For example, 10.0.0.0/24. Error msg: %v", specs, err)
+		}
+	} else {
+		val := service.Annotations[api.AnnotationLoadBalancerSourceRangesKey]
+		val = strings.TrimSpace(val)
+		if val == "" {
+			val = defaultLoadBalancerSourceRanges
+		}
+		specs := strings.Split(val, ",")
+		ipnets, err = netsets.ParseIPNets(specs...)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %s is not valid. Expecting a comma-separated list of source IP ranges. For example, 10.0.0.0/24,192.168.2.0/24", api.AnnotationLoadBalancerSourceRangesKey, val)
+		}
+	}
+	return ipnets, nil
+}
+
+// RequestsOnlyLocalTraffic checks if service requests OnlyLocal traffic.
+func RequestsOnlyLocalTraffic(service *api.Service) bool {
+	if service.Spec.Type != api.ServiceTypeLoadBalancer &&
+		service.Spec.Type != api.ServiceTypeNodePort {
+		return false
+	}
+
+	return service.Spec.ExternalTrafficPolicy == api.ServiceExternalTrafficPolicyTypeLocal
+}
+
+// NeedsHealthCheck checks if service needs health check.
+func NeedsHealthCheck(service *api.Service) bool {
+	if service.Spec.Type != api.ServiceTypeLoadBalancer {
+		return false
+	}
+	return RequestsOnlyLocalTraffic(service)
+}

vendor/k8s.io/kubernetes/pkg/api/service/util_test.go

@@ -0,0 +1,216 @@
+/*
+Copyright 2016 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 service
+
+import (
+	"strings"
+	"testing"
+
+	api "k8s.io/kubernetes/pkg/apis/core"
+	netsets "k8s.io/kubernetes/pkg/util/net/sets"
+)
+
+func TestGetLoadBalancerSourceRanges(t *testing.T) {
+	checkError := func(v string) {
+		annotations := make(map[string]string)
+		annotations[api.AnnotationLoadBalancerSourceRangesKey] = v
+		svc := api.Service{}
+		svc.Annotations = annotations
+		_, err := GetLoadBalancerSourceRanges(&svc)
+		if err == nil {
+			t.Errorf("Expected error parsing: %q", v)
+		}
+		svc = api.Service{}
+		svc.Spec.LoadBalancerSourceRanges = strings.Split(v, ",")
+		_, err = GetLoadBalancerSourceRanges(&svc)
+		if err == nil {
+			t.Errorf("Expected error parsing: %q", v)
+		}
+	}
+	checkError("10.0.0.1/33")
+	checkError("foo.bar")
+	checkError("10.0.0.1/32,*")
+	checkError("10.0.0.1/32,")
+	checkError("10.0.0.1/32, ")
+	checkError("10.0.0.1")
+
+	checkOK := func(v string) netsets.IPNet {
+		annotations := make(map[string]string)
+		annotations[api.AnnotationLoadBalancerSourceRangesKey] = v
+		svc := api.Service{}
+		svc.Annotations = annotations
+		cidrs, err := GetLoadBalancerSourceRanges(&svc)
+		if err != nil {
+			t.Errorf("Unexpected error parsing: %q", v)
+		}
+		svc = api.Service{}
+		svc.Spec.LoadBalancerSourceRanges = strings.Split(v, ",")
+		cidrs, err = GetLoadBalancerSourceRanges(&svc)
+		if err != nil {
+			t.Errorf("Unexpected error parsing: %q", v)
+		}
+		return cidrs
+	}
+	cidrs := checkOK("192.168.0.1/32")
+	if len(cidrs) != 1 {
+		t.Errorf("Expected exactly one CIDR: %v", cidrs.StringSlice())
+	}
+	cidrs = checkOK("192.168.0.1/32,192.168.0.1/32")
+	if len(cidrs) != 1 {
+		t.Errorf("Expected exactly one CIDR (after de-dup): %v", cidrs.StringSlice())
+	}
+	cidrs = checkOK("192.168.0.1/32,192.168.0.2/32")
+	if len(cidrs) != 2 {
+		t.Errorf("Expected two CIDRs: %v", cidrs.StringSlice())
+	}
+	cidrs = checkOK("  192.168.0.1/32 , 192.168.0.2/32   ")
+	if len(cidrs) != 2 {
+		t.Errorf("Expected two CIDRs: %v", cidrs.StringSlice())
+	}
+	// check LoadBalancerSourceRanges not specified
+	svc := api.Service{}
+	cidrs, err := GetLoadBalancerSourceRanges(&svc)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if len(cidrs) != 1 {
+		t.Errorf("Expected exactly one CIDR: %v", cidrs.StringSlice())
+	}
+	if !IsAllowAll(cidrs) {
+		t.Errorf("Expected default to be allow-all: %v", cidrs.StringSlice())
+	}
+	// check SourceRanges annotation is empty
+	annotations := make(map[string]string)
+	annotations[api.AnnotationLoadBalancerSourceRangesKey] = ""
+	svc = api.Service{}
+	svc.Annotations = annotations
+	cidrs, err = GetLoadBalancerSourceRanges(&svc)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if len(cidrs) != 1 {
+		t.Errorf("Expected exactly one CIDR: %v", cidrs.StringSlice())
+	}
+	if !IsAllowAll(cidrs) {
+		t.Errorf("Expected default to be allow-all: %v", cidrs.StringSlice())
+	}
+}
+
+func TestAllowAll(t *testing.T) {
+	checkAllowAll := func(allowAll bool, cidrs ...string) {
+		ipnets, err := netsets.ParseIPNets(cidrs...)
+		if err != nil {
+			t.Errorf("Unexpected error parsing cidrs: %v", cidrs)
+		}
+		if allowAll != IsAllowAll(ipnets) {
+			t.Errorf("IsAllowAll did not return expected value for %v", cidrs)
+		}
+	}
+	checkAllowAll(false, "10.0.0.1/32")
+	checkAllowAll(false, "10.0.0.1/32", "10.0.0.2/32")
+	checkAllowAll(false, "10.0.0.1/32", "10.0.0.1/32")
+
+	checkAllowAll(true, "0.0.0.0/0")
+	checkAllowAll(true, "192.168.0.0/0")
+	checkAllowAll(true, "192.168.0.1/32", "0.0.0.0/0")
+}
+
+func TestRequestsOnlyLocalTraffic(t *testing.T) {
+	checkRequestsOnlyLocalTraffic := func(requestsOnlyLocalTraffic bool, service *api.Service) {
+		res := RequestsOnlyLocalTraffic(service)
+		if res != requestsOnlyLocalTraffic {
+			t.Errorf("Expected requests OnlyLocal traffic = %v, got %v",
+				requestsOnlyLocalTraffic, res)
+		}
+	}
+
+	checkRequestsOnlyLocalTraffic(false, &api.Service{})
+	checkRequestsOnlyLocalTraffic(false, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeClusterIP,
+		},
+	})
+	checkRequestsOnlyLocalTraffic(false, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeNodePort,
+		},
+	})
+	checkRequestsOnlyLocalTraffic(false, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeNodePort,
+			ExternalTrafficPolicy: api.ServiceExternalTrafficPolicyTypeCluster,
+		},
+	})
+	checkRequestsOnlyLocalTraffic(true, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeNodePort,
+			ExternalTrafficPolicy: api.ServiceExternalTrafficPolicyTypeLocal,
+		},
+	})
+	checkRequestsOnlyLocalTraffic(false, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeLoadBalancer,
+			ExternalTrafficPolicy: api.ServiceExternalTrafficPolicyTypeCluster,
+		},
+	})
+	checkRequestsOnlyLocalTraffic(true, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeLoadBalancer,
+			ExternalTrafficPolicy: api.ServiceExternalTrafficPolicyTypeLocal,
+		},
+	})
+}
+
+func TestNeedsHealthCheck(t *testing.T) {
+	checkNeedsHealthCheck := func(needsHealthCheck bool, service *api.Service) {
+		res := NeedsHealthCheck(service)
+		if res != needsHealthCheck {
+			t.Errorf("Expected needs health check = %v, got %v",
+				needsHealthCheck, res)
+		}
+	}
+
+	checkNeedsHealthCheck(false, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeClusterIP,
+		},
+	})
+	checkNeedsHealthCheck(false, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeNodePort,
+			ExternalTrafficPolicy: api.ServiceExternalTrafficPolicyTypeCluster,
+		},
+	})
+	checkNeedsHealthCheck(false, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeNodePort,
+			ExternalTrafficPolicy: api.ServiceExternalTrafficPolicyTypeLocal,
+		},
+	})
+	checkNeedsHealthCheck(false, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeLoadBalancer,
+			ExternalTrafficPolicy: api.ServiceExternalTrafficPolicyTypeCluster,
+		},
+	})
+	checkNeedsHealthCheck(true, &api.Service{
+		Spec: api.ServiceSpec{
+			Type: api.ServiceTypeLoadBalancer,
+			ExternalTrafficPolicy: api.ServiceExternalTrafficPolicyTypeLocal,
+		},
+	})
+}

vendor/k8s.io/kubernetes/pkg/api/testapi/BUILD

@@ -0,0 +1,80 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["testapi.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/testapi",
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/apis/admission:go_default_library",
+        "//pkg/apis/admission/install:go_default_library",
+        "//pkg/apis/admissionregistration:go_default_library",
+        "//pkg/apis/admissionregistration/install:go_default_library",
+        "//pkg/apis/apps:go_default_library",
+        "//pkg/apis/apps/install:go_default_library",
+        "//pkg/apis/authentication/install:go_default_library",
+        "//pkg/apis/authorization:go_default_library",
+        "//pkg/apis/authorization/install:go_default_library",
+        "//pkg/apis/autoscaling:go_default_library",
+        "//pkg/apis/autoscaling/install:go_default_library",
+        "//pkg/apis/batch:go_default_library",
+        "//pkg/apis/batch/install:go_default_library",
+        "//pkg/apis/certificates:go_default_library",
+        "//pkg/apis/certificates/install:go_default_library",
+        "//pkg/apis/componentconfig/install:go_default_library",
+        "//pkg/apis/core:go_default_library",
+        "//pkg/apis/core/install:go_default_library",
+        "//pkg/apis/events:go_default_library",
+        "//pkg/apis/events/install:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/install:go_default_library",
+        "//pkg/apis/imagepolicy:go_default_library",
+        "//pkg/apis/imagepolicy/install:go_default_library",
+        "//pkg/apis/networking:go_default_library",
+        "//pkg/apis/networking/install:go_default_library",
+        "//pkg/apis/policy:go_default_library",
+        "//pkg/apis/policy/install:go_default_library",
+        "//pkg/apis/rbac:go_default_library",
+        "//pkg/apis/rbac/install:go_default_library",
+        "//pkg/apis/scheduling:go_default_library",
+        "//pkg/apis/scheduling/install:go_default_library",
+        "//pkg/apis/settings:go_default_library",
+        "//pkg/apis/settings/install:go_default_library",
+        "//pkg/apis/storage:go_default_library",
+        "//pkg/apis/storage/install:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta: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/runtime/serializer/recognizer:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["testapi_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/testapi",
+    library = ":go_default_library",
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/testapi/OWNERS

@@ -0,0 +1,20 @@
+reviewers:
+- thockin
+- lavalamp
+- smarterclayton
+- wojtek-t
+- deads2k
+- caesarxuchao
+- mikedanese
+- liggitt
+- nikhiljindal
+- erictune
+- tallclair
+- eparis
+- soltysh
+- madhusudancs
+- markturansky
+- mml
+- david-mcmahon
+- ericchiang
+- jianhuiz

vendor/k8s.io/kubernetes/pkg/api/testapi/testapi.go

@@ -0,0 +1,543 @@
+/*
+Copyright 2014 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 testapi provides a helper for retrieving the KUBE_TEST_API environment variable.
+//
+// TODO(lavalamp): this package is a huge disaster at the moment. I intend to
+// refactor. All code currently using this package should change:
+// 1. Declare your own api.Registry.APIGroupRegistrationManager in your own test code.
+// 2. Import the relevant install packages.
+// 3. Register the types you need, from the announced.APIGroupAnnouncementManager.
+package testapi
+
+import (
+	"fmt"
+	"mime"
+	"os"
+	"reflect"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer/recognizer"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/apis/admission"
+	"k8s.io/kubernetes/pkg/apis/admissionregistration"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	"k8s.io/kubernetes/pkg/apis/authorization"
+	"k8s.io/kubernetes/pkg/apis/autoscaling"
+	"k8s.io/kubernetes/pkg/apis/batch"
+	"k8s.io/kubernetes/pkg/apis/certificates"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/events"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/apis/imagepolicy"
+	"k8s.io/kubernetes/pkg/apis/networking"
+	"k8s.io/kubernetes/pkg/apis/policy"
+	"k8s.io/kubernetes/pkg/apis/rbac"
+	"k8s.io/kubernetes/pkg/apis/scheduling"
+	"k8s.io/kubernetes/pkg/apis/settings"
+	"k8s.io/kubernetes/pkg/apis/storage"
+
+	_ "k8s.io/kubernetes/pkg/apis/admission/install"
+	_ "k8s.io/kubernetes/pkg/apis/admissionregistration/install"
+	_ "k8s.io/kubernetes/pkg/apis/apps/install"
+	_ "k8s.io/kubernetes/pkg/apis/authentication/install"
+	_ "k8s.io/kubernetes/pkg/apis/authorization/install"
+	_ "k8s.io/kubernetes/pkg/apis/autoscaling/install"
+	_ "k8s.io/kubernetes/pkg/apis/batch/install"
+	_ "k8s.io/kubernetes/pkg/apis/certificates/install"
+	_ "k8s.io/kubernetes/pkg/apis/componentconfig/install"
+	_ "k8s.io/kubernetes/pkg/apis/core/install"
+	_ "k8s.io/kubernetes/pkg/apis/events/install"
+	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
+	_ "k8s.io/kubernetes/pkg/apis/imagepolicy/install"
+	_ "k8s.io/kubernetes/pkg/apis/networking/install"
+	_ "k8s.io/kubernetes/pkg/apis/policy/install"
+	_ "k8s.io/kubernetes/pkg/apis/rbac/install"
+	_ "k8s.io/kubernetes/pkg/apis/scheduling/install"
+	_ "k8s.io/kubernetes/pkg/apis/settings/install"
+	_ "k8s.io/kubernetes/pkg/apis/storage/install"
+)
+
+var (
+	Groups        = make(map[string]TestGroup)
+	Default       TestGroup
+	Authorization TestGroup
+	Autoscaling   TestGroup
+	Batch         TestGroup
+	Extensions    TestGroup
+	Events        TestGroup
+	Apps          TestGroup
+	Policy        TestGroup
+	Rbac          TestGroup
+	Certificates  TestGroup
+	Scheduling    TestGroup
+	Settings      TestGroup
+	Storage       TestGroup
+	ImagePolicy   TestGroup
+	Admission     TestGroup
+	Networking    TestGroup
+
+	serializer        runtime.SerializerInfo
+	storageSerializer runtime.SerializerInfo
+)
+
+type TestGroup struct {
+	externalGroupVersion schema.GroupVersion
+	internalGroupVersion schema.GroupVersion
+	internalTypes        map[string]reflect.Type
+	externalTypes        map[string]reflect.Type
+}
+
+func init() {
+	if apiMediaType := os.Getenv("KUBE_TEST_API_TYPE"); len(apiMediaType) > 0 {
+		var ok bool
+		mediaType, _, err := mime.ParseMediaType(apiMediaType)
+		if err != nil {
+			panic(err)
+		}
+		serializer, ok = runtime.SerializerInfoForMediaType(legacyscheme.Codecs.SupportedMediaTypes(), mediaType)
+		if !ok {
+			panic(fmt.Sprintf("no serializer for %s", apiMediaType))
+		}
+	}
+
+	if storageMediaType := StorageMediaType(); len(storageMediaType) > 0 {
+		var ok bool
+		mediaType, _, err := mime.ParseMediaType(storageMediaType)
+		if err != nil {
+			panic(err)
+		}
+		storageSerializer, ok = runtime.SerializerInfoForMediaType(legacyscheme.Codecs.SupportedMediaTypes(), mediaType)
+		if !ok {
+			panic(fmt.Sprintf("no serializer for %s", storageMediaType))
+		}
+	}
+
+	kubeTestAPI := os.Getenv("KUBE_TEST_API")
+	if len(kubeTestAPI) != 0 {
+		// priority is "first in list preferred", so this has to run in reverse order
+		testGroupVersions := strings.Split(kubeTestAPI, ",")
+		for i := len(testGroupVersions) - 1; i >= 0; i-- {
+			gvString := testGroupVersions[i]
+			groupVersion, err := schema.ParseGroupVersion(gvString)
+			if err != nil {
+				panic(fmt.Sprintf("Error parsing groupversion %v: %v", gvString, err))
+			}
+
+			internalGroupVersion := schema.GroupVersion{Group: groupVersion.Group, Version: runtime.APIVersionInternal}
+			Groups[groupVersion.Group] = TestGroup{
+				externalGroupVersion: groupVersion,
+				internalGroupVersion: internalGroupVersion,
+				internalTypes:        legacyscheme.Scheme.KnownTypes(internalGroupVersion),
+				externalTypes:        legacyscheme.Scheme.KnownTypes(groupVersion),
+			}
+		}
+	}
+
+	if _, ok := Groups[api.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: api.GroupName, Version: legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersion.Version}
+		Groups[api.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: api.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(api.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[extensions.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: extensions.GroupName, Version: legacyscheme.Registry.GroupOrDie(extensions.GroupName).GroupVersion.Version}
+		Groups[extensions.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: extensions.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(extensions.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[autoscaling.GroupName]; !ok {
+		internalTypes := make(map[string]reflect.Type)
+		for k, t := range legacyscheme.Scheme.KnownTypes(extensions.SchemeGroupVersion) {
+			if k == "Scale" {
+				continue
+			}
+			internalTypes[k] = t
+		}
+		externalGroupVersion := schema.GroupVersion{Group: autoscaling.GroupName, Version: legacyscheme.Registry.GroupOrDie(autoscaling.GroupName).GroupVersion.Version}
+		Groups[autoscaling.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: extensions.SchemeGroupVersion,
+			internalTypes:        internalTypes,
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[autoscaling.GroupName+"IntraGroup"]; !ok {
+		internalTypes := make(map[string]reflect.Type)
+		for k, t := range legacyscheme.Scheme.KnownTypes(extensions.SchemeGroupVersion) {
+			if k == "Scale" {
+				internalTypes[k] = t
+				break
+			}
+		}
+		externalGroupVersion := schema.GroupVersion{Group: autoscaling.GroupName, Version: legacyscheme.Registry.GroupOrDie(autoscaling.GroupName).GroupVersion.Version}
+		Groups[autoscaling.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: autoscaling.SchemeGroupVersion,
+			internalTypes:        internalTypes,
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[batch.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: batch.GroupName, Version: legacyscheme.Registry.GroupOrDie(batch.GroupName).GroupVersion.Version}
+		Groups[batch.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: batch.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(batch.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[apps.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: apps.GroupName, Version: legacyscheme.Registry.GroupOrDie(apps.GroupName).GroupVersion.Version}
+		Groups[apps.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: apps.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(apps.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[policy.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: policy.GroupName, Version: legacyscheme.Registry.GroupOrDie(policy.GroupName).GroupVersion.Version}
+		Groups[policy.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: policy.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(policy.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[rbac.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: rbac.GroupName, Version: legacyscheme.Registry.GroupOrDie(rbac.GroupName).GroupVersion.Version}
+		Groups[rbac.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: rbac.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(rbac.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[scheduling.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: scheduling.GroupName, Version: legacyscheme.Registry.GroupOrDie(scheduling.GroupName).GroupVersion.Version}
+		Groups[scheduling.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: scheduling.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(scheduling.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[settings.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: settings.GroupName, Version: legacyscheme.Registry.GroupOrDie(settings.GroupName).GroupVersion.Version}
+		Groups[settings.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: settings.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(settings.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[storage.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: storage.GroupName, Version: legacyscheme.Registry.GroupOrDie(storage.GroupName).GroupVersion.Version}
+		Groups[storage.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: storage.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(storage.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[certificates.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: certificates.GroupName, Version: legacyscheme.Registry.GroupOrDie(certificates.GroupName).GroupVersion.Version}
+		Groups[certificates.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: certificates.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(certificates.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[imagepolicy.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: imagepolicy.GroupName, Version: legacyscheme.Registry.GroupOrDie(imagepolicy.GroupName).GroupVersion.Version}
+		Groups[imagepolicy.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: imagepolicy.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(imagepolicy.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[authorization.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: authorization.GroupName, Version: legacyscheme.Registry.GroupOrDie(authorization.GroupName).GroupVersion.Version}
+		Groups[authorization.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: authorization.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(authorization.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[admissionregistration.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: admissionregistration.GroupName, Version: legacyscheme.Registry.GroupOrDie(admissionregistration.GroupName).GroupVersion.Version}
+		Groups[admissionregistration.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: admissionregistration.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(admissionregistration.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[admission.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: admission.GroupName, Version: legacyscheme.Registry.GroupOrDie(admission.GroupName).GroupVersion.Version}
+		Groups[admission.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: admission.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(admission.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[networking.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: networking.GroupName, Version: legacyscheme.Registry.GroupOrDie(networking.GroupName).GroupVersion.Version}
+		Groups[networking.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: networking.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(networking.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+	if _, ok := Groups[events.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: events.GroupName, Version: legacyscheme.Registry.GroupOrDie(events.GroupName).GroupVersion.Version}
+		Groups[events.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: events.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(events.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+
+	Default = Groups[api.GroupName]
+	Autoscaling = Groups[autoscaling.GroupName]
+	Batch = Groups[batch.GroupName]
+	Apps = Groups[apps.GroupName]
+	Policy = Groups[policy.GroupName]
+	Certificates = Groups[certificates.GroupName]
+	Extensions = Groups[extensions.GroupName]
+	Events = Groups[events.GroupName]
+	Rbac = Groups[rbac.GroupName]
+	Scheduling = Groups[scheduling.GroupName]
+	Settings = Groups[settings.GroupName]
+	Storage = Groups[storage.GroupName]
+	ImagePolicy = Groups[imagepolicy.GroupName]
+	Authorization = Groups[authorization.GroupName]
+	Admission = Groups[admission.GroupName]
+	Networking = Groups[networking.GroupName]
+}
+
+func (g TestGroup) ContentConfig() (string, *schema.GroupVersion, runtime.Codec) {
+	return "application/json", g.GroupVersion(), g.Codec()
+}
+
+func (g TestGroup) GroupVersion() *schema.GroupVersion {
+	copyOfGroupVersion := g.externalGroupVersion
+	return &copyOfGroupVersion
+}
+
+// InternalGroupVersion returns the group,version used to identify the internal
+// types for this API
+func (g TestGroup) InternalGroupVersion() schema.GroupVersion {
+	return g.internalGroupVersion
+}
+
+// InternalTypes returns a map of internal API types' kind names to their Go types.
+func (g TestGroup) InternalTypes() map[string]reflect.Type {
+	return g.internalTypes
+}
+
+// ExternalTypes returns a map of external API types' kind names to their Go types.
+func (g TestGroup) ExternalTypes() map[string]reflect.Type {
+	return g.externalTypes
+}
+
+// Codec returns the codec for the API version to test against, as set by the
+// KUBE_TEST_API_TYPE env var.
+func (g TestGroup) Codec() runtime.Codec {
+	if serializer.Serializer == nil {
+		return legacyscheme.Codecs.LegacyCodec(g.externalGroupVersion)
+	}
+	return legacyscheme.Codecs.CodecForVersions(serializer.Serializer, legacyscheme.Codecs.UniversalDeserializer(), schema.GroupVersions{g.externalGroupVersion}, nil)
+}
+
+// NegotiatedSerializer returns the negotiated serializer for the server.
+func (g TestGroup) NegotiatedSerializer() runtime.NegotiatedSerializer {
+	return legacyscheme.Codecs
+}
+
+func StorageMediaType() string {
+	return os.Getenv("KUBE_TEST_API_STORAGE_TYPE")
+}
+
+// StorageCodec returns the codec for the API version to store in etcd, as set by the
+// KUBE_TEST_API_STORAGE_TYPE env var.
+func (g TestGroup) StorageCodec() runtime.Codec {
+	s := storageSerializer.Serializer
+
+	if s == nil {
+		return legacyscheme.Codecs.LegacyCodec(g.externalGroupVersion)
+	}
+
+	// etcd2 only supports string data - we must wrap any result before returning
+	// TODO: remove for etcd3 / make parameterizable
+	if !storageSerializer.EncodesAsText {
+		s = runtime.NewBase64Serializer(s, s)
+	}
+	ds := recognizer.NewDecoder(s, legacyscheme.Codecs.UniversalDeserializer())
+
+	return legacyscheme.Codecs.CodecForVersions(s, ds, schema.GroupVersions{g.externalGroupVersion}, nil)
+}
+
+// Converter returns the legacyscheme.Scheme for the API version to test against, as set by the
+// KUBE_TEST_API env var.
+func (g TestGroup) Converter() runtime.ObjectConvertor {
+	interfaces, err := legacyscheme.Registry.GroupOrDie(g.externalGroupVersion.Group).InterfacesFor(g.externalGroupVersion)
+	if err != nil {
+		panic(err)
+	}
+	return interfaces.ObjectConvertor
+}
+
+// MetadataAccessor returns the MetadataAccessor for the API version to test against,
+// as set by the KUBE_TEST_API env var.
+func (g TestGroup) MetadataAccessor() meta.MetadataAccessor {
+	interfaces, err := legacyscheme.Registry.GroupOrDie(g.externalGroupVersion.Group).InterfacesFor(g.externalGroupVersion)
+	if err != nil {
+		panic(err)
+	}
+	return interfaces.MetadataAccessor
+}
+
+// SelfLink returns a self link that will appear to be for the version Version().
+// 'resource' should be the resource path, e.g. "pods" for the Pod type. 'name' should be
+// empty for lists.
+func (g TestGroup) SelfLink(resource, name string) string {
+	if g.externalGroupVersion.Group == api.GroupName {
+		if name == "" {
+			return fmt.Sprintf("/api/%s/%s", g.externalGroupVersion.Version, resource)
+		}
+		return fmt.Sprintf("/api/%s/%s/%s", g.externalGroupVersion.Version, resource, name)
+	} else {
+		// TODO: will need a /apis prefix once we have proper multi-group
+		// support
+		if name == "" {
+			return fmt.Sprintf("/apis/%s/%s/%s", g.externalGroupVersion.Group, g.externalGroupVersion.Version, resource)
+		}
+		return fmt.Sprintf("/apis/%s/%s/%s/%s", g.externalGroupVersion.Group, g.externalGroupVersion.Version, resource, name)
+	}
+}
+
+// ResourcePathWithPrefix returns the appropriate path for the given prefix (watch, proxy, redirect, etc), resource, namespace and name.
+// For ex, this is of the form:
+// /api/v1/watch/namespaces/foo/pods/pod0 for v1.
+func (g TestGroup) ResourcePathWithPrefix(prefix, resource, namespace, name string) string {
+	var path string
+	if g.externalGroupVersion.Group == api.GroupName {
+		path = "/api/" + g.externalGroupVersion.Version
+	} else {
+		// TODO: switch back once we have proper multiple group support
+		// path = "/apis/" + g.Group + "/" + Version(group...)
+		path = "/apis/" + g.externalGroupVersion.Group + "/" + g.externalGroupVersion.Version
+	}
+
+	if prefix != "" {
+		path = path + "/" + prefix
+	}
+	if namespace != "" {
+		path = path + "/namespaces/" + namespace
+	}
+	// Resource names are lower case.
+	resource = strings.ToLower(resource)
+	if resource != "" {
+		path = path + "/" + resource
+	}
+	if name != "" {
+		path = path + "/" + name
+	}
+	return path
+}
+
+// ResourcePath returns the appropriate path for the given resource, namespace and name.
+// For example, this is of the form:
+// /api/v1/namespaces/foo/pods/pod0 for v1.
+func (g TestGroup) ResourcePath(resource, namespace, name string) string {
+	return g.ResourcePathWithPrefix("", resource, namespace, name)
+}
+
+// SubResourcePath returns the appropriate path for the given resource, namespace,
+// name and subresource.
+func (g TestGroup) SubResourcePath(resource, namespace, name, sub string) string {
+	path := g.ResourcePathWithPrefix("", resource, namespace, name)
+	if sub != "" {
+		path = path + "/" + sub
+	}
+
+	return path
+}
+
+// RESTMapper returns RESTMapper in legacyscheme.Registry.
+func (g TestGroup) RESTMapper() meta.RESTMapper {
+	return legacyscheme.Registry.RESTMapper()
+}
+
+// ExternalGroupVersions returns all external group versions allowed for the server.
+func ExternalGroupVersions() schema.GroupVersions {
+	versions := []schema.GroupVersion{}
+	for _, g := range Groups {
+		gv := g.GroupVersion()
+		versions = append(versions, *gv)
+	}
+	return versions
+}
+
+// GetCodecForObject gets codec based on runtime.Object
+func GetCodecForObject(obj runtime.Object) (runtime.Codec, error) {
+	kinds, _, err := legacyscheme.Scheme.ObjectKinds(obj)
+	if err != nil {
+		return nil, fmt.Errorf("unexpected encoding error: %v", err)
+	}
+	kind := kinds[0]
+
+	for _, group := range Groups {
+		if group.GroupVersion().Group != kind.Group {
+			continue
+		}
+
+		if legacyscheme.Scheme.Recognizes(kind) {
+			return group.Codec(), nil
+		}
+	}
+	// Codec used for unversioned types
+	if legacyscheme.Scheme.Recognizes(kind) {
+		serializer, ok := runtime.SerializerInfoForMediaType(legacyscheme.Codecs.SupportedMediaTypes(), runtime.ContentTypeJSON)
+		if !ok {
+			return nil, fmt.Errorf("no serializer registered for json")
+		}
+		return serializer.Serializer, nil
+	}
+	return nil, fmt.Errorf("unexpected kind: %v", kind)
+}
+
+// NewTestGroup creates a new TestGroup.
+func NewTestGroup(external, internal schema.GroupVersion, internalTypes map[string]reflect.Type, externalTypes map[string]reflect.Type) TestGroup {
+	return TestGroup{external, internal, internalTypes, externalTypes}
+}

vendor/k8s.io/kubernetes/pkg/api/testapi/testapi_test.go

@@ -0,0 +1,167 @@
+/*
+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 testapi
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+// TODO these tests don't add much value for testing things that have groups
+
+func TestResourcePathWithPrefix(t *testing.T) {
+	testCases := []struct {
+		prefix    string
+		resource  string
+		namespace string
+		name      string
+		expected  string
+	}{
+		{"prefix", "resource", "mynamespace", "myresource", "/api/" + Default.GroupVersion().Version + "/prefix/namespaces/mynamespace/resource/myresource"},
+		{"prefix", "resource", "", "myresource", "/api/" + Default.GroupVersion().Version + "/prefix/resource/myresource"},
+		{"prefix", "resource", "mynamespace", "", "/api/" + Default.GroupVersion().Version + "/prefix/namespaces/mynamespace/resource"},
+		{"prefix", "resource", "", "", "/api/" + Default.GroupVersion().Version + "/prefix/resource"},
+		{"", "resource", "mynamespace", "myresource", "/api/" + Default.GroupVersion().Version + "/namespaces/mynamespace/resource/myresource"},
+	}
+	for _, item := range testCases {
+		if actual := Default.ResourcePathWithPrefix(item.prefix, item.resource, item.namespace, item.name); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for prefix: %s, resource: %s, namespace: %s and name: %s", item.expected, actual, item.prefix, item.resource, item.namespace, item.name)
+		}
+	}
+}
+
+func TestResourcePath(t *testing.T) {
+	testCases := []struct {
+		resource  string
+		namespace string
+		name      string
+		expected  string
+	}{
+		{"resource", "mynamespace", "myresource", "/api/" + Default.GroupVersion().Version + "/namespaces/mynamespace/resource/myresource"},
+		{"resource", "", "myresource", "/api/" + Default.GroupVersion().Version + "/resource/myresource"},
+		{"resource", "mynamespace", "", "/api/" + Default.GroupVersion().Version + "/namespaces/mynamespace/resource"},
+		{"resource", "", "", "/api/" + Default.GroupVersion().Version + "/resource"},
+	}
+	for _, item := range testCases {
+		if actual := Default.ResourcePath(item.resource, item.namespace, item.name); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for resource: %s, namespace: %s and name: %s", item.expected, actual, item.resource, item.namespace, item.name)
+		}
+	}
+}
+
+var status = &metav1.Status{
+	Status:  metav1.StatusFailure,
+	Code:    200,
+	Reason:  metav1.StatusReasonUnknown,
+	Message: "",
+}
+
+func TestSelfLink(t *testing.T) {
+	testCases := []struct {
+		resource string
+		name     string
+		expected string
+	}{
+		{"resource", "name", "/api/" + Default.GroupVersion().Version + "/resource/name"},
+		{"resource", "", "/api/" + Default.GroupVersion().Version + "/resource"},
+	}
+	for _, item := range testCases {
+		if actual := Default.SelfLink(item.resource, item.name); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for resource: %s and name: %s", item.expected, actual, item.resource, item.name)
+		}
+	}
+
+	testGroupCases := []struct {
+		resource string
+		name     string
+		expected string
+	}{
+		{"resource", "name", "/apis/" + Admission.GroupVersion().Group + "/" + Admission.GroupVersion().Version + "/resource/name"},
+		{"resource", "", "/apis/" + Admission.GroupVersion().Group + "/" + Admission.GroupVersion().Version + "/resource"},
+	}
+	for _, item := range testGroupCases {
+		if actual := Admission.SelfLink(item.resource, item.name); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for resource: %s and name: %s", item.expected, actual, item.resource, item.name)
+		}
+	}
+}
+
+func TestV1EncodeDecodeStatus(t *testing.T) {
+	v1Codec := Default.Codec()
+
+	encoded, err := runtime.Encode(v1Codec, status)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	typeMeta := metav1.TypeMeta{}
+	if err := json.Unmarshal(encoded, &typeMeta); err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if typeMeta.Kind != "Status" {
+		t.Errorf("Kind is not set to \"Status\". Got %v", string(encoded))
+	}
+	if typeMeta.APIVersion != "v1" {
+		t.Errorf("APIVersion is not set to \"v1\". Got %v", string(encoded))
+	}
+	decoded, err := runtime.Decode(v1Codec, encoded)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(status, decoded) {
+		t.Errorf("expected: %#v, got: %#v", status, decoded)
+	}
+}
+
+func testEncodeDecodeStatus(t *testing.T, codec runtime.Codec) {
+	encoded, err := runtime.Encode(codec, status)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	typeMeta := metav1.TypeMeta{}
+	if err := json.Unmarshal(encoded, &typeMeta); err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if typeMeta.Kind != "Status" {
+		t.Errorf("Kind is not set to \"Status\". Got %s", encoded)
+	}
+	if typeMeta.APIVersion != "v1" {
+		t.Errorf("APIVersion is not set to \"\". Got %s", encoded)
+	}
+	decoded, err := runtime.Decode(codec, encoded)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(status, decoded) {
+		t.Errorf("expected: %v, got: %v", status, decoded)
+	}
+}
+
+func TestAutoscalingEncodeDecodeStatus(t *testing.T) {
+	testEncodeDecodeStatus(t, Autoscaling.Codec())
+}
+
+func TestBatchEncodeDecodeStatus(t *testing.T) {
+	testEncodeDecodeStatus(t, Batch.Codec())
+}
+
+func TestExperimentalEncodeDecodeStatus(t *testing.T) {
+	testEncodeDecodeStatus(t, Extensions.Codec())
+}

vendor/k8s.io/kubernetes/pkg/api/testing/.import-restrictions

@@ -0,0 +1,12 @@
+{
+	"Rules": [
+	  {
+		"SelectorRegexp": "k8s[.]io/kubernetes/cmd",
+		"AllowedPrefixes": [
+		    "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
+		],
+		"ForbiddenPrefixes": [
+		]
+	  }
+	]
+}

vendor/k8s.io/kubernetes/pkg/api/testing/BUILD

@@ -0,0 +1,111 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "conversion.go",
+        "doc.go",
+        "fuzzer.go",
+        "pod_specs.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/api/testing",
+    deps = [
+        "//cmd/kubeadm/app/apis/kubeadm/fuzzer:go_default_library",
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/apis/admissionregistration/fuzzer:go_default_library",
+        "//pkg/apis/apps/fuzzer:go_default_library",
+        "//pkg/apis/autoscaling/fuzzer:go_default_library",
+        "//pkg/apis/batch/fuzzer:go_default_library",
+        "//pkg/apis/certificates/fuzzer:go_default_library",
+        "//pkg/apis/core:go_default_library",
+        "//pkg/apis/core/fuzzer:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/fuzzer:go_default_library",
+        "//pkg/apis/extensions/v1beta1:go_default_library",
+        "//pkg/apis/networking/fuzzer:go_default_library",
+        "//pkg/apis/policy/fuzzer:go_default_library",
+        "//pkg/apis/rbac/fuzzer:go_default_library",
+        "//pkg/apis/storage/fuzzer:go_default_library",
+        "//vendor/github.com/google/gofuzz:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/testing:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/testing/fuzzer:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/fuzzer:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/fields:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/api/testing/compat:all-srcs",
+    ],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "backward_compatibility_test.go",
+        "conversion_test.go",
+        "copy_test.go",
+        "deep_copy_test.go",
+        "defaulting_test.go",
+        "meta_test.go",
+        "serialization_proto_test.go",
+        "serialization_test.go",
+        "unstructured_test.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/api/testing",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/api/testapi:go_default_library",
+        "//pkg/api/testing/compat:go_default_library",
+        "//pkg/apis/core:go_default_library",
+        "//pkg/apis/core/install:go_default_library",
+        "//pkg/apis/core/v1:go_default_library",
+        "//pkg/apis/core/validation:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/v1beta1:go_default_library",
+        "//vendor/github.com/gogo/protobuf/proto:go_default_library",
+        "//vendor/github.com/golang/protobuf/proto:go_default_library",
+        "//vendor/github.com/google/gofuzz:go_default_library",
+        "//vendor/github.com/json-iterator/go:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/equality:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/testing/fuzzer:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/testing/roundtrip:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured: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/runtime/serializer/protobuf:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer/streaming:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types: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/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/api/testing/OWNERS

@@ -0,0 +1,39 @@
+reviewers:
+- thockin
+- lavalamp
+- smarterclayton
+- wojtek-t
+- deads2k
+- yujuhong
+- brendandburns
+- derekwaynecarr
+- caesarxuchao
+- vishh
+- mikedanese
+- nikhiljindal
+- erictune
+- pmorie
+- dchen1107
+- saad-ali
+- zmerlynn
+- justinsb
+- pwittrock
+- roberthbailey
+- tallclair
+- yifan-gu
+- eparis
+- soltysh
+- jsafrane
+- madhusudancs
+- hongchaodeng
+- rootfs
+- jszczepkowski
+- markturansky
+- fgrzadkowski
+- aveshagarwal
+- david-mcmahon
+- pweil-
+- rata
+- feihujiang
+- sdminonne
+- ghodss

vendor/k8s.io/kubernetes/pkg/api/testing/backward_compatibility_test.go

@@ -0,0 +1,169 @@
+/*
+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 testing
+
+import (
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	"k8s.io/kubernetes/pkg/api/testing/compat"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/core/validation"
+
+	_ "k8s.io/kubernetes/pkg/apis/core/install"
+)
+
+func TestCompatibility_v1_PodSecurityContext(t *testing.T) {
+	cases := []struct {
+		name         string
+		input        string
+		expectedKeys map[string]string
+		absentKeys   []string
+	}{
+		{
+			name: "hostNetwork = true",
+			input: `
+{
+	"kind":"Pod",
+	"apiVersion":"v1",
+	"metadata":{"name":"my-pod-name", "namespace":"my-pod-namespace"},
+	"spec": {
+		"hostNetwork": true,
+		"containers":[{
+			"name":"a",
+			"image":"my-container-image"
+		}]
+	}
+}
+`,
+			expectedKeys: map[string]string{
+				"spec.hostNetwork": "true",
+			},
+		},
+		{
+			name: "hostNetwork = false",
+			input: `
+{
+	"kind":"Pod",
+	"apiVersion":"v1",
+	"metadata":{"name":"my-pod-name", "namespace":"my-pod-namespace"},
+	"spec": {
+		"hostNetwork": false,
+		"containers":[{
+			"name":"a",
+			"image":"my-container-image"
+		}]
+	}
+}
+`,
+			absentKeys: []string{
+				"spec.hostNetwork",
+			},
+		},
+		{
+			name: "hostIPC = true",
+			input: `
+{
+	"kind":"Pod",
+	"apiVersion":"v1",
+	"metadata":{"name":"my-pod-name", "namespace":"my-pod-namespace"},
+	"spec": {
+		"hostIPC": true,
+		"containers":[{
+			"name":"a",
+			"image":"my-container-image"
+		}]
+	}
+}
+`,
+			expectedKeys: map[string]string{
+				"spec.hostIPC": "true",
+			},
+		},
+		{
+			name: "hostIPC = false",
+			input: `
+{
+	"kind":"Pod",
+	"apiVersion":"v1",
+	"metadata":{"name":"my-pod-name", "namespace":"my-pod-namespace"},
+	"spec": {
+		"hostIPC": false,
+		"containers":[{
+			"name":"a",
+			"image":"my-container-image"
+		}]
+	}
+}
+`,
+			absentKeys: []string{
+				"spec.hostIPC",
+			},
+		},
+		{
+			name: "hostPID = true",
+			input: `
+{
+	"kind":"Pod",
+	"apiVersion":"v1",
+	"metadata":{"name":"my-pod-name", "namespace":"my-pod-namespace"},
+	"spec": {
+		"hostPID": true,
+		"containers":[{
+			"name":"a",
+			"image":"my-container-image"
+		}]
+	}
+}
+`,
+			expectedKeys: map[string]string{
+				"spec.hostPID": "true",
+			},
+		},
+		{
+			name: "hostPID = false",
+			input: `
+{
+	"kind":"Pod",
+	"apiVersion":"v1",
+	"metadata":{"name":"my-pod-name", "namespace":"my-pod-namespace"},
+	"spec": {
+		"hostPID": false,
+		"containers":[{
+			"name":"a",
+			"image":"my-container-image"
+		}]
+	}
+}
+`,
+			absentKeys: []string{
+				"spec.hostPID",
+			},
+		},
+	}
+
+	validator := func(obj runtime.Object) field.ErrorList {
+		return validation.ValidatePodSpec(&(obj.(*api.Pod).Spec), field.NewPath("spec"))
+	}
+
+	for _, tc := range cases {
+		t.Logf("Testing 1.0.0 backward compatibility for %v", tc.name)
+		compat.TestCompatibility(t, v1.SchemeGroupVersion, []byte(tc.input), validator, tc.expectedKeys, tc.absentKeys)
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/testing/compat/BUILD

@@ -0,0 +1,32 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["compatibility_tester.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/testing/compat",
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/printers: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/validation/field:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/testing/compat/compatibility_tester.go

@@ -0,0 +1,144 @@
+/*
+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 compat
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/printers"
+)
+
+// Based on: https://github.com/openshift/origin/blob/master/pkg/api/compatibility_test.go
+//
+// TestCompatibility reencodes the input using the codec for the given
+// version and checks for the presence of the expected keys and absent
+// keys in the resulting JSON.
+func TestCompatibility(
+	t *testing.T,
+	version schema.GroupVersion,
+	input []byte,
+	validator func(obj runtime.Object) field.ErrorList,
+	expectedKeys map[string]string,
+	absentKeys []string,
+) {
+
+	// Decode
+	codec := legacyscheme.Codecs.LegacyCodec(version)
+	obj, err := runtime.Decode(codec, input)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+
+	// Validate
+	errs := validator(obj)
+	if len(errs) != 0 {
+		t.Fatalf("Unexpected validation errors: %v", errs)
+	}
+
+	// Encode
+	output, err := runtime.Encode(codec, obj)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+
+	// Validate old and new fields are encoded
+	generic := map[string]interface{}{}
+	if err := json.Unmarshal(output, &generic); err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+
+	hasError := false
+	for k, expectedValue := range expectedKeys {
+		keys := strings.Split(k, ".")
+		if actualValue, ok, err := getJSONValue(generic, keys...); err != nil || !ok {
+			t.Errorf("Unexpected error for %s: %v", k, err)
+			hasError = true
+		} else if !reflect.DeepEqual(expectedValue, fmt.Sprintf("%v", actualValue)) {
+			hasError = true
+			t.Errorf("Unexpected value for %v: expected %v, got %v", k, expectedValue, actualValue)
+		}
+	}
+
+	for _, absentKey := range absentKeys {
+		keys := strings.Split(absentKey, ".")
+		actualValue, ok, err := getJSONValue(generic, keys...)
+		if err == nil || ok {
+			t.Errorf("Unexpected value found for key %s: %v", absentKey, actualValue)
+			hasError = true
+		}
+	}
+
+	if hasError {
+		printer := &printers.JSONPrinter{}
+		printer.PrintObj(obj, os.Stdout)
+		t.Logf("2: Encoded value: %#v", string(output))
+	}
+}
+
+func getJSONValue(data map[string]interface{}, keys ...string) (interface{}, bool, error) {
+	// No keys, current value is it
+	if len(keys) == 0 {
+		return data, true, nil
+	}
+
+	// Get the key (and optional index)
+	key := keys[0]
+	index := -1
+	if matches := regexp.MustCompile(`^(.*)\[(\d+)\]$`).FindStringSubmatch(key); len(matches) > 0 {
+		key = matches[1]
+		index, _ = strconv.Atoi(matches[2])
+	}
+
+	// Look up the value
+	value, ok := data[key]
+	if !ok {
+		return nil, false, fmt.Errorf("No key %s found", key)
+	}
+
+	// Get the indexed value if an index is specified
+	if index >= 0 {
+		valueSlice, ok := value.([]interface{})
+		if !ok {
+			return nil, false, fmt.Errorf("Key %s did not hold a slice", key)
+		}
+		if index >= len(valueSlice) {
+			return nil, false, fmt.Errorf("Index %d out of bounds for slice at key: %v", index, key)
+		}
+		value = valueSlice[index]
+	}
+
+	if len(keys) == 1 {
+		return value, true, nil
+	}
+
+	childData, ok := value.(map[string]interface{})
+	if !ok {
+		return nil, false, fmt.Errorf("Key %s did not hold a map", keys[0])
+	}
+	return getJSONValue(childData, keys[1:]...)
+}

vendor/k8s.io/kubernetes/pkg/api/testing/conversion.go

@@ -0,0 +1,72 @@
+/*
+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 testing
+
+import (
+	"testing"
+
+	"k8s.io/apimachinery/pkg/fields"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+)
+
+// TestSelectableFieldLabelConversions verifies that given resource have field
+// label conversion defined for each its selectable field.
+// fields contains selectable fields of the resource.
+// labelMap maps deprecated labels to their canonical names.
+func TestSelectableFieldLabelConversionsOfKind(t *testing.T, apiVersion string, kind string, fields fields.Set, labelMap map[string]string) {
+	badFieldLabels := []string{
+		"name",
+		".name",
+		"bad",
+		"metadata",
+		"foo.bar",
+	}
+
+	value := "value"
+
+	if len(fields) == 0 {
+		t.Logf("no selectable fields for kind %q, skipping", kind)
+	}
+	for label := range fields {
+		if label == "name" {
+			t.Logf("FIXME: \"name\" is deprecated by \"metadata.name\", it should be removed from selectable fields of kind=%s", kind)
+			continue
+		}
+		newLabel, newValue, err := legacyscheme.Scheme.ConvertFieldLabel(apiVersion, kind, label, value)
+		if err != nil {
+			t.Errorf("kind=%s label=%s: got unexpected error: %v", kind, label, err)
+		} else {
+			expectedLabel := label
+			if l, exists := labelMap[label]; exists {
+				expectedLabel = l
+			}
+			if newLabel != expectedLabel {
+				t.Errorf("kind=%s label=%s: got unexpected label name (%q != %q)", kind, label, newLabel, expectedLabel)
+			}
+			if newValue != value {
+				t.Errorf("kind=%s label=%s: got unexpected new value (%q != %q)", kind, label, newValue, value)
+			}
+		}
+	}
+
+	for _, label := range badFieldLabels {
+		_, _, err := legacyscheme.Scheme.ConvertFieldLabel(apiVersion, kind, label, "value")
+		if err == nil {
+			t.Errorf("kind=%s label=%s: got unexpected non-error", kind, label)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/testing/conversion_test.go

@@ -0,0 +1,117 @@
+/*
+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 testing
+
+import (
+	"io/ioutil"
+	"math/rand"
+	"testing"
+
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/api/testing/fuzzer"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/util/diff"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/api/testapi"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+func BenchmarkPodConversion(b *testing.B) {
+	apiObjectFuzzer := fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(benchmarkSeed), legacyscheme.Codecs)
+	items := make([]api.Pod, 4)
+	for i := range items {
+		apiObjectFuzzer.Fuzz(&items[i])
+		items[i].Spec.InitContainers = nil
+		items[i].Status.InitContainerStatuses = nil
+	}
+
+	// add a fixed item
+	items = append(items, benchmarkPod)
+	width := len(items)
+
+	scheme := legacyscheme.Scheme
+	for i := 0; i < b.N; i++ {
+		pod := &items[i%width]
+		versionedObj, err := scheme.UnsafeConvertToVersion(pod, legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersion)
+		if err != nil {
+			b.Fatalf("Conversion error: %v", err)
+		}
+		if _, err = scheme.UnsafeConvertToVersion(versionedObj, testapi.Default.InternalGroupVersion()); err != nil {
+			b.Fatalf("Conversion error: %v", err)
+		}
+	}
+}
+
+func BenchmarkNodeConversion(b *testing.B) {
+	data, err := ioutil.ReadFile("node_example.json")
+	if err != nil {
+		b.Fatalf("Unexpected error while reading file: %v", err)
+	}
+	var node api.Node
+	if err := runtime.DecodeInto(testapi.Default.Codec(), data, &node); err != nil {
+		b.Fatalf("Unexpected error decoding node: %v", err)
+	}
+
+	scheme := legacyscheme.Scheme
+	var result *api.Node
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		versionedObj, err := scheme.UnsafeConvertToVersion(&node, legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersion)
+		if err != nil {
+			b.Fatalf("Conversion error: %v", err)
+		}
+		obj, err := scheme.UnsafeConvertToVersion(versionedObj, testapi.Default.InternalGroupVersion())
+		if err != nil {
+			b.Fatalf("Conversion error: %v", err)
+		}
+		result = obj.(*api.Node)
+	}
+	b.StopTimer()
+	if !apiequality.Semantic.DeepDerivative(node, *result) {
+		b.Fatalf("Incorrect conversion: %s", diff.ObjectDiff(node, *result))
+	}
+}
+
+func BenchmarkReplicationControllerConversion(b *testing.B) {
+	data, err := ioutil.ReadFile("replication_controller_example.json")
+	if err != nil {
+		b.Fatalf("Unexpected error while reading file: %v", err)
+	}
+	var replicationController api.ReplicationController
+	if err := runtime.DecodeInto(testapi.Default.Codec(), data, &replicationController); err != nil {
+		b.Fatalf("Unexpected error decoding node: %v", err)
+	}
+
+	scheme := legacyscheme.Scheme
+	var result *api.ReplicationController
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		versionedObj, err := scheme.UnsafeConvertToVersion(&replicationController, legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersion)
+		if err != nil {
+			b.Fatalf("Conversion error: %v", err)
+		}
+		obj, err := scheme.UnsafeConvertToVersion(versionedObj, testapi.Default.InternalGroupVersion())
+		if err != nil {
+			b.Fatalf("Conversion error: %v", err)
+		}
+		result = obj.(*api.ReplicationController)
+	}
+	b.StopTimer()
+	if !apiequality.Semantic.DeepDerivative(replicationController, *result) {
+		b.Fatalf("Incorrect conversion: expected %v, got %v", replicationController, *result)
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/testing/copy_test.go

@@ -0,0 +1,87 @@
+/*
+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 testing
+
+import (
+	"bytes"
+	"math/rand"
+	"reflect"
+	"testing"
+
+	"github.com/google/gofuzz"
+
+	"k8s.io/apimachinery/pkg/api/testing/fuzzer"
+	"k8s.io/apimachinery/pkg/api/testing/roundtrip"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/diff"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/api/testapi"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+func TestDeepCopyApiObjects(t *testing.T) {
+	for i := 0; i < *roundtrip.FuzzIters; i++ {
+		for _, version := range []schema.GroupVersion{testapi.Default.InternalGroupVersion(), legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersion} {
+			f := fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(rand.Int63()), legacyscheme.Codecs)
+			for kind := range legacyscheme.Scheme.KnownTypes(version) {
+				doDeepCopyTest(t, version.WithKind(kind), f)
+			}
+		}
+	}
+}
+
+func doDeepCopyTest(t *testing.T, kind schema.GroupVersionKind, f *fuzz.Fuzzer) {
+	item, err := legacyscheme.Scheme.New(kind)
+	if err != nil {
+		t.Fatalf("Could not create a %v: %s", kind, err)
+	}
+	f.Fuzz(item)
+	itemCopy := item.DeepCopyObject()
+	if !reflect.DeepEqual(item, itemCopy) {
+		t.Errorf("\nexpected: %#v\n\ngot:      %#v\n\ndiff:      %v", item, itemCopy, diff.ObjectReflectDiff(item, itemCopy))
+	}
+
+	prefuzzData := &bytes.Buffer{}
+	if err := legacyscheme.Codecs.LegacyCodec(kind.GroupVersion()).Encode(item, prefuzzData); err != nil {
+		t.Errorf("Could not encode a %v: %s", kind, err)
+		return
+	}
+
+	// Refuzz the copy, which should have no effect on the original
+	f.Fuzz(itemCopy)
+
+	postfuzzData := &bytes.Buffer{}
+	if err := legacyscheme.Codecs.LegacyCodec(kind.GroupVersion()).Encode(item, postfuzzData); err != nil {
+		t.Errorf("Could not encode a %v: %s", kind, err)
+		return
+	}
+
+	if bytes.Compare(prefuzzData.Bytes(), postfuzzData.Bytes()) != 0 {
+		t.Log(diff.StringDiff(prefuzzData.String(), postfuzzData.String()))
+		t.Errorf("Fuzzing copy modified original of %#v", kind)
+		return
+	}
+}
+
+func TestDeepCopySingleType(t *testing.T) {
+	for i := 0; i < *roundtrip.FuzzIters; i++ {
+		for _, version := range []schema.GroupVersion{testapi.Default.InternalGroupVersion(), legacyscheme.Registry.GroupOrDie(api.GroupName).GroupVersion} {
+			f := fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(rand.Int63()), legacyscheme.Codecs)
+			doDeepCopyTest(t, version.WithKind("Pod"), f)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/testing/deep_copy_test.go

@@ -0,0 +1,177 @@
+/*
+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 testing
+
+import (
+	"io/ioutil"
+	"testing"
+	"time"
+
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/kubernetes/pkg/api/testapi"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+func parseTimeOrDie(ts string) metav1.Time {
+	t, err := time.Parse(time.RFC3339, ts)
+	if err != nil {
+		panic(err)
+	}
+	return metav1.Time{Time: t}
+}
+
+var benchmarkPod api.Pod = api.Pod{
+	TypeMeta: metav1.TypeMeta{
+		Kind:       "Pod",
+		APIVersion: "v1",
+	},
+	ObjectMeta: metav1.ObjectMeta{
+		Name:              "etcd-server-e2e-test-wojtekt-master",
+		Namespace:         "default",
+		SelfLink:          "/api/v1/namespaces/default/pods/etcd-server-e2e-test-wojtekt-master",
+		UID:               types.UID("a671734a-e8e5-11e4-8fde-42010af09327"),
+		ResourceVersion:   "22",
+		CreationTimestamp: parseTimeOrDie("2015-04-22T11:49:36Z"),
+	},
+	Spec: api.PodSpec{
+		Volumes: []api.Volume{
+			{
+				Name: "varetcd",
+				VolumeSource: api.VolumeSource{
+					HostPath: &api.HostPathVolumeSource{
+						Path: "/mnt/master-pd/var/etcd",
+					},
+				},
+			},
+		},
+		Containers: []api.Container{
+			{
+				Name:  "etcd-container",
+				Image: "gcr.io/google_containers/etcd:2.0.9",
+				Command: []string{
+					"/usr/local/bin/etcd",
+					"--addr",
+					"127.0.0.1:2379",
+					"--bind-addr",
+					"127.0.0.1:2379",
+					"--data-dir",
+					"/var/etcd/data",
+				},
+				Ports: []api.ContainerPort{
+					{
+						Name:          "serverport",
+						HostPort:      2380,
+						ContainerPort: 2380,
+						Protocol:      "TCP",
+					},
+					{
+						Name:          "clientport",
+						HostPort:      2379,
+						ContainerPort: 2379,
+						Protocol:      "TCP",
+					},
+				},
+				VolumeMounts: []api.VolumeMount{
+					{
+						Name:      "varetcd",
+						MountPath: "/var/etcd",
+					},
+				},
+				TerminationMessagePath: "/dev/termination-log",
+				ImagePullPolicy:        api.PullIfNotPresent,
+			},
+		},
+		RestartPolicy: api.RestartPolicyAlways,
+		DNSPolicy:     api.DNSClusterFirst,
+		NodeName:      "e2e-test-wojtekt-master",
+	},
+	Status: api.PodStatus{
+		Phase: api.PodRunning,
+		Conditions: []api.PodCondition{
+			{
+				Type:   api.PodReady,
+				Status: api.ConditionTrue,
+			},
+		},
+		ContainerStatuses: []api.ContainerStatus{
+			{
+				Name: "etcd-container",
+				State: api.ContainerState{
+					Running: &api.ContainerStateRunning{
+						StartedAt: parseTimeOrDie("2015-04-22T11:49:32Z"),
+					},
+				},
+				Ready:        true,
+				RestartCount: 0,
+				Image:        "gcr.io/google_containers/etcd:2.0.9",
+				ImageID:      "docker://b6b9a86dc06aa1361357ca1b105feba961f6a4145adca6c54e142c0be0fe87b0",
+				ContainerID:  "docker://3cbbf818f1addfc252957b4504f56ef2907a313fe6afc47fc75373674255d46d",
+			},
+		},
+	},
+}
+
+func BenchmarkPodCopy(b *testing.B) {
+	var result *api.Pod
+	for i := 0; i < b.N; i++ {
+		result = benchmarkPod.DeepCopy()
+	}
+	if !apiequality.Semantic.DeepEqual(benchmarkPod, *result) {
+		b.Fatalf("Incorrect copy: expected %v, got %v", benchmarkPod, *result)
+	}
+}
+
+func BenchmarkNodeCopy(b *testing.B) {
+	data, err := ioutil.ReadFile("node_example.json")
+	if err != nil {
+		b.Fatalf("Unexpected error while reading file: %v", err)
+	}
+	var node api.Node
+	if err := runtime.DecodeInto(testapi.Default.Codec(), data, &node); err != nil {
+		b.Fatalf("Unexpected error decoding node: %v", err)
+	}
+
+	var result *api.Node
+	for i := 0; i < b.N; i++ {
+		result = node.DeepCopy()
+	}
+	if !apiequality.Semantic.DeepEqual(node, *result) {
+		b.Fatalf("Incorrect copy: expected %v, got %v", node, *result)
+	}
+}
+
+func BenchmarkReplicationControllerCopy(b *testing.B) {
+	data, err := ioutil.ReadFile("replication_controller_example.json")
+	if err != nil {
+		b.Fatalf("Unexpected error while reading file: %v", err)
+	}
+	var replicationController api.ReplicationController
+	if err := runtime.DecodeInto(testapi.Default.Codec(), data, &replicationController); err != nil {
+		b.Fatalf("Unexpected error decoding node: %v", err)
+	}
+
+	var result *api.ReplicationController
+	for i := 0; i < b.N; i++ {
+		result = replicationController.DeepCopy()
+	}
+	if !apiequality.Semantic.DeepEqual(replicationController, *result) {
+		b.Fatalf("Incorrect copy: expected %v, got %v", replicationController, *result)
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/testing/defaulting_test.go

@@ -0,0 +1,233 @@
+/*
+Copyright 2016 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 testing
+
+import (
+	"math/rand"
+	"reflect"
+	"sort"
+	"testing"
+
+	fuzz "github.com/google/gofuzz"
+
+	apiv1 "k8s.io/api/core/v1"
+	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
+	roundtrip "k8s.io/apimachinery/pkg/api/testing/roundtrip"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/diff"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+)
+
+type orderedGroupVersionKinds []schema.GroupVersionKind
+
+func (o orderedGroupVersionKinds) Len() int      { return len(o) }
+func (o orderedGroupVersionKinds) Swap(i, j int) { o[i], o[j] = o[j], o[i] }
+func (o orderedGroupVersionKinds) Less(i, j int) bool {
+	return o[i].String() < o[j].String()
+}
+
+// TODO: add a reflexive test that verifies that all SetDefaults functions are registered
+func TestDefaulting(t *testing.T) {
+	// these are the known types with defaulters - you must add to this list if you add a top level defaulter
+	typesWithDefaulting := map[schema.GroupVersionKind]struct{}{
+		{Group: "", Version: "v1", Kind: "ConfigMap"}:                                             {},
+		{Group: "", Version: "v1", Kind: "ConfigMapList"}:                                         {},
+		{Group: "", Version: "v1", Kind: "Endpoints"}:                                             {},
+		{Group: "", Version: "v1", Kind: "EndpointsList"}:                                         {},
+		{Group: "", Version: "v1", Kind: "Namespace"}:                                             {},
+		{Group: "", Version: "v1", Kind: "NamespaceList"}:                                         {},
+		{Group: "", Version: "v1", Kind: "Node"}:                                                  {},
+		{Group: "", Version: "v1", Kind: "NodeList"}:                                              {},
+		{Group: "", Version: "v1", Kind: "PersistentVolume"}:                                      {},
+		{Group: "", Version: "v1", Kind: "PersistentVolumeList"}:                                  {},
+		{Group: "", Version: "v1", Kind: "PersistentVolumeClaim"}:                                 {},
+		{Group: "", Version: "v1", Kind: "PersistentVolumeClaimList"}:                             {},
+		{Group: "", Version: "v1", Kind: "Pod"}:                                                   {},
+		{Group: "", Version: "v1", Kind: "PodList"}:                                               {},
+		{Group: "", Version: "v1", Kind: "PodTemplate"}:                                           {},
+		{Group: "", Version: "v1", Kind: "PodTemplateList"}:                                       {},
+		{Group: "", Version: "v1", Kind: "ReplicationController"}:                                 {},
+		{Group: "", Version: "v1", Kind: "ReplicationControllerList"}:                             {},
+		{Group: "", Version: "v1", Kind: "Secret"}:                                                {},
+		{Group: "", Version: "v1", Kind: "SecretList"}:                                            {},
+		{Group: "", Version: "v1", Kind: "Service"}:                                               {},
+		{Group: "", Version: "v1", Kind: "ServiceList"}:                                           {},
+		{Group: "apps", Version: "v1beta1", Kind: "StatefulSet"}:                                  {},
+		{Group: "apps", Version: "v1beta1", Kind: "StatefulSetList"}:                              {},
+		{Group: "apps", Version: "v1beta2", Kind: "StatefulSet"}:                                  {},
+		{Group: "apps", Version: "v1beta2", Kind: "StatefulSetList"}:                              {},
+		{Group: "apps", Version: "v1", Kind: "StatefulSet"}:                                       {},
+		{Group: "apps", Version: "v1", Kind: "StatefulSetList"}:                                   {},
+		{Group: "autoscaling", Version: "v1", Kind: "HorizontalPodAutoscaler"}:                    {},
+		{Group: "autoscaling", Version: "v1", Kind: "HorizontalPodAutoscalerList"}:                {},
+		{Group: "autoscaling", Version: "v2beta1", Kind: "HorizontalPodAutoscaler"}:               {},
+		{Group: "autoscaling", Version: "v2beta1", Kind: "HorizontalPodAutoscalerList"}:           {},
+		{Group: "batch", Version: "v1", Kind: "Job"}:                                              {},
+		{Group: "batch", Version: "v1", Kind: "JobList"}:                                          {},
+		{Group: "batch", Version: "v1beta1", Kind: "CronJob"}:                                     {},
+		{Group: "batch", Version: "v1beta1", Kind: "CronJobList"}:                                 {},
+		{Group: "batch", Version: "v1beta1", Kind: "JobTemplate"}:                                 {},
+		{Group: "batch", Version: "v2alpha1", Kind: "CronJob"}:                                    {},
+		{Group: "batch", Version: "v2alpha1", Kind: "CronJobList"}:                                {},
+		{Group: "batch", Version: "v2alpha1", Kind: "JobTemplate"}:                                {},
+		{Group: "certificates.k8s.io", Version: "v1beta1", Kind: "CertificateSigningRequest"}:     {},
+		{Group: "certificates.k8s.io", Version: "v1beta1", Kind: "CertificateSigningRequestList"}: {},
+		{Group: "componentconfig", Version: "v1alpha1", Kind: "KubeProxyConfiguration"}:           {},
+		{Group: "componentconfig", Version: "v1alpha1", Kind: "KubeSchedulerConfiguration"}:       {},
+		{Group: "componentconfig", Version: "v1alpha1", Kind: "KubeletConfiguration"}:             {},
+		{Group: "kubeadm.k8s.io", Version: "v1alpha1", Kind: "MasterConfiguration"}:               {},
+		// This object contains only int fields which currently breaks the defaulting test because
+		// it's pretty stupid. Once we add non integer fields, we should uncomment this.
+		// {Group: "kubeadm.k8s.io", Version: "v1alpha1", Kind: "NodeConfiguration"}:                 {},
+		{Group: "extensions", Version: "v1beta1", Kind: "DaemonSet"}:                                            {},
+		{Group: "extensions", Version: "v1beta1", Kind: "DaemonSetList"}:                                        {},
+		{Group: "apps", Version: "v1beta2", Kind: "DaemonSet"}:                                                  {},
+		{Group: "apps", Version: "v1beta2", Kind: "DaemonSetList"}:                                              {},
+		{Group: "apps", Version: "v1", Kind: "DaemonSet"}:                                                       {},
+		{Group: "apps", Version: "v1", Kind: "DaemonSetList"}:                                                   {},
+		{Group: "extensions", Version: "v1beta1", Kind: "Deployment"}:                                           {},
+		{Group: "extensions", Version: "v1beta1", Kind: "DeploymentList"}:                                       {},
+		{Group: "apps", Version: "v1beta1", Kind: "Deployment"}:                                                 {},
+		{Group: "apps", Version: "v1beta1", Kind: "DeploymentList"}:                                             {},
+		{Group: "apps", Version: "v1beta2", Kind: "Deployment"}:                                                 {},
+		{Group: "apps", Version: "v1beta2", Kind: "DeploymentList"}:                                             {},
+		{Group: "apps", Version: "v1", Kind: "Deployment"}:                                                      {},
+		{Group: "apps", Version: "v1", Kind: "DeploymentList"}:                                                  {},
+		{Group: "extensions", Version: "v1beta1", Kind: "PodSecurityPolicy"}:                                    {},
+		{Group: "extensions", Version: "v1beta1", Kind: "PodSecurityPolicyList"}:                                {},
+		{Group: "apps", Version: "v1beta2", Kind: "ReplicaSet"}:                                                 {},
+		{Group: "apps", Version: "v1beta2", Kind: "ReplicaSetList"}:                                             {},
+		{Group: "apps", Version: "v1", Kind: "ReplicaSet"}:                                                      {},
+		{Group: "apps", Version: "v1", Kind: "ReplicaSetList"}:                                                  {},
+		{Group: "extensions", Version: "v1beta1", Kind: "ReplicaSet"}:                                           {},
+		{Group: "extensions", Version: "v1beta1", Kind: "ReplicaSetList"}:                                       {},
+		{Group: "extensions", Version: "v1beta1", Kind: "NetworkPolicy"}:                                        {},
+		{Group: "extensions", Version: "v1beta1", Kind: "NetworkPolicyList"}:                                    {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1alpha1", Kind: "ClusterRoleBinding"}:                   {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1alpha1", Kind: "ClusterRoleBindingList"}:               {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1alpha1", Kind: "RoleBinding"}:                          {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1alpha1", Kind: "RoleBindingList"}:                      {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1beta1", Kind: "ClusterRoleBinding"}:                    {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1beta1", Kind: "ClusterRoleBindingList"}:                {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1beta1", Kind: "RoleBinding"}:                           {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1beta1", Kind: "RoleBindingList"}:                       {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1", Kind: "ClusterRoleBinding"}:                         {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1", Kind: "ClusterRoleBindingList"}:                     {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1", Kind: "RoleBinding"}:                                {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1", Kind: "RoleBindingList"}:                            {},
+		{Group: "settings.k8s.io", Version: "v1alpha1", Kind: "PodPreset"}:                                      {},
+		{Group: "settings.k8s.io", Version: "v1alpha1", Kind: "PodPresetList"}:                                  {},
+		{Group: "admissionregistration.k8s.io", Version: "v1beta1", Kind: "ValidatingWebhookConfiguration"}:     {},
+		{Group: "admissionregistration.k8s.io", Version: "v1beta1", Kind: "ValidatingWebhookConfigurationList"}: {},
+		{Group: "admissionregistration.k8s.io", Version: "v1beta1", Kind: "MutatingWebhookConfiguration"}:       {},
+		{Group: "admissionregistration.k8s.io", Version: "v1beta1", Kind: "MutatingWebhookConfigurationList"}:   {},
+		{Group: "networking.k8s.io", Version: "v1", Kind: "NetworkPolicy"}:                                      {},
+		{Group: "networking.k8s.io", Version: "v1", Kind: "NetworkPolicyList"}:                                  {},
+		{Group: "storage.k8s.io", Version: "v1beta1", Kind: "StorageClass"}:                                     {},
+		{Group: "storage.k8s.io", Version: "v1beta1", Kind: "StorageClassList"}:                                 {},
+		{Group: "storage.k8s.io", Version: "v1", Kind: "StorageClass"}:                                          {},
+		{Group: "storage.k8s.io", Version: "v1", Kind: "StorageClassList"}:                                      {},
+	}
+
+	f := fuzz.New().NilChance(.5).NumElements(1, 1).RandSource(rand.NewSource(1))
+	f.Funcs(
+		func(s *runtime.RawExtension, c fuzz.Continue) {},
+		func(s *metav1.LabelSelector, c fuzz.Continue) {
+			c.FuzzNoCustom(s)
+			s.MatchExpressions = nil // need to fuzz this specially
+		},
+		func(s *apiv1.ListOptions, c fuzz.Continue) {
+			c.FuzzNoCustom(s)
+			s.LabelSelector = "" // need to fuzz requirement strings specially
+			s.FieldSelector = "" // need to fuzz requirement strings specially
+		},
+		func(s *extensionsv1beta1.ScaleStatus, c fuzz.Continue) {
+			c.FuzzNoCustom(s)
+			s.TargetSelector = "" // need to fuzz requirement strings specially
+		},
+	)
+
+	scheme := legacyscheme.Scheme
+	var testTypes orderedGroupVersionKinds
+	for gvk := range scheme.AllKnownTypes() {
+		if gvk.Version == runtime.APIVersionInternal {
+			continue
+		}
+		testTypes = append(testTypes, gvk)
+	}
+	sort.Sort(testTypes)
+
+	for _, gvk := range testTypes {
+		_, expectedChanged := typesWithDefaulting[gvk]
+		iter := 0
+		changedOnce := false
+		for {
+			if iter > *roundtrip.FuzzIters {
+				if !expectedChanged || changedOnce {
+					break
+				}
+				if iter > 300 {
+					t.Errorf("expected %s to trigger defaulting due to fuzzing", gvk)
+					break
+				}
+				// if we expected defaulting, continue looping until the fuzzer gives us one
+				// at worst, we will timeout
+			}
+			iter++
+
+			src, err := scheme.New(gvk)
+			if err != nil {
+				t.Fatal(err)
+			}
+			f.Fuzz(src)
+
+			src.GetObjectKind().SetGroupVersionKind(schema.GroupVersionKind{})
+
+			original := src.DeepCopyObject()
+
+			// get internal
+			withDefaults := src.DeepCopyObject()
+			scheme.Default(withDefaults.(runtime.Object))
+
+			if !reflect.DeepEqual(original, withDefaults) {
+				changedOnce = true
+				if !expectedChanged {
+					t.Errorf("{Group: \"%s\", Version: \"%s\", Kind: \"%s\"} did not expect defaults to be set - update expected or check defaulter registering: %s", gvk.Group, gvk.Version, gvk.Kind, diff.ObjectReflectDiff(original, withDefaults))
+				}
+			}
+		}
+	}
+}
+
+func BenchmarkPodDefaulting(b *testing.B) {
+	f := fuzz.New().NilChance(.5).NumElements(1, 1).RandSource(rand.NewSource(1))
+	items := make([]apiv1.Pod, 100)
+	for i := range items {
+		f.Fuzz(&items[i])
+	}
+
+	scheme := legacyscheme.Scheme
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		pod := &items[i%len(items)]
+
+		scheme.Default(pod)
+	}
+	b.StopTimer()
+}

vendor/k8s.io/kubernetes/pkg/api/testing/doc.go

@@ -0,0 +1,20 @@
+/*
+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 testing contains
+// - all generic API tests which depend on Kubernetes API types
+// - all cross-Kubernetes-API tests.
+package testing

vendor/k8s.io/kubernetes/pkg/api/testing/fuzzer.go

@@ -0,0 +1,107 @@
+/*
+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 testing
+
+import (
+	"fmt"
+
+	fuzz "github.com/google/gofuzz"
+
+	"k8s.io/api/core/v1"
+	apitesting "k8s.io/apimachinery/pkg/api/testing"
+	"k8s.io/apimachinery/pkg/api/testing/fuzzer"
+	genericfuzzer "k8s.io/apimachinery/pkg/apis/meta/fuzzer"
+	"k8s.io/apimachinery/pkg/runtime"
+	runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
+	kubeadmfuzzer "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/fuzzer"
+	admissionregistrationfuzzer "k8s.io/kubernetes/pkg/apis/admissionregistration/fuzzer"
+	appsfuzzer "k8s.io/kubernetes/pkg/apis/apps/fuzzer"
+	autoscalingfuzzer "k8s.io/kubernetes/pkg/apis/autoscaling/fuzzer"
+	batchfuzzer "k8s.io/kubernetes/pkg/apis/batch/fuzzer"
+	certificatesfuzzer "k8s.io/kubernetes/pkg/apis/certificates/fuzzer"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	corefuzzer "k8s.io/kubernetes/pkg/apis/core/fuzzer"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	extensionsfuzzer "k8s.io/kubernetes/pkg/apis/extensions/fuzzer"
+	extensionsv1beta1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
+	networkingfuzzer "k8s.io/kubernetes/pkg/apis/networking/fuzzer"
+	policyfuzzer "k8s.io/kubernetes/pkg/apis/policy/fuzzer"
+	rbacfuzzer "k8s.io/kubernetes/pkg/apis/rbac/fuzzer"
+	storagefuzzer "k8s.io/kubernetes/pkg/apis/storage/fuzzer"
+)
+
+// overrideGenericFuncs override some generic fuzzer funcs from k8s.io/apiserver in order to have more realistic
+// values in a Kubernetes context.
+func overrideGenericFuncs(codecs runtimeserializer.CodecFactory) []interface{} {
+	return []interface{}{
+		func(j *runtime.Object, c fuzz.Continue) {
+			// TODO: uncomment when round trip starts from a versioned object
+			if true { //c.RandBool() {
+				*j = &runtime.Unknown{
+					// We do not set TypeMeta here because it is not carried through a round trip
+					Raw:         []byte(`{"apiVersion":"unknown.group/unknown","kind":"Something","someKey":"someValue"}`),
+					ContentType: runtime.ContentTypeJSON,
+				}
+			} else {
+				types := []runtime.Object{&api.Pod{}, &api.ReplicationController{}}
+				t := types[c.Rand.Intn(len(types))]
+				c.Fuzz(t)
+				*j = t
+			}
+		},
+		func(r *runtime.RawExtension, c fuzz.Continue) {
+			// Pick an arbitrary type and fuzz it
+			types := []runtime.Object{&api.Pod{}, &extensions.Deployment{}, &api.Service{}}
+			obj := types[c.Rand.Intn(len(types))]
+			c.Fuzz(obj)
+
+			var codec runtime.Codec
+			switch obj.(type) {
+			case *extensions.Deployment:
+				codec = apitesting.TestCodec(codecs, extensionsv1beta1.SchemeGroupVersion)
+			default:
+				codec = apitesting.TestCodec(codecs, v1.SchemeGroupVersion)
+			}
+
+			// Convert the object to raw bytes
+			bytes, err := runtime.Encode(codec, obj)
+			if err != nil {
+				panic(fmt.Sprintf("Failed to encode object: %v", err))
+			}
+
+			// Set the bytes field on the RawExtension
+			r.Raw = bytes
+		},
+	}
+}
+
+var FuzzerFuncs = fuzzer.MergeFuzzerFuncs(
+	genericfuzzer.Funcs,
+	overrideGenericFuncs,
+	corefuzzer.Funcs,
+	extensionsfuzzer.Funcs,
+	appsfuzzer.Funcs,
+	batchfuzzer.Funcs,
+	autoscalingfuzzer.Funcs,
+	rbacfuzzer.Funcs,
+	kubeadmfuzzer.Funcs,
+	policyfuzzer.Funcs,
+	certificatesfuzzer.Funcs,
+	admissionregistrationfuzzer.Funcs,
+	storagefuzzer.Funcs,
+	networkingfuzzer.Funcs,
+)

vendor/k8s.io/kubernetes/pkg/api/testing/meta_test.go

@@ -0,0 +1,103 @@
+/*
+Copyright 2014 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 testing
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+)
+
+var _ metav1.Object = &metav1.ObjectMeta{}
+
+func TestAccessorImplementations(t *testing.T) {
+	for _, gv := range legacyscheme.Registry.EnabledVersions() {
+		internalGV := schema.GroupVersion{Group: gv.Group, Version: runtime.APIVersionInternal}
+		for _, gv := range []schema.GroupVersion{gv, internalGV} {
+			for kind, knownType := range legacyscheme.Scheme.KnownTypes(gv) {
+				value := reflect.New(knownType)
+				obj := value.Interface()
+				if _, ok := obj.(runtime.Object); !ok {
+					t.Errorf("%v (%v) does not implement runtime.Object", gv.WithKind(kind), knownType)
+				}
+				lm, isLM := obj.(meta.ListMetaAccessor)
+				om, isOM := obj.(metav1.ObjectMetaAccessor)
+				switch {
+				case isLM && isOM:
+					t.Errorf("%v (%v) implements ListMetaAccessor and ObjectMetaAccessor", gv.WithKind(kind), knownType)
+					continue
+				case isLM:
+					m := lm.GetListMeta()
+					if m == nil {
+						t.Errorf("%v (%v) returns nil ListMeta", gv.WithKind(kind), knownType)
+						continue
+					}
+					m.SetResourceVersion("102030")
+					if m.GetResourceVersion() != "102030" {
+						t.Errorf("%v (%v) did not preserve resource version", gv.WithKind(kind), knownType)
+						continue
+					}
+					m.SetSelfLink("102030")
+					if m.GetSelfLink() != "102030" {
+						t.Errorf("%v (%v) did not preserve self link", gv.WithKind(kind), knownType)
+						continue
+					}
+				case isOM:
+					m := om.GetObjectMeta()
+					if m == nil {
+						t.Errorf("%v (%v) returns nil ObjectMeta", gv.WithKind(kind), knownType)
+						continue
+					}
+					m.SetResourceVersion("102030")
+					if m.GetResourceVersion() != "102030" {
+						t.Errorf("%v (%v) did not preserve resource version", gv.WithKind(kind), knownType)
+						continue
+					}
+					m.SetSelfLink("102030")
+					if m.GetSelfLink() != "102030" {
+						t.Errorf("%v (%v) did not preserve self link", gv.WithKind(kind), knownType)
+						continue
+					}
+					labels := map[string]string{"a": "b"}
+					m.SetLabels(labels)
+					if !reflect.DeepEqual(m.GetLabels(), labels) {
+						t.Errorf("%v (%v) did not preserve labels", gv.WithKind(kind), knownType)
+						continue
+					}
+				default:
+					if _, ok := obj.(metav1.ListMetaAccessor); ok {
+						continue
+					}
+					if _, ok := value.Elem().Type().FieldByName("ObjectMeta"); ok {
+						t.Errorf("%v (%v) has ObjectMeta but does not implement ObjectMetaAccessor", gv.WithKind(kind), knownType)
+						continue
+					}
+					if _, ok := value.Elem().Type().FieldByName("ListMeta"); ok {
+						t.Errorf("%v (%v) has ListMeta but does not implement ListMetaAccessor", gv.WithKind(kind), knownType)
+						continue
+					}
+					t.Logf("%v (%v) does not implement ListMetaAccessor or ObjectMetaAccessor", gv.WithKind(kind), knownType)
+				}
+			}
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/testing/node_example.json

@@ -0,0 +1,49 @@
+{
+    "kind": "Node",
+    "apiVersion": "v1",
+    "metadata": {
+        "name": "e2e-test-wojtekt-node-etd6",
+        "selfLink": "/api/v1/nodes/e2e-test-wojtekt-node-etd6",
+        "uid": "a7e89222-e8e5-11e4-8fde-42010af09327",
+        "resourceVersion": "379",
+        "creationTimestamp": "2015-04-22T11:49:39Z"
+    },
+    "spec": {
+        "externalID": "15488322946290398375"
+    },
+    "status": {
+        "capacity": {
+            "cpu": "1",
+            "memory": "1745152Ki"
+        },
+        "conditions": [
+            {
+                "type": "Ready",
+                "status": "True",
+                "lastHeartbeatTime": "2015-04-22T11:58:17Z",
+                "lastTransitionTime": "2015-04-22T11:49:52Z",
+                "reason": "kubelet is posting ready status"
+            }
+        ],
+        "addresses": [
+            {
+                "type": "ExternalIP",
+                "address": "104.197.49.213"
+            },
+            {
+                "type": "LegacyHostIP",
+                "address": "104.197.20.11"
+            }
+        ],
+        "nodeInfo": {
+            "machineID": "",
+            "systemUUID": "D59FA3FA-7B5B-7287-5E1A-1D79F13CB577",
+            "bootID": "44a832f3-8cfb-4de5-b7d2-d66030b6cd95",
+            "kernelVersion": "3.16.0-0.bpo.4-amd64",
+            "osImage": "Debian GNU/Linux 7 (wheezy)",
+            "containerRuntimeVersion": "docker://1.5.0",
+            "kubeletVersion": "v0.15.0-484-g0c8ee980d705a3-dirty",
+            "kubeProxyVersion": "v0.15.0-484-g0c8ee980d705a3-dirty"
+        }
+    }
+}

vendor/k8s.io/kubernetes/pkg/api/testing/pod_specs.go

@@ -0,0 +1,45 @@
+/*
+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 testing
+
+import (
+	"k8s.io/api/core/v1"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+// DeepEqualSafePodSpec returns a PodSpec which is ready to be used with apiequality.Semantic.DeepEqual
+func DeepEqualSafePodSpec() api.PodSpec {
+	grace := int64(30)
+	return api.PodSpec{
+		RestartPolicy:                 api.RestartPolicyAlways,
+		DNSPolicy:                     api.DNSClusterFirst,
+		TerminationGracePeriodSeconds: &grace,
+		SecurityContext:               &api.PodSecurityContext{},
+		SchedulerName:                 api.DefaultSchedulerName,
+	}
+}
+
+// V1DeepEqualSafePodSpec returns a PodSpec which is ready to be used with apiequality.Semantic.DeepEqual
+func V1DeepEqualSafePodSpec() v1.PodSpec {
+	grace := int64(30)
+	return v1.PodSpec{
+		RestartPolicy:                 v1.RestartPolicyAlways,
+		DNSPolicy:                     v1.DNSClusterFirst,
+		TerminationGracePeriodSeconds: &grace,
+		SecurityContext:               &v1.PodSecurityContext{},
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/testing/replication_controller_example.json

@@ -0,0 +1,83 @@
+{
+    "kind": "ReplicationController",
+    "apiVersion": "v1",
+    "metadata": {
+        "name": "elasticsearch-logging-controller",
+        "namespace": "default",
+        "selfLink": "/api/v1/namespaces/default/replicationcontrollers/elasticsearch-logging-controller",
+        "uid": "aa76f162-e8e5-11e4-8fde-42010af09327",
+        "resourceVersion": "98",
+        "creationTimestamp": "2015-04-22T11:49:43Z",
+        "labels": {
+            "kubernetes.io/cluster-service": "true",
+            "name": "elasticsearch-logging"
+        }
+    },
+    "spec": {
+        "replicas": 1,
+        "selector": {
+            "name": "elasticsearch-logging"
+        },
+        "template": {
+            "metadata": {
+                "creationTimestamp": null,
+                "labels": {
+                    "kubernetes.io/cluster-service": "true",
+                    "name": "elasticsearch-logging"
+                }
+            },
+            "spec": {
+                "volumes": [
+                    {
+                        "name": "es-persistent-storage",
+                        "hostPath": null,
+                        "emptyDir": {
+                            "medium": ""
+                        },
+                        "gcePersistentDisk": null,
+                        "awsElasticBlockStore": null,
+                        "gitRepo": null,
+                        "secret": null,
+                        "nfs": null,
+                        "iscsi": null,
+                        "glusterfs": null,
+                        "quobyte": null
+                    }
+                ],
+                "containers": [
+                    {
+                        "name": "elasticsearch-logging",
+                        "image": "gcr.io/google_containers/elasticsearch:1.0",
+                        "ports": [
+                            {
+                                "name": "db",
+                                "containerPort": 9200,
+                                "protocol": "TCP"
+                            },
+                            {
+                                "name": "transport",
+                                "containerPort": 9300,
+                                "protocol": "TCP"
+                            }
+                        ],
+                        "resources": {},
+                        "volumeMounts": [
+                            {
+                                "name": "es-persistent-storage",
+                                "mountPath": "/data"
+                            }
+                        ],
+                        "terminationMessagePath": "/dev/termination-log",
+                        "imagePullPolicy": "IfNotPresent",
+                        "capabilities": {}
+                    }
+                ],
+                "restartPolicy": "Always",
+                "dnsPolicy": "ClusterFirst"
+            }
+        }
+    },
+    "status": {
+        "replicas": 1
+    }
+}

vendor/k8s.io/kubernetes/pkg/api/testing/serialization_proto_test.go

@@ -0,0 +1,217 @@
+/*
+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 testing
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"math/rand"
+	"reflect"
+	"testing"
+
+	"github.com/gogo/protobuf/proto"
+	"k8s.io/api/core/v1"
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/api/testing/fuzzer"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer/protobuf"
+	"k8s.io/apimachinery/pkg/util/diff"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	_ "k8s.io/kubernetes/pkg/apis/extensions"
+	_ "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
+)
+
+func TestUniversalDeserializer(t *testing.T) {
+	expected := &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "test"}}
+	d := legacyscheme.Codecs.UniversalDeserializer()
+	for _, mediaType := range []string{"application/json", "application/yaml", "application/vnd.kubernetes.protobuf"} {
+		info, ok := runtime.SerializerInfoForMediaType(legacyscheme.Codecs.SupportedMediaTypes(), mediaType)
+		if !ok {
+			t.Fatal(mediaType)
+		}
+		buf := &bytes.Buffer{}
+		if err := info.Serializer.Encode(expected, buf); err != nil {
+			t.Fatalf("%s: %v", mediaType, err)
+		}
+		obj, _, err := d.Decode(buf.Bytes(), &schema.GroupVersionKind{Kind: "Pod", Version: "v1"}, nil)
+		if err != nil {
+			t.Fatalf("%s: %v", mediaType, err)
+		}
+		if !apiequality.Semantic.DeepEqual(expected, obj) {
+			t.Fatalf("%s: %#v", mediaType, obj)
+		}
+	}
+}
+
+func TestAllFieldsHaveTags(t *testing.T) {
+	for gvk, obj := range legacyscheme.Scheme.AllKnownTypes() {
+		if gvk.Version == runtime.APIVersionInternal {
+			// internal versions are not serialized to protobuf
+			continue
+		}
+		if gvk.Group == "componentconfig" {
+			// component config is not serialized to protobuf
+			continue
+		}
+		if err := fieldsHaveProtobufTags(obj); err != nil {
+			t.Errorf("type %s as gvk %v is missing tags: %v", obj, gvk, err)
+		}
+	}
+}
+
+func fieldsHaveProtobufTags(obj reflect.Type) error {
+	switch obj.Kind() {
+	case reflect.Slice, reflect.Map, reflect.Ptr, reflect.Array:
+		return fieldsHaveProtobufTags(obj.Elem())
+	case reflect.Struct:
+		for i := 0; i < obj.NumField(); i++ {
+			f := obj.Field(i)
+			if f.Name == "TypeMeta" && f.Type.Name() == "TypeMeta" {
+				// TypeMeta is not included in external protobuf because we use an envelope type with TypeMeta
+				continue
+			}
+			if len(f.Tag.Get("json")) > 0 && len(f.Tag.Get("protobuf")) == 0 {
+				return fmt.Errorf("field %s in %s has a 'json' tag but no protobuf tag", f.Name, obj)
+			}
+		}
+	}
+	return nil
+}
+
+func TestProtobufRoundTrip(t *testing.T) {
+	obj := &v1.Pod{}
+	fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(benchmarkSeed), legacyscheme.Codecs).Fuzz(obj)
+	// InitContainers are turned into annotations by conversion.
+	obj.Spec.InitContainers = nil
+	obj.Status.InitContainerStatuses = nil
+	data, err := obj.Marshal()
+	if err != nil {
+		t.Fatal(err)
+	}
+	out := &v1.Pod{}
+	if err := out.Unmarshal(data); err != nil {
+		t.Fatal(err)
+	}
+	if !apiequality.Semantic.Equalities.DeepEqual(out, obj) {
+		t.Logf("marshal\n%s", hex.Dump(data))
+		t.Fatalf("Unmarshal is unequal\n%s", diff.ObjectGoPrintDiff(out, obj))
+	}
+}
+
+// BenchmarkEncodeCodec measures the cost of performing a codec encode, which includes
+// reflection (to clear APIVersion and Kind)
+func BenchmarkEncodeCodecProtobuf(b *testing.B) {
+	items := benchmarkItems(b)
+	width := len(items)
+	s := protobuf.NewSerializer(nil, nil, "application/arbitrary.content.type")
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := runtime.Encode(s, &items[i%width]); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+// BenchmarkEncodeCodecFromInternalProtobuf measures the cost of performing a codec encode,
+// including conversions and any type setting. This is a "full" encode.
+func BenchmarkEncodeCodecFromInternalProtobuf(b *testing.B) {
+	items := benchmarkItems(b)
+	width := len(items)
+	encodable := make([]api.Pod, width)
+	for i := range items {
+		if err := legacyscheme.Scheme.Convert(&items[i], &encodable[i], nil); err != nil {
+			b.Fatal(err)
+		}
+	}
+	s := protobuf.NewSerializer(nil, nil, "application/arbitrary.content.type")
+	codec := legacyscheme.Codecs.EncoderForVersion(s, v1.SchemeGroupVersion)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := runtime.Encode(codec, &encodable[i%width]); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+func BenchmarkEncodeProtobufGeneratedMarshal(b *testing.B) {
+	items := benchmarkItems(b)
+	width := len(items)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := items[i%width].Marshal(); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+// BenchmarkDecodeCodecToInternalProtobuf measures the cost of performing a codec decode,
+// including conversions and any type setting. This is a "full" decode.
+func BenchmarkDecodeCodecToInternalProtobuf(b *testing.B) {
+	items := benchmarkItems(b)
+	width := len(items)
+	s := protobuf.NewSerializer(legacyscheme.Scheme, legacyscheme.Scheme, "application/arbitrary.content.type")
+	encoder := legacyscheme.Codecs.EncoderForVersion(s, v1.SchemeGroupVersion)
+	var encoded [][]byte
+	for i := range items {
+		data, err := runtime.Encode(encoder, &items[i])
+		if err != nil {
+			b.Fatal(err)
+		}
+		encoded = append(encoded, data)
+	}
+
+	decoder := legacyscheme.Codecs.DecoderToVersion(s, api.SchemeGroupVersion)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := runtime.Decode(decoder, encoded[i%width]); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+// BenchmarkDecodeJSON provides a baseline for regular JSON decode performance
+func BenchmarkDecodeIntoProtobuf(b *testing.B) {
+	items := benchmarkItems(b)
+	width := len(items)
+	encoded := make([][]byte, width)
+	for i := range items {
+		data, err := (&items[i]).Marshal()
+		if err != nil {
+			b.Fatal(err)
+		}
+		encoded[i] = data
+		validate := &v1.Pod{}
+		if err := proto.Unmarshal(data, validate); err != nil {
+			b.Fatalf("Failed to unmarshal %d: %v\n%#v", i, err, items[i])
+		}
+	}
+
+	for i := 0; i < b.N; i++ {
+		obj := v1.Pod{}
+		if err := proto.Unmarshal(encoded[i%width], &obj); err != nil {
+			b.Fatal(err)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/testing/serialization_test.go

@@ -0,0 +1,570 @@
+/*
+Copyright 2014 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 testing
+
+import (
+	"bytes"
+	"encoding/hex"
+	"encoding/json"
+	"io/ioutil"
+	"math/rand"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/golang/protobuf/proto"
+	jsoniter "github.com/json-iterator/go"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/api/extensions/v1beta1"
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/api/testing/fuzzer"
+	"k8s.io/apimachinery/pkg/api/testing/roundtrip"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/conversion"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer/streaming"
+	"k8s.io/apimachinery/pkg/util/diff"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/api/testapi"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	k8s_api_v1 "k8s.io/kubernetes/pkg/apis/core/v1"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	k8s_v1beta1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
+)
+
+// fuzzInternalObject fuzzes an arbitrary runtime object using the appropriate
+// fuzzer registered with the apitesting package.
+func fuzzInternalObject(t *testing.T, forVersion schema.GroupVersion, item runtime.Object, seed int64) runtime.Object {
+	fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(seed), legacyscheme.Codecs).Fuzz(item)
+
+	j, err := meta.TypeAccessor(item)
+	if err != nil {
+		t.Fatalf("Unexpected error %v for %#v", err, item)
+	}
+	j.SetKind("")
+	j.SetAPIVersion("")
+
+	return item
+}
+
+// dataAsString returns the given byte array as a string; handles detecting
+// protocol buffers.
+func dataAsString(data []byte) string {
+	dataString := string(data)
+	if !strings.HasPrefix(dataString, "{") {
+		dataString = "\n" + hex.Dump(data)
+		proto.NewBuffer(make([]byte, 0, 1024)).DebugPrint("decoded object", data)
+	}
+	return dataString
+}
+
+func Convert_v1beta1_ReplicaSet_to_api_ReplicationController(in *v1beta1.ReplicaSet, out *api.ReplicationController, s conversion.Scope) error {
+	intermediate1 := &extensions.ReplicaSet{}
+	if err := k8s_v1beta1.Convert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(in, intermediate1, s); err != nil {
+		return err
+	}
+
+	intermediate2 := &v1.ReplicationController{}
+	if err := k8s_api_v1.Convert_extensions_ReplicaSet_to_v1_ReplicationController(intermediate1, intermediate2, s); err != nil {
+		return err
+	}
+
+	return k8s_api_v1.Convert_v1_ReplicationController_To_core_ReplicationController(intermediate2, out, s)
+}
+
+func TestSetControllerConversion(t *testing.T) {
+	if err := legacyscheme.Scheme.AddConversionFuncs(Convert_v1beta1_ReplicaSet_to_api_ReplicationController); err != nil {
+		t.Fatal(err)
+	}
+
+	rs := &extensions.ReplicaSet{}
+	rc := &api.ReplicationController{}
+
+	extGroup := testapi.Extensions
+	defaultGroup := testapi.Default
+
+	fuzzInternalObject(t, extGroup.InternalGroupVersion(), rs, rand.Int63())
+
+	// explicitly set the selector to something that is convertible to old-style selectors
+	// (since normally we'll fuzz the selectors with things that aren't convertible)
+	rs.Spec.Selector = &metav1.LabelSelector{
+		MatchLabels: map[string]string{
+			"foo": "bar",
+			"baz": "quux",
+		},
+	}
+
+	t.Logf("rs._internal.extensions -> rs.v1beta1.extensions")
+	data, err := runtime.Encode(extGroup.Codec(), rs)
+	if err != nil {
+		t.Fatalf("unexpected encoding error: %v", err)
+	}
+
+	decoder := legacyscheme.Codecs.DecoderToVersion(
+		legacyscheme.Codecs.UniversalDeserializer(),
+		runtime.NewMultiGroupVersioner(
+			*defaultGroup.GroupVersion(),
+			schema.GroupKind{Group: defaultGroup.GroupVersion().Group},
+			schema.GroupKind{Group: extGroup.GroupVersion().Group},
+		),
+	)
+
+	t.Logf("rs.v1beta1.extensions -> rc._internal")
+	if err := runtime.DecodeInto(decoder, data, rc); err != nil {
+		t.Fatalf("unexpected decoding error: %v", err)
+	}
+
+	t.Logf("rc._internal -> rc.v1")
+	data, err = runtime.Encode(defaultGroup.Codec(), rc)
+	if err != nil {
+		t.Fatalf("unexpected encoding error: %v", err)
+	}
+
+	t.Logf("rc.v1 -> rs._internal.extensions")
+	if err := runtime.DecodeInto(decoder, data, rs); err != nil {
+		t.Fatalf("unexpected decoding error: %v", err)
+	}
+}
+
+// TestSpecificKind round-trips a single specific kind and is intended to help
+// debug issues that arise while adding a new API type.
+func TestSpecificKind(t *testing.T) {
+	// Uncomment the following line to enable logging of which conversions
+	// legacyscheme.Scheme.Log(t)
+	internalGVK := schema.GroupVersionKind{Group: "extensions", Version: runtime.APIVersionInternal, Kind: "DaemonSet"}
+
+	seed := rand.Int63()
+	fuzzer := fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(seed), legacyscheme.Codecs)
+
+	roundtrip.RoundTripSpecificKind(t, internalGVK, legacyscheme.Scheme, legacyscheme.Codecs, fuzzer, nil)
+}
+
+var nonRoundTrippableTypes = sets.NewString(
+	"ExportOptions",
+	"GetOptions",
+	// WatchEvent does not include kind and version and can only be deserialized
+	// implicitly (if the caller expects the specific object). The watch call defines
+	// the schema by content type, rather than via kind/version included in each
+	// object.
+	"WatchEvent",
+	// ListOptions is now part of the meta group
+	"ListOptions",
+	// Delete options is only read in metav1
+	"DeleteOptions",
+)
+
+var commonKinds = []string{"Status", "ListOptions", "DeleteOptions", "ExportOptions"}
+
+// TestCommonKindsRegistered verifies that all group/versions registered with
+// the testapi package have the common kinds.
+func TestCommonKindsRegistered(t *testing.T) {
+	for _, kind := range commonKinds {
+		for _, group := range testapi.Groups {
+			gv := group.GroupVersion()
+			gvk := gv.WithKind(kind)
+			obj, err := legacyscheme.Scheme.New(gvk)
+			if err != nil {
+				t.Error(err)
+			}
+			defaults := gv.WithKind("")
+			var got *schema.GroupVersionKind
+			if obj, got, err = legacyscheme.Codecs.LegacyCodec().Decode([]byte(`{"kind":"`+kind+`"}`), &defaults, obj); err != nil || gvk != *got {
+				t.Errorf("expected %v: %v %v", gvk, got, err)
+			}
+			data, err := runtime.Encode(legacyscheme.Codecs.LegacyCodec(*gv), obj)
+			if err != nil {
+				t.Errorf("expected %v: %v\n%s", gvk, err, string(data))
+				continue
+			}
+			if !bytes.Contains(data, []byte(`"kind":"`+kind+`","apiVersion":"`+gv.String()+`"`)) {
+				if kind != "Status" {
+					t.Errorf("expected %v: %v\n%s", gvk, err, string(data))
+					continue
+				}
+				// TODO: this is wrong, but legacy clients expect it
+				if !bytes.Contains(data, []byte(`"kind":"`+kind+`","apiVersion":"v1"`)) {
+					t.Errorf("expected %v: %v\n%s", gvk, err, string(data))
+					continue
+				}
+			}
+		}
+	}
+}
+
+// TestRoundTripTypes applies the round-trip test to all round-trippable Kinds
+// in all of the API groups registered for test in the testapi package.
+func TestRoundTripTypes(t *testing.T) {
+	seed := rand.Int63()
+	fuzzer := fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(seed), legacyscheme.Codecs)
+
+	nonRoundTrippableTypes := map[schema.GroupVersionKind]bool{
+		{Group: "componentconfig", Version: runtime.APIVersionInternal, Kind: "KubeProxyConfiguration"}:     true,
+		{Group: "componentconfig", Version: runtime.APIVersionInternal, Kind: "KubeSchedulerConfiguration"}: true,
+	}
+
+	roundtrip.RoundTripTypes(t, legacyscheme.Scheme, legacyscheme.Codecs, fuzzer, nonRoundTrippableTypes)
+}
+
+// TestEncodePtr tests that a pointer to a golang type can be encoded and
+// decoded without information loss or mutation.
+func TestEncodePtr(t *testing.T) {
+	grace := int64(30)
+	pod := &api.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Labels: map[string]string{"name": "foo"},
+		},
+		Spec: api.PodSpec{
+			RestartPolicy: api.RestartPolicyAlways,
+			DNSPolicy:     api.DNSClusterFirst,
+
+			TerminationGracePeriodSeconds: &grace,
+
+			SecurityContext: &api.PodSecurityContext{},
+			SchedulerName:   api.DefaultSchedulerName,
+		},
+	}
+	obj := runtime.Object(pod)
+	data, err := runtime.Encode(testapi.Default.Codec(), obj)
+	obj2, err2 := runtime.Decode(testapi.Default.Codec(), data)
+	if err != nil || err2 != nil {
+		t.Fatalf("Failure: '%v' '%v'", err, err2)
+	}
+	if _, ok := obj2.(*api.Pod); !ok {
+		t.Fatalf("Got wrong type")
+	}
+	if !apiequality.Semantic.DeepEqual(obj2, pod) {
+		t.Errorf("\nExpected:\n\n %#v,\n\nGot:\n\n %#vDiff: %v\n\n", pod, obj2, diff.ObjectDiff(obj2, pod))
+	}
+}
+
+// TestBadJSONRejection establishes that a JSON object without a kind or with
+// an unknown kind will not be decoded without error.
+func TestBadJSONRejection(t *testing.T) {
+	badJSONMissingKind := []byte(`{ }`)
+	if _, err := runtime.Decode(testapi.Default.Codec(), badJSONMissingKind); err == nil {
+		t.Errorf("Did not reject despite lack of kind field: %s", badJSONMissingKind)
+	}
+	badJSONUnknownType := []byte(`{"kind": "bar"}`)
+	if _, err1 := runtime.Decode(testapi.Default.Codec(), badJSONUnknownType); err1 == nil {
+		t.Errorf("Did not reject despite use of unknown type: %s", badJSONUnknownType)
+	}
+	/*badJSONKindMismatch := []byte(`{"kind": "Pod"}`)
+	if err2 := DecodeInto(badJSONKindMismatch, &Node{}); err2 == nil {
+		t.Errorf("Kind is set but doesn't match the object type: %s", badJSONKindMismatch)
+	}*/
+}
+
+// TestUnversionedTypes establishes that the default codec can encode and
+// decode unversioned objects.
+func TestUnversionedTypes(t *testing.T) {
+	testcases := []runtime.Object{
+		&metav1.Status{Status: "Failure", Message: "something went wrong"},
+		&metav1.APIVersions{Versions: []string{"A", "B", "C"}},
+		&metav1.APIGroupList{Groups: []metav1.APIGroup{{Name: "mygroup"}}},
+		&metav1.APIGroup{Name: "mygroup"},
+		&metav1.APIResourceList{GroupVersion: "mygroup/myversion"},
+	}
+
+	for _, obj := range testcases {
+		// Make sure the unversioned codec can encode
+		unversionedJSON, err := runtime.Encode(testapi.Default.Codec(), obj)
+		if err != nil {
+			t.Errorf("%v: unexpected error: %v", obj, err)
+			continue
+		}
+
+		// Make sure the versioned codec under test can decode
+		versionDecodedObject, err := runtime.Decode(testapi.Default.Codec(), unversionedJSON)
+		if err != nil {
+			t.Errorf("%v: unexpected error: %v", obj, err)
+			continue
+		}
+		// Make sure it decodes correctly
+		if !reflect.DeepEqual(obj, versionDecodedObject) {
+			t.Errorf("%v: expected %#v, got %#v", obj, obj, versionDecodedObject)
+			continue
+		}
+	}
+}
+
+// TestObjectWatchFraming establishes that a watch event can be encoded and
+// decoded correctly through each of the supported RFC2046 media types.
+func TestObjectWatchFraming(t *testing.T) {
+	f := fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(benchmarkSeed), legacyscheme.Codecs)
+	secret := &api.Secret{}
+	f.Fuzz(secret)
+	secret.Data["binary"] = []byte{0x00, 0x10, 0x30, 0x55, 0xff, 0x00}
+	secret.Data["utf8"] = []byte("a string with \u0345 characters")
+	secret.Data["long"] = bytes.Repeat([]byte{0x01, 0x02, 0x03, 0x00}, 1000)
+	converted, _ := legacyscheme.Scheme.ConvertToVersion(secret, v1.SchemeGroupVersion)
+	v1secret := converted.(*v1.Secret)
+	for _, info := range legacyscheme.Codecs.SupportedMediaTypes() {
+		if info.StreamSerializer == nil {
+			continue
+		}
+		s := info.StreamSerializer
+		framer := s.Framer
+		embedded := info.Serializer
+		if embedded == nil {
+			t.Errorf("no embedded serializer for %s", info.MediaType)
+			continue
+		}
+		innerDecode := legacyscheme.Codecs.DecoderToVersion(embedded, api.SchemeGroupVersion)
+
+		// write a single object through the framer and back out
+		obj := &bytes.Buffer{}
+		if err := s.Encode(v1secret, obj); err != nil {
+			t.Fatal(err)
+		}
+		out := &bytes.Buffer{}
+		w := framer.NewFrameWriter(out)
+		if n, err := w.Write(obj.Bytes()); err != nil || n != len(obj.Bytes()) {
+			t.Fatal(err)
+		}
+		sr := streaming.NewDecoder(framer.NewFrameReader(ioutil.NopCloser(out)), s)
+		resultSecret := &v1.Secret{}
+		res, _, err := sr.Decode(nil, resultSecret)
+		if err != nil {
+			t.Fatalf("%v:\n%s", err, hex.Dump(obj.Bytes()))
+		}
+		resultSecret.Kind = "Secret"
+		resultSecret.APIVersion = "v1"
+		if !apiequality.Semantic.DeepEqual(v1secret, res) {
+			t.Fatalf("objects did not match: %s", diff.ObjectGoPrintDiff(v1secret, res))
+		}
+
+		// write a watch event through the frame writer and read it back in
+		// via the frame reader for this media type
+		obj = &bytes.Buffer{}
+		if err := embedded.Encode(v1secret, obj); err != nil {
+			t.Fatal(err)
+		}
+		event := &metav1.WatchEvent{Type: string(watch.Added)}
+		event.Object.Raw = obj.Bytes()
+		obj = &bytes.Buffer{}
+		if err := s.Encode(event, obj); err != nil {
+			t.Fatal(err)
+		}
+		out = &bytes.Buffer{}
+		w = framer.NewFrameWriter(out)
+		if n, err := w.Write(obj.Bytes()); err != nil || n != len(obj.Bytes()) {
+			t.Fatal(err)
+		}
+		sr = streaming.NewDecoder(framer.NewFrameReader(ioutil.NopCloser(out)), s)
+		outEvent := &metav1.WatchEvent{}
+		res, _, err = sr.Decode(nil, outEvent)
+		if err != nil || outEvent.Type != string(watch.Added) {
+			t.Fatalf("%v: %#v", err, outEvent)
+		}
+		if outEvent.Object.Object == nil && outEvent.Object.Raw != nil {
+			outEvent.Object.Object, err = runtime.Decode(innerDecode, outEvent.Object.Raw)
+			if err != nil {
+				t.Fatalf("%v:\n%s", err, hex.Dump(outEvent.Object.Raw))
+			}
+		}
+
+		if !apiequality.Semantic.DeepEqual(secret, outEvent.Object.Object) {
+			t.Fatalf("%s: did not match after frame decoding: %s", info.MediaType, diff.ObjectGoPrintDiff(secret, outEvent.Object.Object))
+		}
+	}
+}
+
+const benchmarkSeed = 100
+
+func benchmarkItems(b *testing.B) []v1.Pod {
+	apiObjectFuzzer := fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(benchmarkSeed), legacyscheme.Codecs)
+	items := make([]v1.Pod, 10)
+	for i := range items {
+		var pod api.Pod
+		apiObjectFuzzer.Fuzz(&pod)
+		pod.Spec.InitContainers, pod.Status.InitContainerStatuses = nil, nil
+		out, err := legacyscheme.Scheme.ConvertToVersion(&pod, v1.SchemeGroupVersion)
+		if err != nil {
+			panic(err)
+		}
+		items[i] = *out.(*v1.Pod)
+	}
+	return items
+}
+
+// BenchmarkEncodeCodec measures the cost of performing a codec encode, which includes
+// reflection (to clear APIVersion and Kind)
+func BenchmarkEncodeCodec(b *testing.B) {
+	items := benchmarkItems(b)
+	width := len(items)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := runtime.Encode(testapi.Default.Codec(), &items[i%width]); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+// BenchmarkEncodeCodecFromInternal measures the cost of performing a codec encode,
+// including conversions.
+func BenchmarkEncodeCodecFromInternal(b *testing.B) {
+	items := benchmarkItems(b)
+	width := len(items)
+	encodable := make([]api.Pod, width)
+	for i := range items {
+		if err := legacyscheme.Scheme.Convert(&items[i], &encodable[i], nil); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := runtime.Encode(testapi.Default.Codec(), &encodable[i%width]); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+// BenchmarkEncodeJSONMarshal provides a baseline for regular JSON encode performance
+func BenchmarkEncodeJSONMarshal(b *testing.B) {
+	items := benchmarkItems(b)
+	width := len(items)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := json.Marshal(&items[i%width]); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+func BenchmarkDecodeCodec(b *testing.B) {
+	codec := testapi.Default.Codec()
+	items := benchmarkItems(b)
+	width := len(items)
+	encoded := make([][]byte, width)
+	for i := range items {
+		data, err := runtime.Encode(codec, &items[i])
+		if err != nil {
+			b.Fatal(err)
+		}
+		encoded[i] = data
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := runtime.Decode(codec, encoded[i%width]); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+func BenchmarkDecodeIntoExternalCodec(b *testing.B) {
+	codec := testapi.Default.Codec()
+	items := benchmarkItems(b)
+	width := len(items)
+	encoded := make([][]byte, width)
+	for i := range items {
+		data, err := runtime.Encode(codec, &items[i])
+		if err != nil {
+			b.Fatal(err)
+		}
+		encoded[i] = data
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		obj := v1.Pod{}
+		if err := runtime.DecodeInto(codec, encoded[i%width], &obj); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+func BenchmarkDecodeIntoInternalCodec(b *testing.B) {
+	codec := testapi.Default.Codec()
+	items := benchmarkItems(b)
+	width := len(items)
+	encoded := make([][]byte, width)
+	for i := range items {
+		data, err := runtime.Encode(codec, &items[i])
+		if err != nil {
+			b.Fatal(err)
+		}
+		encoded[i] = data
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		obj := api.Pod{}
+		if err := runtime.DecodeInto(codec, encoded[i%width], &obj); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+// BenchmarkDecodeJSON provides a baseline for regular JSON decode performance
+func BenchmarkDecodeIntoJSON(b *testing.B) {
+	codec := testapi.Default.Codec()
+	items := benchmarkItems(b)
+	width := len(items)
+	encoded := make([][]byte, width)
+	for i := range items {
+		data, err := runtime.Encode(codec, &items[i])
+		if err != nil {
+			b.Fatal(err)
+		}
+		encoded[i] = data
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		obj := v1.Pod{}
+		if err := json.Unmarshal(encoded[i%width], &obj); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}
+
+// BenchmarkDecodeJSON provides a baseline for JSON decode performance
+func BenchmarkDecodeIntoJSONCodecGen(b *testing.B) {
+	kcodec := testapi.Default.Codec()
+	items := benchmarkItems(b)
+	width := len(items)
+	encoded := make([][]byte, width)
+	for i := range items {
+		data, err := runtime.Encode(kcodec, &items[i])
+		if err != nil {
+			b.Fatal(err)
+		}
+		encoded[i] = data
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		obj := v1.Pod{}
+		if err := jsoniter.ConfigFastest.Unmarshal(encoded[i%width], &obj); err != nil {
+			b.Fatal(err)
+		}
+	}
+	b.StopTimer()
+}

vendor/k8s.io/kubernetes/pkg/api/testing/unstructured_test.go

@@ -0,0 +1,213 @@
+/*
+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 testing
+
+import (
+	"math/rand"
+	"reflect"
+	"testing"
+
+	"github.com/google/gofuzz"
+
+	"k8s.io/api/core/v1"
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/api/testing/fuzzer"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	metaunstruct "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/util/diff"
+	"k8s.io/apimachinery/pkg/util/json"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/api/testapi"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+func doRoundTrip(t *testing.T, group testapi.TestGroup, kind string) {
+	// We do fuzzing on the internal version of the object, and only then
+	// convert to the external version. This is because custom fuzzing
+	// function are only supported for internal objects.
+	internalObj, err := legacyscheme.Scheme.New(group.InternalGroupVersion().WithKind(kind))
+	if err != nil {
+		t.Fatalf("Couldn't create internal object %v: %v", kind, err)
+	}
+	seed := rand.Int63()
+	fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(seed), legacyscheme.Codecs).
+		// We are explicitly overwriting custom fuzzing functions, to ensure
+		// that InitContainers and their statuses are not generated. This is
+		// because in thise test we are simply doing json operations, in which
+		// those disappear.
+		Funcs(
+			func(s *api.PodSpec, c fuzz.Continue) {
+				c.FuzzNoCustom(s)
+				s.InitContainers = nil
+			},
+			func(s *api.PodStatus, c fuzz.Continue) {
+				c.FuzzNoCustom(s)
+				s.InitContainerStatuses = nil
+			},
+		).Fuzz(internalObj)
+
+	item, err := legacyscheme.Scheme.New(group.GroupVersion().WithKind(kind))
+	if err != nil {
+		t.Fatalf("Couldn't create external object %v: %v", kind, err)
+	}
+	if err := legacyscheme.Scheme.Convert(internalObj, item, nil); err != nil {
+		t.Fatalf("Conversion for %v failed: %v", kind, err)
+	}
+
+	data, err := json.Marshal(item)
+	if err != nil {
+		t.Errorf("Error when marshaling object: %v", err)
+		return
+	}
+	unstr := make(map[string]interface{})
+	err = json.Unmarshal(data, &unstr)
+	if err != nil {
+		t.Errorf("Error when unmarshaling to unstructured: %v", err)
+		return
+	}
+
+	data, err = json.Marshal(unstr)
+	if err != nil {
+		t.Errorf("Error when marshaling unstructured: %v", err)
+		return
+	}
+	unmarshalledObj := reflect.New(reflect.TypeOf(item).Elem()).Interface()
+	err = json.Unmarshal(data, &unmarshalledObj)
+	if err != nil {
+		t.Errorf("Error when unmarshaling to object: %v", err)
+		return
+	}
+	if !apiequality.Semantic.DeepEqual(item, unmarshalledObj) {
+		t.Errorf("Object changed during JSON operations, diff: %v", diff.ObjectReflectDiff(item, unmarshalledObj))
+		return
+	}
+
+	newUnstr, err := runtime.NewTestUnstructuredConverter(apiequality.Semantic).ToUnstructured(item)
+	if err != nil {
+		t.Errorf("ToUnstructured failed: %v", err)
+		return
+	}
+
+	newObj := reflect.New(reflect.TypeOf(item).Elem()).Interface().(runtime.Object)
+	err = runtime.DefaultUnstructuredConverter.FromUnstructured(newUnstr, newObj)
+	if err != nil {
+		t.Errorf("FromUnstructured failed: %v", err)
+		return
+	}
+
+	if !apiequality.Semantic.DeepEqual(item, newObj) {
+		t.Errorf("Object changed, diff: %v", diff.ObjectReflectDiff(item, newObj))
+	}
+}
+
+func TestRoundTrip(t *testing.T) {
+	for groupKey, group := range testapi.Groups {
+		for kind := range group.ExternalTypes() {
+			if nonRoundTrippableTypes.Has(kind) {
+				continue
+			}
+			t.Logf("Testing: %v in %v", kind, groupKey)
+			for i := 0; i < 50; i++ {
+				doRoundTrip(t, group, kind)
+				if t.Failed() {
+					break
+				}
+			}
+		}
+	}
+}
+
+func TestRoundTripWithEmptyCreationTimestamp(t *testing.T) {
+	for groupKey, group := range testapi.Groups {
+		for kind := range group.ExternalTypes() {
+			if nonRoundTrippableTypes.Has(kind) {
+				continue
+			}
+			item, err := legacyscheme.Scheme.New(group.GroupVersion().WithKind(kind))
+			if err != nil {
+				t.Fatalf("Couldn't create external object %v: %v", kind, err)
+			}
+			t.Logf("Testing: %v in %v", kind, groupKey)
+
+			unstrBody, err := runtime.DefaultUnstructuredConverter.ToUnstructured(item)
+			if err != nil {
+				t.Fatalf("ToUnstructured failed: %v", err)
+			}
+
+			unstructObj := &metaunstruct.Unstructured{}
+			unstructObj.Object = unstrBody
+
+			if meta, err := meta.Accessor(unstructObj); err == nil {
+				meta.SetCreationTimestamp(metav1.Time{})
+			} else {
+				t.Fatalf("Unable to set creation timestamp: %v", err)
+			}
+
+			// attempt to re-convert unstructured object - conversion should not fail
+			// based on empty metadata fields, such as creationTimestamp
+			newObj := reflect.New(reflect.TypeOf(item).Elem()).Interface().(runtime.Object)
+			err = runtime.NewTestUnstructuredConverter(apiequality.Semantic).FromUnstructured(unstructObj.Object, newObj)
+			if err != nil {
+				t.Fatalf("FromUnstructured failed: %v", err)
+			}
+		}
+	}
+}
+
+func BenchmarkToFromUnstructured(b *testing.B) {
+	items := benchmarkItems(b)
+	size := len(items)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		unstr, err := runtime.NewTestUnstructuredConverter(apiequality.Semantic).ToUnstructured(&items[i%size])
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
+		obj := v1.Pod{}
+		if err := runtime.NewTestUnstructuredConverter(apiequality.Semantic).FromUnstructured(unstr, &obj); err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
+	}
+	b.StopTimer()
+}
+
+func BenchmarkToFromUnstructuredViaJSON(b *testing.B) {
+	items := benchmarkItems(b)
+	size := len(items)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		data, err := json.Marshal(&items[i%size])
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
+		unstr := map[string]interface{}{}
+		if err := json.Unmarshal(data, &unstr); err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
+		data, err = json.Marshal(unstr)
+		if err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
+		obj := v1.Pod{}
+		if err := json.Unmarshal(data, &obj); err != nil {
+			b.Fatalf("unexpected error: %v", err)
+		}
+	}
+	b.StopTimer()
+}

vendor/k8s.io/kubernetes/pkg/api/unversioned/BUILD

@@ -0,0 +1,34 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "duration.go",
+        "time.go",
+        "types.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/api/unversioned",
+    deps = [
+        "//vendor/github.com/go-openapi/spec:go_default_library",
+        "//vendor/github.com/google/gofuzz:go_default_library",
+        "//vendor/k8s.io/kube-openapi/pkg/common:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/unversioned/duration.go

@@ -0,0 +1,47 @@
+/*
+Copyright 2016 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 unversioned
+
+import (
+	"encoding/json"
+	"time"
+)
+
+// Duration is a wrapper around time.Duration which supports correct
+// marshaling to YAML and JSON. In particular, it marshals into strings, which
+// can be used as map keys in json.
+type Duration struct {
+	time.Duration `protobuf:"-"`
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface.
+func (d *Duration) UnmarshalJSON(b []byte) error {
+	var str string
+	json.Unmarshal(b, &str)
+
+	pd, err := time.ParseDuration(str)
+	if err != nil {
+		return err
+	}
+	d.Duration = pd
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (d Duration) MarshalJSON() ([]byte, error) {
+	return json.Marshal(d.Duration.String())
+}

vendor/k8s.io/kubernetes/pkg/api/unversioned/time.go

@@ -0,0 +1,176 @@
+/*
+Copyright 2016 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 unversioned
+
+import (
+	"encoding/json"
+	"time"
+
+	openapi "k8s.io/kube-openapi/pkg/common"
+
+	"github.com/go-openapi/spec"
+	"github.com/google/gofuzz"
+)
+
+// Time is a wrapper around time.Time which supports correct
+// marshaling to YAML and JSON.  Wrappers are provided for many
+// of the factory methods that the time package offers.
+type Time struct {
+	time.Time `protobuf:"-"`
+}
+
+// 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) DeepCopyInto(out *Time) {
+	*out = *t
+}
+
+// String returns the representation of the time.
+func (t Time) String() string {
+	return t.Time.String()
+}
+
+// NewTime returns a wrapped instance of the provided time
+func NewTime(time time.Time) Time {
+	return Time{time}
+}
+
+// Date returns the Time corresponding to the supplied parameters
+// by wrapping time.Date.
+func Date(year int, month time.Month, day, hour, min, sec, nsec int, loc *time.Location) Time {
+	return Time{time.Date(year, month, day, hour, min, sec, nsec, loc)}
+}
+
+// Now returns the current local time.
+func Now() Time {
+	return Time{time.Now()}
+}
+
+// IsZero returns true if the value is nil or time is zero.
+func (t *Time) IsZero() bool {
+	if t == nil {
+		return true
+	}
+	return t.Time.IsZero()
+}
+
+// Before reports whether the time instant t is before u.
+func (t Time) Before(u Time) bool {
+	return t.Time.Before(u.Time)
+}
+
+// Equal reports whether the time instant t is equal to u.
+func (t Time) Equal(u Time) bool {
+	return t.Time.Equal(u.Time)
+}
+
+// Unix returns the local time corresponding to the given Unix time
+// by wrapping time.Unix.
+func Unix(sec int64, nsec int64) Time {
+	return Time{time.Unix(sec, nsec)}
+}
+
+// Rfc3339Copy returns a copy of the Time at second-level precision.
+func (t Time) Rfc3339Copy() Time {
+	copied, _ := time.Parse(time.RFC3339, t.Format(time.RFC3339))
+	return Time{copied}
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface.
+func (t *Time) UnmarshalJSON(b []byte) error {
+	if len(b) == 4 && string(b) == "null" {
+		t.Time = time.Time{}
+		return nil
+	}
+
+	var str string
+	json.Unmarshal(b, &str)
+
+	pt, err := time.Parse(time.RFC3339, str)
+	if err != nil {
+		return err
+	}
+
+	t.Time = pt.Local()
+	return nil
+}
+
+// UnmarshalQueryParameter converts from a URL query parameter value to an object
+func (t *Time) UnmarshalQueryParameter(str string) error {
+	if len(str) == 0 {
+		t.Time = time.Time{}
+		return nil
+	}
+	// Tolerate requests from older clients that used JSON serialization to build query params
+	if len(str) == 4 && str == "null" {
+		t.Time = time.Time{}
+		return nil
+	}
+
+	pt, err := time.Parse(time.RFC3339, str)
+	if err != nil {
+		return err
+	}
+
+	t.Time = pt.Local()
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (t Time) MarshalJSON() ([]byte, error) {
+	if t.IsZero() {
+		// Encode unset/nil objects as JSON's "null".
+		return []byte("null"), nil
+	}
+
+	return json.Marshal(t.UTC().Format(time.RFC3339))
+}
+
+func (_ Time) OpenAPIDefinition() openapi.OpenAPIDefinition {
+	return openapi.OpenAPIDefinition{
+		Schema: spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Type:   []string{"string"},
+				Format: "date-time",
+			},
+		},
+	}
+}
+
+// MarshalQueryParameter converts to a URL query parameter value
+func (t Time) MarshalQueryParameter() (string, error) {
+	if t.IsZero() {
+		// Encode unset/nil objects as an empty string
+		return "", nil
+	}
+
+	return t.UTC().Format(time.RFC3339), nil
+}
+
+// Fuzz satisfies fuzz.Interface.
+func (t *Time) Fuzz(c fuzz.Continue) {
+	if t == nil {
+		return
+	}
+	// Allow for about 1000 years of randomness.  Leave off nanoseconds
+	// because JSON doesn't represent them so they can't round-trip
+	// properly.
+	t.Time = time.Unix(c.Rand.Int63n(1000*365*24*60*60), 0)
+}
+
+var _ fuzz.Interface = &Time{}

vendor/k8s.io/kubernetes/pkg/api/unversioned/types.go

@@ -0,0 +1,60 @@
+/*
+Copyright 2016 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 unversioned is deprecated and has been replaced with pkg/apis/meta/v1
+//
+// DEPRECATED - Do not reference or add types to this package, it will be removed
+// once Heapster is updated to use pkg/apis/meta/v1.
+package unversioned
+
+// 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.
+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.
+	// Cannot be updated.
+	// In CamelCase.
+	// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
+	// +optional
+	Kind string `json:"kind,omitempty" protobuf:"bytes,1,opt,name=kind"`
+
+	// APIVersion defines the versioned schema of this representation of an object.
+	// Servers should convert recognized schemas to the latest internal value, and
+	// may reject unrecognized values.
+	// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources
+	// +optional
+	APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,2,opt,name=apiVersion"`
+}
+
+// ListMeta describes metadata that synthetic resources must have, including lists and
+// various status objects. A resource may have only one of {ObjectMeta, ListMeta}.
+type ListMeta struct {
+	// SelfLink is a URL representing this object.
+	// Populated by the system.
+	// Read-only.
+	// +optional
+	SelfLink string `json:"selfLink,omitempty" protobuf:"bytes,1,opt,name=selfLink"`
+
+	// String that identifies the server's internal version of this object that
+	// can be used by clients to determine when objects have changed.
+	// Value must be treated as opaque by clients and passed unmodified back to the server.
+	// Populated by the system.
+	// Read-only.
+	// More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency
+	// +optional
+	ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,2,opt,name=resourceVersion"`
+}

vendor/k8s.io/kubernetes/pkg/api/v1/OWNERS

@@ -0,0 +1,39 @@
+reviewers:
+- thockin
+- lavalamp
+- smarterclayton
+- wojtek-t
+- deads2k
+- yujuhong
+- brendandburns
+- derekwaynecarr
+- caesarxuchao
+- vishh
+- mikedanese
+- liggitt
+- nikhiljindal
+- gmarek
+- erictune
+- davidopp
+- pmorie
+- sttts
+- dchen1107
+- saad-ali
+- zmerlynn
+- luxas
+- janetkuo
+- justinsb
+- roberthbailey
+- ncdc
+- tallclair
+- eparis
+- timothysc
+- piosz
+- jsafrane
+- dims
+- errordeveloper
+- madhusudancs
+- krousey
+- jayunit100
+- rootfs
+- markturansky

vendor/k8s.io/kubernetes/pkg/api/v1/endpoints/BUILD

@@ -0,0 +1,43 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/v1/endpoints",
+    deps = [
+        "//pkg/util/hash:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/v1/endpoints",
+    library = ":go_default_library",
+    deps = [
+        "//vendor/github.com/davecgh/go-spew/spew:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/v1/endpoints/util.go

@@ -0,0 +1,226 @@
+/*
+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 endpoints
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/hex"
+	"hash"
+	"sort"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	hashutil "k8s.io/kubernetes/pkg/util/hash"
+)
+
+// RepackSubsets takes a slice of EndpointSubset objects, expands it to the full
+// representation, and then repacks that into the canonical layout.  This
+// ensures that code which operates on these objects can rely on the common
+// form for things like comparison.  The result is a newly allocated slice.
+func RepackSubsets(subsets []v1.EndpointSubset) []v1.EndpointSubset {
+	// First map each unique port definition to the sets of hosts that
+	// offer it.
+	allAddrs := map[addressKey]*v1.EndpointAddress{}
+	portToAddrReadyMap := map[v1.EndpointPort]addressSet{}
+	for i := range subsets {
+		for _, port := range subsets[i].Ports {
+			for k := range subsets[i].Addresses {
+				mapAddressByPort(&subsets[i].Addresses[k], port, true, allAddrs, portToAddrReadyMap)
+			}
+			for k := range subsets[i].NotReadyAddresses {
+				mapAddressByPort(&subsets[i].NotReadyAddresses[k], port, false, allAddrs, portToAddrReadyMap)
+			}
+		}
+	}
+
+	// Next, map the sets of hosts to the sets of ports they offer.
+	// Go does not allow maps or slices as keys to maps, so we have
+	// to synthesize an artificial key and do a sort of 2-part
+	// associative entity.
+	type keyString string
+	keyToAddrReadyMap := map[keyString]addressSet{}
+	addrReadyMapKeyToPorts := map[keyString][]v1.EndpointPort{}
+	for port, addrs := range portToAddrReadyMap {
+		key := keyString(hashAddresses(addrs))
+		keyToAddrReadyMap[key] = addrs
+		addrReadyMapKeyToPorts[key] = append(addrReadyMapKeyToPorts[key], port)
+	}
+
+	// Next, build the N-to-M association the API wants.
+	final := []v1.EndpointSubset{}
+	for key, ports := range addrReadyMapKeyToPorts {
+		var readyAddrs, notReadyAddrs []v1.EndpointAddress
+		for addr, ready := range keyToAddrReadyMap[key] {
+			if ready {
+				readyAddrs = append(readyAddrs, *addr)
+			} else {
+				notReadyAddrs = append(notReadyAddrs, *addr)
+			}
+		}
+		final = append(final, v1.EndpointSubset{Addresses: readyAddrs, NotReadyAddresses: notReadyAddrs, Ports: ports})
+	}
+
+	// Finally, sort it.
+	return SortSubsets(final)
+}
+
+// The sets of hosts must be de-duped, using IP+UID as the key.
+type addressKey struct {
+	ip  string
+	uid types.UID
+}
+
+// mapAddressByPort adds an address into a map by its ports, registering the address with a unique pointer, and preserving
+// any existing ready state.
+func mapAddressByPort(addr *v1.EndpointAddress, port v1.EndpointPort, ready bool, allAddrs map[addressKey]*v1.EndpointAddress, portToAddrReadyMap map[v1.EndpointPort]addressSet) *v1.EndpointAddress {
+	// use addressKey to distinguish between two endpoints that are identical addresses
+	// but may have come from different hosts, for attribution. For instance, Mesos
+	// assigns pods the node IP, but the pods are distinct.
+	key := addressKey{ip: addr.IP}
+	if addr.TargetRef != nil {
+		key.uid = addr.TargetRef.UID
+	}
+
+	// Accumulate the address. The full EndpointAddress structure is preserved for use when
+	// we rebuild the subsets so that the final TargetRef has all of the necessary data.
+	existingAddress := allAddrs[key]
+	if existingAddress == nil {
+		// Make a copy so we don't write to the
+		// input args of this function.
+		existingAddress = &v1.EndpointAddress{}
+		*existingAddress = *addr
+		allAddrs[key] = existingAddress
+	}
+
+	// Remember that this port maps to this address.
+	if _, found := portToAddrReadyMap[port]; !found {
+		portToAddrReadyMap[port] = addressSet{}
+	}
+	// if we have not yet recorded this port for this address, or if the previous
+	// state was ready, write the current ready state. not ready always trumps
+	// ready.
+	if wasReady, found := portToAddrReadyMap[port][existingAddress]; !found || wasReady {
+		portToAddrReadyMap[port][existingAddress] = ready
+	}
+	return existingAddress
+}
+
+type addressSet map[*v1.EndpointAddress]bool
+
+type addrReady struct {
+	addr  *v1.EndpointAddress
+	ready bool
+}
+
+func hashAddresses(addrs addressSet) string {
+	// Flatten the list of addresses into a string so it can be used as a
+	// map key.  Unfortunately, DeepHashObject is implemented in terms of
+	// spew, and spew does not handle non-primitive map keys well.  So
+	// first we collapse it into a slice, sort the slice, then hash that.
+	slice := make([]addrReady, 0, len(addrs))
+	for k, ready := range addrs {
+		slice = append(slice, addrReady{k, ready})
+	}
+	sort.Sort(addrsReady(slice))
+	hasher := md5.New()
+	hashutil.DeepHashObject(hasher, slice)
+	return hex.EncodeToString(hasher.Sum(nil)[0:])
+}
+
+func lessAddrReady(a, b addrReady) bool {
+	// ready is not significant to hashing since we can't have duplicate addresses
+	return LessEndpointAddress(a.addr, b.addr)
+}
+
+type addrsReady []addrReady
+
+func (sl addrsReady) Len() int      { return len(sl) }
+func (sl addrsReady) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
+func (sl addrsReady) Less(i, j int) bool {
+	return lessAddrReady(sl[i], sl[j])
+}
+
+func LessEndpointAddress(a, b *v1.EndpointAddress) bool {
+	ipComparison := bytes.Compare([]byte(a.IP), []byte(b.IP))
+	if ipComparison != 0 {
+		return ipComparison < 0
+	}
+	if b.TargetRef == nil {
+		return false
+	}
+	if a.TargetRef == nil {
+		return true
+	}
+	return a.TargetRef.UID < b.TargetRef.UID
+}
+
+type addrPtrsByIpAndUID []*v1.EndpointAddress
+
+func (sl addrPtrsByIpAndUID) Len() int      { return len(sl) }
+func (sl addrPtrsByIpAndUID) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
+func (sl addrPtrsByIpAndUID) Less(i, j int) bool {
+	return LessEndpointAddress(sl[i], sl[j])
+}
+
+// SortSubsets sorts an array of EndpointSubset objects in place.  For ease of
+// use it returns the input slice.
+func SortSubsets(subsets []v1.EndpointSubset) []v1.EndpointSubset {
+	for i := range subsets {
+		ss := &subsets[i]
+		sort.Sort(addrsByIpAndUID(ss.Addresses))
+		sort.Sort(addrsByIpAndUID(ss.NotReadyAddresses))
+		sort.Sort(portsByHash(ss.Ports))
+	}
+	sort.Sort(subsetsByHash(subsets))
+	return subsets
+}
+
+func hashObject(hasher hash.Hash, obj interface{}) []byte {
+	hashutil.DeepHashObject(hasher, obj)
+	return hasher.Sum(nil)
+}
+
+type subsetsByHash []v1.EndpointSubset
+
+func (sl subsetsByHash) Len() int      { return len(sl) }
+func (sl subsetsByHash) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
+func (sl subsetsByHash) Less(i, j int) bool {
+	hasher := md5.New()
+	h1 := hashObject(hasher, sl[i])
+	h2 := hashObject(hasher, sl[j])
+	return bytes.Compare(h1, h2) < 0
+}
+
+type addrsByIpAndUID []v1.EndpointAddress
+
+func (sl addrsByIpAndUID) Len() int      { return len(sl) }
+func (sl addrsByIpAndUID) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
+func (sl addrsByIpAndUID) Less(i, j int) bool {
+	return LessEndpointAddress(&sl[i], &sl[j])
+}
+
+type portsByHash []v1.EndpointPort
+
+func (sl portsByHash) Len() int      { return len(sl) }
+func (sl portsByHash) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] }
+func (sl portsByHash) Less(i, j int) bool {
+	hasher := md5.New()
+	h1 := hashObject(hasher, sl[i])
+	h2 := hashObject(hasher, sl[j])
+	return bytes.Compare(h1, h2) < 0
+}

vendor/k8s.io/kubernetes/pkg/api/v1/endpoints/util_test.go

@@ -0,0 +1,464 @@
+/*
+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 endpoints
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+)
+
+func podRef(uid string) *v1.ObjectReference {
+	ref := v1.ObjectReference{UID: types.UID(uid)}
+	return &ref
+}
+
+func TestPackSubsets(t *testing.T) {
+	// The downside of table-driven tests is that some things have to live outside the table.
+	fooObjRef := v1.ObjectReference{Name: "foo"}
+	barObjRef := v1.ObjectReference{Name: "bar"}
+
+	testCases := []struct {
+		name   string
+		given  []v1.EndpointSubset
+		expect []v1.EndpointSubset
+	}{
+		{
+			name:   "empty everything",
+			given:  []v1.EndpointSubset{{Addresses: []v1.EndpointAddress{}, Ports: []v1.EndpointPort{}}},
+			expect: []v1.EndpointSubset{},
+		}, {
+			name:   "empty addresses",
+			given:  []v1.EndpointSubset{{Addresses: []v1.EndpointAddress{}, Ports: []v1.EndpointPort{{Port: 111}}}},
+			expect: []v1.EndpointSubset{},
+		}, {
+			name:   "empty ports",
+			given:  []v1.EndpointSubset{{Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}}, Ports: []v1.EndpointPort{}}},
+			expect: []v1.EndpointSubset{},
+		}, {
+			name:   "empty ports",
+			given:  []v1.EndpointSubset{{NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4"}}, Ports: []v1.EndpointPort{}}},
+			expect: []v1.EndpointSubset{},
+		}, {
+			name: "one set, one ip, one port",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one ip, one port (IPv6)",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "beef::1:2:3:4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "beef::1:2:3:4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one notReady ip, one port",
+			given: []v1.EndpointSubset{{
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one ip, one UID, one port",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one notReady ip, one UID, one port",
+			given: []v1.EndpointSubset{{
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one ip, empty UID, one port",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one notReady ip, empty UID, one port",
+			given: []v1.EndpointSubset{{
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("")}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("")}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, two ips, one port",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}, {IP: "5.6.7.8"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}, {IP: "5.6.7.8"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, two mixed ips, one port",
+			given: []v1.EndpointSubset{{
+				Addresses:         []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses:         []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, two duplicate ips, one port, notReady is covered by ready",
+			given: []v1.EndpointSubset{{
+				Addresses:         []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one ip, two ports",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}, {Port: 222}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}, {Port: 222}},
+			}},
+		}, {
+			name: "one set, dup ips, one port",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}, {IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, dup ips, one port (IPv6)",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "beef::1"}, {IP: "beef::1"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "beef::1"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, dup ips with target-refs, one port",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{
+					{IP: "1.2.3.4", TargetRef: &fooObjRef},
+					{IP: "1.2.3.4", TargetRef: &barObjRef},
+				},
+				Ports: []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: &fooObjRef}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, dup mixed ips with target-refs, one port",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{
+					{IP: "1.2.3.4", TargetRef: &fooObjRef},
+				},
+				NotReadyAddresses: []v1.EndpointAddress{
+					{IP: "1.2.3.4", TargetRef: &barObjRef},
+				},
+				Ports: []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				// finding the same address twice is considered an error on input, only the first address+port
+				// reference is preserved
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: &fooObjRef}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "one set, one ip, dup ports",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}, {Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, dup ip, dup port",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, dup mixed ip, dup port",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, dup ip, two ports",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 222}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}, {Port: 222}},
+			}},
+		}, {
+			name: "two sets, dup ip, dup uids, two ports",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []v1.EndpointPort{{Port: 222}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []v1.EndpointPort{{Port: 111}, {Port: 222}},
+			}},
+		}, {
+			name: "two sets, dup mixed ip, dup uids, two ports",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:             []v1.EndpointPort{{Port: 222}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:             []v1.EndpointPort{{Port: 222}},
+			}},
+		}, {
+			name: "two sets, two ips, dup port",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}, {IP: "5.6.7.8"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two set, dup ip, two uids, dup ports",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-2")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{
+					{IP: "1.2.3.4", TargetRef: podRef("uid-1")},
+					{IP: "1.2.3.4", TargetRef: podRef("uid-2")},
+				},
+				Ports: []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two set, dup ip, with and without uid, dup ports",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-2")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{
+					{IP: "1.2.3.4"},
+					{IP: "1.2.3.4", TargetRef: podRef("uid-2")},
+				},
+				Ports: []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, two ips, two dup ip with uid, dup port, wrong order",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "5.6.7.8", TargetRef: podRef("uid-1")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{
+					{IP: "1.2.3.4"},
+					{IP: "1.2.3.4", TargetRef: podRef("uid-1")},
+					{IP: "5.6.7.8"},
+					{IP: "5.6.7.8", TargetRef: podRef("uid-1")},
+				},
+				Ports: []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, two mixed ips, two dup ip with uid, dup port, wrong order, ends up with split addresses",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "5.6.7.8", TargetRef: podRef("uid-1")}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4", TargetRef: podRef("uid-1")}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:             []v1.EndpointPort{{Port: 111}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{
+					{IP: "5.6.7.8"},
+				},
+				NotReadyAddresses: []v1.EndpointAddress{
+					{IP: "1.2.3.4"},
+					{IP: "1.2.3.4", TargetRef: podRef("uid-1")},
+					{IP: "5.6.7.8", TargetRef: podRef("uid-1")},
+				},
+				Ports: []v1.EndpointPort{{Port: 111}},
+			}},
+		}, {
+			name: "two sets, two ips, two ports",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:     []v1.EndpointPort{{Port: 222}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "5.6.7.8"}},
+				Ports:     []v1.EndpointPort{{Port: 222}},
+			}},
+		}, {
+			name: "four sets, three ips, three ports, jumbled",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:     []v1.EndpointPort{{Port: 222}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.6"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:     []v1.EndpointPort{{Port: 333}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}, {IP: "1.2.3.6"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:     []v1.EndpointPort{{Port: 222}, {Port: 333}},
+			}},
+		}, {
+			name: "four sets, three mixed ips, three ports, jumbled",
+			given: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:             []v1.EndpointPort{{Port: 222}},
+			}, {
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.6"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:             []v1.EndpointPort{{Port: 333}},
+			}},
+			expect: []v1.EndpointSubset{{
+				Addresses: []v1.EndpointAddress{{IP: "1.2.3.4"}, {IP: "1.2.3.6"}},
+				Ports:     []v1.EndpointPort{{Port: 111}},
+			}, {
+				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.5"}},
+				Ports:             []v1.EndpointPort{{Port: 222}, {Port: 333}},
+			}},
+		},
+	}
+
+	for _, tc := range testCases {
+		result := RepackSubsets(tc.given)
+		if !reflect.DeepEqual(result, SortSubsets(tc.expect)) {
+			t.Errorf("case %q: expected %s, got %s", tc.name, spew.Sprintf("%#v", SortSubsets(tc.expect)), spew.Sprintf("%#v", result))
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/v1/node/BUILD

@@ -0,0 +1,26 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/v1/node",
+    deps = ["//vendor/k8s.io/api/core/v1:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/v1/node/util.go

@@ -0,0 +1,47 @@
+/*
+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.
+*/
+
+// TODO: merge with pkg/util/node
+
+package node
+
+import (
+	"k8s.io/api/core/v1"
+)
+
+// GetNodeCondition extracts the provided condition from the given status and returns that.
+// Returns nil and -1 if the condition is not present, and the index of the located condition.
+func GetNodeCondition(status *v1.NodeStatus, conditionType v1.NodeConditionType) (int, *v1.NodeCondition) {
+	if status == nil {
+		return -1, nil
+	}
+	for i := range status.Conditions {
+		if status.Conditions[i].Type == conditionType {
+			return i, &status.Conditions[i]
+		}
+	}
+	return -1, nil
+}
+
+// IsNodeReady returns true if a node is ready; false otherwise.
+func IsNodeReady(node *v1.Node) bool {
+	for _, c := range node.Status.Conditions {
+		if c.Type == v1.NodeReady {
+			return c.Status == v1.ConditionTrue
+		}
+	}
+	return false
+}

vendor/k8s.io/kubernetes/pkg/api/v1/pod/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/v1/pod",
+    deps = [
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/intstr:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/v1/pod",
+    library = ":go_default_library",
+    deps = [
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/intstr:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/v1/pod/util.go

@@ -0,0 +1,296 @@
+/*
+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 pod
+
+import (
+	"fmt"
+	"time"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
+)
+
+// FindPort locates the container port for the given pod and portName.  If the
+// targetPort is a number, use that.  If the targetPort is a string, look that
+// string up in all named ports in all containers in the target pod.  If no
+// match is found, fail.
+func FindPort(pod *v1.Pod, svcPort *v1.ServicePort) (int, error) {
+	portName := svcPort.TargetPort
+	switch portName.Type {
+	case intstr.String:
+		name := portName.StrVal
+		for _, container := range pod.Spec.Containers {
+			for _, port := range container.Ports {
+				if port.Name == name && port.Protocol == svcPort.Protocol {
+					return int(port.ContainerPort), nil
+				}
+			}
+		}
+	case intstr.Int:
+		return portName.IntValue(), nil
+	}
+
+	return 0, fmt.Errorf("no suitable port for manifest: %s", pod.UID)
+}
+
+// Visitor is called with each object name, and returns true if visiting should continue
+type Visitor func(name string) (shouldContinue bool)
+
+// VisitPodSecretNames invokes the visitor function with the name of every secret
+// referenced by the pod spec. If visitor returns false, visiting is short-circuited.
+// Transitive references (e.g. pod -> pvc -> pv -> secret) are not visited.
+// Returns true if visiting completed, false if visiting was short-circuited.
+func VisitPodSecretNames(pod *v1.Pod, visitor Visitor) bool {
+	for _, reference := range pod.Spec.ImagePullSecrets {
+		if !visitor(reference.Name) {
+			return false
+		}
+	}
+	for i := range pod.Spec.InitContainers {
+		if !visitContainerSecretNames(&pod.Spec.InitContainers[i], visitor) {
+			return false
+		}
+	}
+	for i := range pod.Spec.Containers {
+		if !visitContainerSecretNames(&pod.Spec.Containers[i], visitor) {
+			return false
+		}
+	}
+	var source *v1.VolumeSource
+
+	for i := range pod.Spec.Volumes {
+		source = &pod.Spec.Volumes[i].VolumeSource
+		switch {
+		case source.AzureFile != nil:
+			if len(source.AzureFile.SecretName) > 0 && !visitor(source.AzureFile.SecretName) {
+				return false
+			}
+		case source.CephFS != nil:
+			if source.CephFS.SecretRef != nil && !visitor(source.CephFS.SecretRef.Name) {
+				return false
+			}
+		case source.FlexVolume != nil:
+			if source.FlexVolume.SecretRef != nil && !visitor(source.FlexVolume.SecretRef.Name) {
+				return false
+			}
+		case source.Projected != nil:
+			for j := range source.Projected.Sources {
+				if source.Projected.Sources[j].Secret != nil {
+					if !visitor(source.Projected.Sources[j].Secret.Name) {
+						return false
+					}
+				}
+			}
+		case source.RBD != nil:
+			if source.RBD.SecretRef != nil && !visitor(source.RBD.SecretRef.Name) {
+				return false
+			}
+		case source.Secret != nil:
+			if !visitor(source.Secret.SecretName) {
+				return false
+			}
+		case source.ScaleIO != nil:
+			if source.ScaleIO.SecretRef != nil && !visitor(source.ScaleIO.SecretRef.Name) {
+				return false
+			}
+		case source.ISCSI != nil:
+			if source.ISCSI.SecretRef != nil && !visitor(source.ISCSI.SecretRef.Name) {
+				return false
+			}
+		case source.StorageOS != nil:
+			if source.StorageOS.SecretRef != nil && !visitor(source.StorageOS.SecretRef.Name) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func visitContainerSecretNames(container *v1.Container, visitor Visitor) bool {
+	for _, env := range container.EnvFrom {
+		if env.SecretRef != nil {
+			if !visitor(env.SecretRef.Name) {
+				return false
+			}
+		}
+	}
+	for _, envVar := range container.Env {
+		if envVar.ValueFrom != nil && envVar.ValueFrom.SecretKeyRef != nil {
+			if !visitor(envVar.ValueFrom.SecretKeyRef.Name) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// VisitPodConfigmapNames invokes the visitor function with the name of every configmap
+// referenced by the pod spec. If visitor returns false, visiting is short-circuited.
+// Transitive references (e.g. pod -> pvc -> pv -> secret) are not visited.
+// Returns true if visiting completed, false if visiting was short-circuited.
+func VisitPodConfigmapNames(pod *v1.Pod, visitor Visitor) bool {
+	for i := range pod.Spec.InitContainers {
+		if !visitContainerConfigmapNames(&pod.Spec.InitContainers[i], visitor) {
+			return false
+		}
+	}
+	for i := range pod.Spec.Containers {
+		if !visitContainerConfigmapNames(&pod.Spec.Containers[i], visitor) {
+			return false
+		}
+	}
+	var source *v1.VolumeSource
+	for i := range pod.Spec.Volumes {
+		source = &pod.Spec.Volumes[i].VolumeSource
+		switch {
+		case source.Projected != nil:
+			for j := range source.Projected.Sources {
+				if source.Projected.Sources[j].ConfigMap != nil {
+					if !visitor(source.Projected.Sources[j].ConfigMap.Name) {
+						return false
+					}
+				}
+			}
+		case source.ConfigMap != nil:
+			if !visitor(source.ConfigMap.Name) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func visitContainerConfigmapNames(container *v1.Container, visitor Visitor) bool {
+	for _, env := range container.EnvFrom {
+		if env.ConfigMapRef != nil {
+			if !visitor(env.ConfigMapRef.Name) {
+				return false
+			}
+		}
+	}
+	for _, envVar := range container.Env {
+		if envVar.ValueFrom != nil && envVar.ValueFrom.ConfigMapKeyRef != nil {
+			if !visitor(envVar.ValueFrom.ConfigMapKeyRef.Name) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// GetContainerStatus extracts the status of container "name" from "statuses".
+// It also returns if "name" exists.
+func GetContainerStatus(statuses []v1.ContainerStatus, name string) (v1.ContainerStatus, bool) {
+	for i := range statuses {
+		if statuses[i].Name == name {
+			return statuses[i], true
+		}
+	}
+	return v1.ContainerStatus{}, false
+}
+
+// GetExistingContainerStatus extracts the status of container "name" from "statuses",
+// and returns empty status if "name" does not exist.
+func GetExistingContainerStatus(statuses []v1.ContainerStatus, name string) v1.ContainerStatus {
+	for i := range statuses {
+		if statuses[i].Name == name {
+			return statuses[i]
+		}
+	}
+	return v1.ContainerStatus{}
+}
+
+// IsPodAvailable returns true if a pod is available; false otherwise.
+// Precondition for an available pod is that it must be ready. On top
+// of that, there are two cases when a pod can be considered available:
+// 1. minReadySeconds == 0, or
+// 2. LastTransitionTime (is set) + minReadySeconds < current time
+func IsPodAvailable(pod *v1.Pod, minReadySeconds int32, now metav1.Time) bool {
+	if !IsPodReady(pod) {
+		return false
+	}
+
+	c := GetPodReadyCondition(pod.Status)
+	minReadySecondsDuration := time.Duration(minReadySeconds) * time.Second
+	if minReadySeconds == 0 || !c.LastTransitionTime.IsZero() && c.LastTransitionTime.Add(minReadySecondsDuration).Before(now.Time) {
+		return true
+	}
+	return false
+}
+
+// IsPodReady returns true if a pod is ready; false otherwise.
+func IsPodReady(pod *v1.Pod) bool {
+	return IsPodReadyConditionTrue(pod.Status)
+}
+
+// IsPodReady retruns true if a pod is ready; false otherwise.
+func IsPodReadyConditionTrue(status v1.PodStatus) bool {
+	condition := GetPodReadyCondition(status)
+	return condition != nil && condition.Status == v1.ConditionTrue
+}
+
+// Extracts the pod ready condition from the given status and returns that.
+// Returns nil if the condition is not present.
+func GetPodReadyCondition(status v1.PodStatus) *v1.PodCondition {
+	_, condition := GetPodCondition(&status, v1.PodReady)
+	return condition
+}
+
+// GetPodCondition extracts the provided condition from the given status and returns that.
+// Returns nil and -1 if the condition is not present, and the index of the located condition.
+func GetPodCondition(status *v1.PodStatus, conditionType v1.PodConditionType) (int, *v1.PodCondition) {
+	if status == nil {
+		return -1, nil
+	}
+	for i := range status.Conditions {
+		if status.Conditions[i].Type == conditionType {
+			return i, &status.Conditions[i]
+		}
+	}
+	return -1, nil
+}
+
+// Updates existing pod condition or creates a new one. Sets LastTransitionTime to now if the
+// status has changed.
+// Returns true if pod condition has changed or has been added.
+func UpdatePodCondition(status *v1.PodStatus, condition *v1.PodCondition) bool {
+	condition.LastTransitionTime = metav1.Now()
+	// Try to find this pod condition.
+	conditionIndex, oldCondition := GetPodCondition(status, condition.Type)
+
+	if oldCondition == nil {
+		// We are adding new pod condition.
+		status.Conditions = append(status.Conditions, *condition)
+		return true
+	} else {
+		// We are updating an existing condition, so we need to check if it has changed.
+		if condition.Status == oldCondition.Status {
+			condition.LastTransitionTime = oldCondition.LastTransitionTime
+		}
+
+		isEqual := condition.Status == oldCondition.Status &&
+			condition.Reason == oldCondition.Reason &&
+			condition.Message == oldCondition.Message &&
+			condition.LastProbeTime.Equal(&oldCondition.LastProbeTime) &&
+			condition.LastTransitionTime.Equal(&oldCondition.LastTransitionTime)
+
+		status.Conditions[conditionIndex] = *condition
+		// Return true if one of the fields have changed.
+		return !isEqual
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/v1/pod/util_test.go

@@ -0,0 +1,406 @@
+/*
+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 pod
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+)
+
+func TestFindPort(t *testing.T) {
+	testCases := []struct {
+		name       string
+		containers []v1.Container
+		port       intstr.IntOrString
+		expected   int
+		pass       bool
+	}{{
+		name:       "valid int, no ports",
+		containers: []v1.Container{{}},
+		port:       intstr.FromInt(93),
+		expected:   93,
+		pass:       true,
+	}, {
+		name: "valid int, with ports",
+		containers: []v1.Container{{Ports: []v1.ContainerPort{{
+			Name:          "",
+			ContainerPort: 11,
+			Protocol:      "TCP",
+		}, {
+			Name:          "p",
+			ContainerPort: 22,
+			Protocol:      "TCP",
+		}}}},
+		port:     intstr.FromInt(93),
+		expected: 93,
+		pass:     true,
+	}, {
+		name:       "valid str, no ports",
+		containers: []v1.Container{{}},
+		port:       intstr.FromString("p"),
+		expected:   0,
+		pass:       false,
+	}, {
+		name: "valid str, one ctr with ports",
+		containers: []v1.Container{{Ports: []v1.ContainerPort{{
+			Name:          "",
+			ContainerPort: 11,
+			Protocol:      "UDP",
+		}, {
+			Name:          "p",
+			ContainerPort: 22,
+			Protocol:      "TCP",
+		}, {
+			Name:          "q",
+			ContainerPort: 33,
+			Protocol:      "TCP",
+		}}}},
+		port:     intstr.FromString("q"),
+		expected: 33,
+		pass:     true,
+	}, {
+		name: "valid str, two ctr with ports",
+		containers: []v1.Container{{}, {Ports: []v1.ContainerPort{{
+			Name:          "",
+			ContainerPort: 11,
+			Protocol:      "UDP",
+		}, {
+			Name:          "p",
+			ContainerPort: 22,
+			Protocol:      "TCP",
+		}, {
+			Name:          "q",
+			ContainerPort: 33,
+			Protocol:      "TCP",
+		}}}},
+		port:     intstr.FromString("q"),
+		expected: 33,
+		pass:     true,
+	}, {
+		name: "valid str, two ctr with same port",
+		containers: []v1.Container{{}, {Ports: []v1.ContainerPort{{
+			Name:          "",
+			ContainerPort: 11,
+			Protocol:      "UDP",
+		}, {
+			Name:          "p",
+			ContainerPort: 22,
+			Protocol:      "TCP",
+		}, {
+			Name:          "q",
+			ContainerPort: 22,
+			Protocol:      "TCP",
+		}}}},
+		port:     intstr.FromString("q"),
+		expected: 22,
+		pass:     true,
+	}, {
+		name: "valid str, invalid protocol",
+		containers: []v1.Container{{}, {Ports: []v1.ContainerPort{{
+			Name:          "a",
+			ContainerPort: 11,
+			Protocol:      "snmp",
+		},
+		}}},
+		port:     intstr.FromString("a"),
+		expected: 0,
+		pass:     false,
+	}, {
+		name: "valid hostPort",
+		containers: []v1.Container{{}, {Ports: []v1.ContainerPort{{
+			Name:          "a",
+			ContainerPort: 11,
+			HostPort:      81,
+			Protocol:      "TCP",
+		},
+		}}},
+		port:     intstr.FromString("a"),
+		expected: 11,
+		pass:     true,
+	},
+		{
+			name: "invalid hostPort",
+			containers: []v1.Container{{}, {Ports: []v1.ContainerPort{{
+				Name:          "a",
+				ContainerPort: 11,
+				HostPort:      -1,
+				Protocol:      "TCP",
+			},
+			}}},
+			port:     intstr.FromString("a"),
+			expected: 11,
+			pass:     true,
+			//this should fail but passes.
+		},
+		{
+			name: "invalid ContainerPort",
+			containers: []v1.Container{{}, {Ports: []v1.ContainerPort{{
+				Name:          "a",
+				ContainerPort: -1,
+				Protocol:      "TCP",
+			},
+			}}},
+			port:     intstr.FromString("a"),
+			expected: -1,
+			pass:     true,
+			//this should fail but passes
+		},
+		{
+			name: "HostIP Address",
+			containers: []v1.Container{{}, {Ports: []v1.ContainerPort{{
+				Name:          "a",
+				ContainerPort: 11,
+				HostIP:        "192.168.1.1",
+				Protocol:      "TCP",
+			},
+			}}},
+			port:     intstr.FromString("a"),
+			expected: 11,
+			pass:     true,
+		},
+	}
+
+	for _, tc := range testCases {
+		port, err := FindPort(&v1.Pod{Spec: v1.PodSpec{Containers: tc.containers}},
+			&v1.ServicePort{Protocol: "TCP", TargetPort: tc.port})
+		if err != nil && tc.pass {
+			t.Errorf("unexpected error for %s: %v", tc.name, err)
+		}
+		if err == nil && !tc.pass {
+			t.Errorf("unexpected non-error for %s: %d", tc.name, port)
+		}
+		if port != tc.expected {
+			t.Errorf("wrong result for %s: expected %d, got %d", tc.name, tc.expected, port)
+		}
+	}
+}
+
+func TestPodSecrets(t *testing.T) {
+	// Stub containing all possible secret references in a pod.
+	// The names of the referenced secrets match struct paths detected by reflection.
+	pod := &v1.Pod{
+		Spec: v1.PodSpec{
+			Containers: []v1.Container{{
+				EnvFrom: []v1.EnvFromSource{{
+					SecretRef: &v1.SecretEnvSource{
+						LocalObjectReference: v1.LocalObjectReference{
+							Name: "Spec.Containers[*].EnvFrom[*].SecretRef"}}}},
+				Env: []v1.EnvVar{{
+					ValueFrom: &v1.EnvVarSource{
+						SecretKeyRef: &v1.SecretKeySelector{
+							LocalObjectReference: v1.LocalObjectReference{
+								Name: "Spec.Containers[*].Env[*].ValueFrom.SecretKeyRef"}}}}}}},
+			ImagePullSecrets: []v1.LocalObjectReference{{
+				Name: "Spec.ImagePullSecrets"}},
+			InitContainers: []v1.Container{{
+				EnvFrom: []v1.EnvFromSource{{
+					SecretRef: &v1.SecretEnvSource{
+						LocalObjectReference: v1.LocalObjectReference{
+							Name: "Spec.InitContainers[*].EnvFrom[*].SecretRef"}}}},
+				Env: []v1.EnvVar{{
+					ValueFrom: &v1.EnvVarSource{
+						SecretKeyRef: &v1.SecretKeySelector{
+							LocalObjectReference: v1.LocalObjectReference{
+								Name: "Spec.InitContainers[*].Env[*].ValueFrom.SecretKeyRef"}}}}}}},
+			Volumes: []v1.Volume{{
+				VolumeSource: v1.VolumeSource{
+					AzureFile: &v1.AzureFileVolumeSource{
+						SecretName: "Spec.Volumes[*].VolumeSource.AzureFile.SecretName"}}}, {
+				VolumeSource: v1.VolumeSource{
+					CephFS: &v1.CephFSVolumeSource{
+						SecretRef: &v1.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.CephFS.SecretRef"}}}}, {
+				VolumeSource: v1.VolumeSource{
+					FlexVolume: &v1.FlexVolumeSource{
+						SecretRef: &v1.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.FlexVolume.SecretRef"}}}}, {
+				VolumeSource: v1.VolumeSource{
+					Projected: &v1.ProjectedVolumeSource{
+						Sources: []v1.VolumeProjection{{
+							Secret: &v1.SecretProjection{
+								LocalObjectReference: v1.LocalObjectReference{
+									Name: "Spec.Volumes[*].VolumeSource.Projected.Sources[*].Secret"}}}}}}}, {
+				VolumeSource: v1.VolumeSource{
+					RBD: &v1.RBDVolumeSource{
+						SecretRef: &v1.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.RBD.SecretRef"}}}}, {
+				VolumeSource: v1.VolumeSource{
+					Secret: &v1.SecretVolumeSource{
+						SecretName: "Spec.Volumes[*].VolumeSource.Secret.SecretName"}}}, {
+				VolumeSource: v1.VolumeSource{
+					Secret: &v1.SecretVolumeSource{
+						SecretName: "Spec.Volumes[*].VolumeSource.Secret"}}}, {
+				VolumeSource: v1.VolumeSource{
+					ScaleIO: &v1.ScaleIOVolumeSource{
+						SecretRef: &v1.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.ScaleIO.SecretRef"}}}}, {
+				VolumeSource: v1.VolumeSource{
+					ISCSI: &v1.ISCSIVolumeSource{
+						SecretRef: &v1.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.ISCSI.SecretRef"}}}}, {
+				VolumeSource: v1.VolumeSource{
+					StorageOS: &v1.StorageOSVolumeSource{
+						SecretRef: &v1.LocalObjectReference{
+							Name: "Spec.Volumes[*].VolumeSource.StorageOS.SecretRef"}}}}},
+		},
+	}
+	extractedNames := sets.NewString()
+	VisitPodSecretNames(pod, func(name string) bool {
+		extractedNames.Insert(name)
+		return true
+	})
+
+	// excludedSecretPaths holds struct paths to fields with "secret" in the name that are not actually references to secret API objects
+	excludedSecretPaths := sets.NewString(
+		"Spec.Volumes[*].VolumeSource.CephFS.SecretFile",
+	)
+	// expectedSecretPaths holds struct paths to fields with "secret" in the name that are references to secret API objects.
+	// every path here should be represented as an example in the Pod stub above, with the secret name set to the path.
+	expectedSecretPaths := sets.NewString(
+		"Spec.Containers[*].EnvFrom[*].SecretRef",
+		"Spec.Containers[*].Env[*].ValueFrom.SecretKeyRef",
+		"Spec.ImagePullSecrets",
+		"Spec.InitContainers[*].EnvFrom[*].SecretRef",
+		"Spec.InitContainers[*].Env[*].ValueFrom.SecretKeyRef",
+		"Spec.Volumes[*].VolumeSource.AzureFile.SecretName",
+		"Spec.Volumes[*].VolumeSource.CephFS.SecretRef",
+		"Spec.Volumes[*].VolumeSource.FlexVolume.SecretRef",
+		"Spec.Volumes[*].VolumeSource.Projected.Sources[*].Secret",
+		"Spec.Volumes[*].VolumeSource.RBD.SecretRef",
+		"Spec.Volumes[*].VolumeSource.Secret",
+		"Spec.Volumes[*].VolumeSource.Secret.SecretName",
+		"Spec.Volumes[*].VolumeSource.ScaleIO.SecretRef",
+		"Spec.Volumes[*].VolumeSource.ISCSI.SecretRef",
+		"Spec.Volumes[*].VolumeSource.StorageOS.SecretRef",
+	)
+	secretPaths := collectSecretPaths(t, nil, "", reflect.TypeOf(&v1.Pod{}))
+	secretPaths = secretPaths.Difference(excludedSecretPaths)
+	if missingPaths := expectedSecretPaths.Difference(secretPaths); len(missingPaths) > 0 {
+		t.Logf("Missing expected secret paths:\n%s", strings.Join(missingPaths.List(), "\n"))
+		t.Error("Missing expected secret paths. Verify VisitPodSecretNames() is correctly finding the missing paths, then correct expectedSecretPaths")
+	}
+	if extraPaths := secretPaths.Difference(expectedSecretPaths); len(extraPaths) > 0 {
+		t.Logf("Extra secret paths:\n%s", strings.Join(extraPaths.List(), "\n"))
+		t.Error("Extra fields with 'secret' in the name found. Verify VisitPodSecretNames() is including these fields if appropriate, then correct expectedSecretPaths")
+	}
+
+	if missingNames := expectedSecretPaths.Difference(extractedNames); len(missingNames) > 0 {
+		t.Logf("Missing expected secret names:\n%s", strings.Join(missingNames.List(), "\n"))
+		t.Error("Missing expected secret names. Verify the pod stub above includes these references, then verify VisitPodSecretNames() is correctly finding the missing names")
+	}
+	if extraNames := extractedNames.Difference(expectedSecretPaths); len(extraNames) > 0 {
+		t.Logf("Extra secret names:\n%s", strings.Join(extraNames.List(), "\n"))
+		t.Error("Extra secret names extracted. Verify VisitPodSecretNames() is correctly extracting secret names")
+	}
+}
+
+// collectSecretPaths traverses the object, computing all the struct paths that lead to fields with "secret" in the name.
+func collectSecretPaths(t *testing.T, path *field.Path, name string, tp reflect.Type) sets.String {
+	secretPaths := sets.NewString()
+
+	if tp.Kind() == reflect.Ptr {
+		secretPaths.Insert(collectSecretPaths(t, path, name, tp.Elem()).List()...)
+		return secretPaths
+	}
+
+	if strings.Contains(strings.ToLower(name), "secret") {
+		secretPaths.Insert(path.String())
+	}
+
+	switch tp.Kind() {
+	case reflect.Ptr:
+		secretPaths.Insert(collectSecretPaths(t, path, name, tp.Elem()).List()...)
+	case reflect.Struct:
+		for i := 0; i < tp.NumField(); i++ {
+			field := tp.Field(i)
+			secretPaths.Insert(collectSecretPaths(t, path.Child(field.Name), field.Name, field.Type).List()...)
+		}
+	case reflect.Interface:
+		t.Errorf("cannot find secret fields in interface{} field %s", path.String())
+	case reflect.Map:
+		secretPaths.Insert(collectSecretPaths(t, path.Key("*"), "", tp.Elem()).List()...)
+	case reflect.Slice:
+		secretPaths.Insert(collectSecretPaths(t, path.Key("*"), "", tp.Elem()).List()...)
+	default:
+		// all primitive types
+	}
+
+	return secretPaths
+}
+
+func newPod(now metav1.Time, ready bool, beforeSec int) *v1.Pod {
+	conditionStatus := v1.ConditionFalse
+	if ready {
+		conditionStatus = v1.ConditionTrue
+	}
+	return &v1.Pod{
+		Status: v1.PodStatus{
+			Conditions: []v1.PodCondition{
+				{
+					Type:               v1.PodReady,
+					LastTransitionTime: metav1.NewTime(now.Time.Add(-1 * time.Duration(beforeSec) * time.Second)),
+					Status:             conditionStatus,
+				},
+			},
+		},
+	}
+}
+
+func TestIsPodAvailable(t *testing.T) {
+	now := metav1.Now()
+	tests := []struct {
+		pod             *v1.Pod
+		minReadySeconds int32
+		expected        bool
+	}{
+		{
+			pod:             newPod(now, false, 0),
+			minReadySeconds: 0,
+			expected:        false,
+		},
+		{
+			pod:             newPod(now, true, 0),
+			minReadySeconds: 1,
+			expected:        false,
+		},
+		{
+			pod:             newPod(now, true, 0),
+			minReadySeconds: 0,
+			expected:        true,
+		},
+		{
+			pod:             newPod(now, true, 51),
+			minReadySeconds: 50,
+			expected:        true,
+		},
+	}
+
+	for i, test := range tests {
+		isAvailable := IsPodAvailable(test.pod, test.minReadySeconds, now)
+		if isAvailable != test.expected {
+			t.Errorf("[tc #%d] expected available pod: %t, got: %t", i, test.expected, isAvailable)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/v1/resource/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["helpers_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/v1/resource",
+    library = ":go_default_library",
+    deps = [
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["helpers.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/v1/resource",
+    deps = [
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/v1/resource/helpers.go

@@ -0,0 +1,202 @@
+/*
+Copyright 2014 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 resource
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+)
+
+// PodRequestsAndLimits returns a dictionary of all defined resources summed up for all
+// containers of the pod.
+func PodRequestsAndLimits(pod *v1.Pod) (reqs map[v1.ResourceName]resource.Quantity, limits map[v1.ResourceName]resource.Quantity) {
+	reqs, limits = map[v1.ResourceName]resource.Quantity{}, map[v1.ResourceName]resource.Quantity{}
+	for _, container := range pod.Spec.Containers {
+		for name, quantity := range container.Resources.Requests {
+			if value, ok := reqs[name]; !ok {
+				reqs[name] = *quantity.Copy()
+			} else {
+				value.Add(quantity)
+				reqs[name] = value
+			}
+		}
+		for name, quantity := range container.Resources.Limits {
+			if value, ok := limits[name]; !ok {
+				limits[name] = *quantity.Copy()
+			} else {
+				value.Add(quantity)
+				limits[name] = value
+			}
+		}
+	}
+	// init containers define the minimum of any resource
+	for _, container := range pod.Spec.InitContainers {
+		for name, quantity := range container.Resources.Requests {
+			value, ok := reqs[name]
+			if !ok {
+				reqs[name] = *quantity.Copy()
+				continue
+			}
+			if quantity.Cmp(value) > 0 {
+				reqs[name] = *quantity.Copy()
+			}
+		}
+		for name, quantity := range container.Resources.Limits {
+			value, ok := limits[name]
+			if !ok {
+				limits[name] = *quantity.Copy()
+				continue
+			}
+			if quantity.Cmp(value) > 0 {
+				limits[name] = *quantity.Copy()
+			}
+		}
+	}
+	return
+}
+
+// finds and returns the request for a specific resource.
+func GetResourceRequest(pod *v1.Pod, resource v1.ResourceName) int64 {
+	if resource == v1.ResourcePods {
+		return 1
+	}
+	totalResources := int64(0)
+	for _, container := range pod.Spec.Containers {
+		if rQuantity, ok := container.Resources.Requests[resource]; ok {
+			if resource == v1.ResourceCPU {
+				totalResources += rQuantity.MilliValue()
+			} else {
+				totalResources += rQuantity.Value()
+			}
+		}
+	}
+	// take max_resource(sum_pod, any_init_container)
+	for _, container := range pod.Spec.InitContainers {
+		if rQuantity, ok := container.Resources.Requests[resource]; ok {
+			if resource == v1.ResourceCPU && rQuantity.MilliValue() > totalResources {
+				totalResources = rQuantity.MilliValue()
+			} else if rQuantity.Value() > totalResources {
+				totalResources = rQuantity.Value()
+			}
+		}
+	}
+	return totalResources
+}
+
+// ExtractResourceValueByContainerName extracts the value of a resource
+// by providing container name
+func ExtractResourceValueByContainerName(fs *v1.ResourceFieldSelector, pod *v1.Pod, containerName string) (string, error) {
+	container, err := findContainerInPod(pod, containerName)
+	if err != nil {
+		return "", err
+	}
+	return ExtractContainerResourceValue(fs, container)
+}
+
+// ExtractResourceValueByContainerNameAndNodeAllocatable extracts the value of a resource
+// by providing container name and node allocatable
+func ExtractResourceValueByContainerNameAndNodeAllocatable(fs *v1.ResourceFieldSelector, pod *v1.Pod, containerName string, nodeAllocatable v1.ResourceList) (string, error) {
+	realContainer, err := findContainerInPod(pod, containerName)
+	if err != nil {
+		return "", err
+	}
+
+	container := realContainer.DeepCopy()
+
+	MergeContainerResourceLimits(container, nodeAllocatable)
+
+	return ExtractContainerResourceValue(fs, container)
+}
+
+// ExtractContainerResourceValue extracts the value of a resource
+// in an already known container
+func ExtractContainerResourceValue(fs *v1.ResourceFieldSelector, container *v1.Container) (string, error) {
+	divisor := resource.Quantity{}
+	if divisor.Cmp(fs.Divisor) == 0 {
+		divisor = resource.MustParse("1")
+	} else {
+		divisor = fs.Divisor
+	}
+
+	switch fs.Resource {
+	case "limits.cpu":
+		return convertResourceCPUToString(container.Resources.Limits.Cpu(), divisor)
+	case "limits.memory":
+		return convertResourceMemoryToString(container.Resources.Limits.Memory(), divisor)
+	case "limits.ephemeral-storage":
+		return convertResourceEphemeralStorageToString(container.Resources.Limits.StorageEphemeral(), divisor)
+	case "requests.cpu":
+		return convertResourceCPUToString(container.Resources.Requests.Cpu(), divisor)
+	case "requests.memory":
+		return convertResourceMemoryToString(container.Resources.Requests.Memory(), divisor)
+	case "requests.ephemeral-storage":
+		return convertResourceEphemeralStorageToString(container.Resources.Requests.StorageEphemeral(), divisor)
+	}
+
+	return "", fmt.Errorf("Unsupported container resource : %v", fs.Resource)
+}
+
+// convertResourceCPUToString converts cpu value to the format of divisor and returns
+// ceiling of the value.
+func convertResourceCPUToString(cpu *resource.Quantity, divisor resource.Quantity) (string, error) {
+	c := int64(math.Ceil(float64(cpu.MilliValue()) / float64(divisor.MilliValue())))
+	return strconv.FormatInt(c, 10), nil
+}
+
+// convertResourceMemoryToString converts memory value to the format of divisor and returns
+// ceiling of the value.
+func convertResourceMemoryToString(memory *resource.Quantity, divisor resource.Quantity) (string, error) {
+	m := int64(math.Ceil(float64(memory.Value()) / float64(divisor.Value())))
+	return strconv.FormatInt(m, 10), nil
+}
+
+// convertResourceEphemeralStorageToString converts ephemeral storage value to the format of divisor and returns
+// ceiling of the value.
+func convertResourceEphemeralStorageToString(ephemeralStorage *resource.Quantity, divisor resource.Quantity) (string, error) {
+	m := int64(math.Ceil(float64(ephemeralStorage.Value()) / float64(divisor.Value())))
+	return strconv.FormatInt(m, 10), nil
+}
+
+// findContainerInPod finds a container by its name in the provided pod
+func findContainerInPod(pod *v1.Pod, containerName string) (*v1.Container, error) {
+	for _, container := range pod.Spec.Containers {
+		if container.Name == containerName {
+			return &container, nil
+		}
+	}
+	return nil, fmt.Errorf("container %s not found", containerName)
+}
+
+// MergeContainerResourceLimits checks if a limit is applied for
+// the container, and if not, it sets the limit to the passed resource list.
+func MergeContainerResourceLimits(container *v1.Container,
+	allocatable v1.ResourceList) {
+	if container.Resources.Limits == nil {
+		container.Resources.Limits = make(v1.ResourceList)
+	}
+	for _, resource := range []v1.ResourceName{v1.ResourceCPU, v1.ResourceMemory, v1.ResourceEphemeralStorage} {
+		if quantity, exists := container.Resources.Limits[resource]; !exists || quantity.IsZero() {
+			if cap, exists := allocatable[resource]; exists {
+				container.Resources.Limits[resource] = *cap.Copy()
+			}
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/v1/resource/helpers_test.go

@@ -0,0 +1,180 @@
+/*
+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 resource
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+)
+
+func TestResourceHelpers(t *testing.T) {
+	cpuLimit := resource.MustParse("10")
+	memoryLimit := resource.MustParse("10G")
+	resourceSpec := v1.ResourceRequirements{
+		Limits: v1.ResourceList{
+			v1.ResourceCPU:    cpuLimit,
+			v1.ResourceMemory: memoryLimit,
+		},
+	}
+	if res := resourceSpec.Limits.Cpu(); res.Cmp(cpuLimit) != 0 {
+		t.Errorf("expected cpulimit %v, got %v", cpuLimit, res)
+	}
+	if res := resourceSpec.Limits.Memory(); res.Cmp(memoryLimit) != 0 {
+		t.Errorf("expected memorylimit %v, got %v", memoryLimit, res)
+	}
+	resourceSpec = v1.ResourceRequirements{
+		Limits: v1.ResourceList{
+			v1.ResourceMemory: memoryLimit,
+		},
+	}
+	if res := resourceSpec.Limits.Cpu(); res.Value() != 0 {
+		t.Errorf("expected cpulimit %v, got %v", 0, res)
+	}
+	if res := resourceSpec.Limits.Memory(); res.Cmp(memoryLimit) != 0 {
+		t.Errorf("expected memorylimit %v, got %v", memoryLimit, res)
+	}
+}
+
+func TestDefaultResourceHelpers(t *testing.T) {
+	resourceList := v1.ResourceList{}
+	if resourceList.Cpu().Format != resource.DecimalSI {
+		t.Errorf("expected %v, actual %v", resource.DecimalSI, resourceList.Cpu().Format)
+	}
+	if resourceList.Memory().Format != resource.BinarySI {
+		t.Errorf("expected %v, actual %v", resource.BinarySI, resourceList.Memory().Format)
+	}
+}
+
+func TestExtractResourceValue(t *testing.T) {
+	cases := []struct {
+		fs            *v1.ResourceFieldSelector
+		pod           *v1.Pod
+		cName         string
+		expectedValue string
+		expectedError error
+	}{
+		{
+			fs: &v1.ResourceFieldSelector{
+				Resource: "limits.cpu",
+			},
+			cName:         "foo",
+			pod:           getPod("foo", "", "9", "", ""),
+			expectedValue: "9",
+		},
+		{
+			fs: &v1.ResourceFieldSelector{
+				Resource: "requests.cpu",
+			},
+			cName:         "foo",
+			pod:           getPod("foo", "", "", "", ""),
+			expectedValue: "0",
+		},
+		{
+			fs: &v1.ResourceFieldSelector{
+				Resource: "requests.cpu",
+			},
+			cName:         "foo",
+			pod:           getPod("foo", "8", "", "", ""),
+			expectedValue: "8",
+		},
+		{
+			fs: &v1.ResourceFieldSelector{
+				Resource: "requests.cpu",
+			},
+			cName:         "foo",
+			pod:           getPod("foo", "100m", "", "", ""),
+			expectedValue: "1",
+		},
+		{
+			fs: &v1.ResourceFieldSelector{
+				Resource: "requests.cpu",
+				Divisor:  resource.MustParse("100m"),
+			},
+			cName:         "foo",
+			pod:           getPod("foo", "1200m", "", "", ""),
+			expectedValue: "12",
+		},
+		{
+			fs: &v1.ResourceFieldSelector{
+				Resource: "requests.memory",
+			},
+			cName:         "foo",
+			pod:           getPod("foo", "", "", "100Mi", ""),
+			expectedValue: "104857600",
+		},
+		{
+			fs: &v1.ResourceFieldSelector{
+				Resource: "requests.memory",
+				Divisor:  resource.MustParse("1Mi"),
+			},
+			cName:         "foo",
+			pod:           getPod("foo", "", "", "100Mi", "1Gi"),
+			expectedValue: "100",
+		},
+		{
+			fs: &v1.ResourceFieldSelector{
+				Resource: "limits.memory",
+			},
+			cName:         "foo",
+			pod:           getPod("foo", "", "", "10Mi", "100Mi"),
+			expectedValue: "104857600",
+		},
+	}
+	as := assert.New(t)
+	for idx, tc := range cases {
+		actual, err := ExtractResourceValueByContainerName(tc.fs, tc.pod, tc.cName)
+		if tc.expectedError != nil {
+			as.Equal(tc.expectedError, err, "expected test case [%d] to fail with error %v; got %v", idx, tc.expectedError, err)
+		} else {
+			as.Nil(err, "expected test case [%d] to not return an error; got %v", idx, err)
+			as.Equal(tc.expectedValue, actual, "expected test case [%d] to return %q; got %q instead", idx, tc.expectedValue, actual)
+		}
+	}
+}
+
+func getPod(cname, cpuRequest, cpuLimit, memoryRequest, memoryLimit string) *v1.Pod {
+	resources := v1.ResourceRequirements{
+		Limits:   make(v1.ResourceList),
+		Requests: make(v1.ResourceList),
+	}
+	if cpuLimit != "" {
+		resources.Limits[v1.ResourceCPU] = resource.MustParse(cpuLimit)
+	}
+	if memoryLimit != "" {
+		resources.Limits[v1.ResourceMemory] = resource.MustParse(memoryLimit)
+	}
+	if cpuRequest != "" {
+		resources.Requests[v1.ResourceCPU] = resource.MustParse(cpuRequest)
+	}
+	if memoryRequest != "" {
+		resources.Requests[v1.ResourceMemory] = resource.MustParse(memoryRequest)
+	}
+	return &v1.Pod{
+		Spec: v1.PodSpec{
+			Containers: []v1.Container{
+				{
+					Name:      cname,
+					Resources: resources,
+				},
+			},
+		},
+	}
+}

vendor/k8s.io/kubernetes/pkg/api/v1/service/BUILD

@@ -0,0 +1,41 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/v1/service",
+    deps = [
+        "//pkg/util/net/sets:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/api/v1/service",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/util/net/sets:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/api/v1/service/util.go

@@ -0,0 +1,97 @@
+/*
+Copyright 2016 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 service
+
+import (
+	"fmt"
+	"strings"
+
+	"k8s.io/api/core/v1"
+	netsets "k8s.io/kubernetes/pkg/util/net/sets"
+)
+
+const (
+	defaultLoadBalancerSourceRanges = "0.0.0.0/0"
+)
+
+// IsAllowAll checks whether the netsets.IPNet allows traffic from 0.0.0.0/0
+func IsAllowAll(ipnets netsets.IPNet) bool {
+	for _, s := range ipnets.StringSlice() {
+		if s == "0.0.0.0/0" {
+			return true
+		}
+	}
+	return false
+}
+
+// GetLoadBalancerSourceRanges first try to parse and verify LoadBalancerSourceRanges field from a service.
+// If the field is not specified, turn to parse and verify the AnnotationLoadBalancerSourceRangesKey annotation from a service,
+// extracting the source ranges to allow, and if not present returns a default (allow-all) value.
+func GetLoadBalancerSourceRanges(service *v1.Service) (netsets.IPNet, error) {
+	var ipnets netsets.IPNet
+	var err error
+	// if SourceRange field is specified, ignore sourceRange annotation
+	if len(service.Spec.LoadBalancerSourceRanges) > 0 {
+		specs := service.Spec.LoadBalancerSourceRanges
+		ipnets, err = netsets.ParseIPNets(specs...)
+
+		if err != nil {
+			return nil, fmt.Errorf("service.Spec.LoadBalancerSourceRanges: %v is not valid. Expecting a list of IP ranges. For example, 10.0.0.0/24. Error msg: %v", specs, err)
+		}
+	} else {
+		val := service.Annotations[v1.AnnotationLoadBalancerSourceRangesKey]
+		val = strings.TrimSpace(val)
+		if val == "" {
+			val = defaultLoadBalancerSourceRanges
+		}
+		specs := strings.Split(val, ",")
+		ipnets, err = netsets.ParseIPNets(specs...)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %s is not valid. Expecting a comma-separated list of source IP ranges. For example, 10.0.0.0/24,192.168.2.0/24", v1.AnnotationLoadBalancerSourceRangesKey, val)
+		}
+	}
+	return ipnets, nil
+}
+
+// RequestsOnlyLocalTraffic checks if service requests OnlyLocal traffic.
+func RequestsOnlyLocalTraffic(service *v1.Service) bool {
+	if service.Spec.Type != v1.ServiceTypeLoadBalancer &&
+		service.Spec.Type != v1.ServiceTypeNodePort {
+		return false
+	}
+	return service.Spec.ExternalTrafficPolicy == v1.ServiceExternalTrafficPolicyTypeLocal
+}
+
+// NeedsHealthCheck checks if service needs health check.
+func NeedsHealthCheck(service *v1.Service) bool {
+	if service.Spec.Type != v1.ServiceTypeLoadBalancer {
+		return false
+	}
+	return RequestsOnlyLocalTraffic(service)
+}
+
+// GetServiceHealthCheckPathPort returns the path and nodePort programmed into the Cloud LB Health Check
+func GetServiceHealthCheckPathPort(service *v1.Service) (string, int32) {
+	if !NeedsHealthCheck(service) {
+		return "", 0
+	}
+	port := service.Spec.HealthCheckNodePort
+	if port == 0 {
+		return "", 0
+	}
+	return "/healthz", port
+}

vendor/k8s.io/kubernetes/pkg/api/v1/service/util_test.go

@@ -0,0 +1,216 @@
+/*
+Copyright 2016 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 service
+
+import (
+	"strings"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	netsets "k8s.io/kubernetes/pkg/util/net/sets"
+)
+
+func TestGetLoadBalancerSourceRanges(t *testing.T) {
+	checkError := func(v string) {
+		annotations := make(map[string]string)
+		annotations[v1.AnnotationLoadBalancerSourceRangesKey] = v
+		svc := v1.Service{}
+		svc.Annotations = annotations
+		_, err := GetLoadBalancerSourceRanges(&svc)
+		if err == nil {
+			t.Errorf("Expected error parsing: %q", v)
+		}
+		svc = v1.Service{}
+		svc.Spec.LoadBalancerSourceRanges = strings.Split(v, ",")
+		_, err = GetLoadBalancerSourceRanges(&svc)
+		if err == nil {
+			t.Errorf("Expected error parsing: %q", v)
+		}
+	}
+	checkError("10.0.0.1/33")
+	checkError("foo.bar")
+	checkError("10.0.0.1/32,*")
+	checkError("10.0.0.1/32,")
+	checkError("10.0.0.1/32, ")
+	checkError("10.0.0.1")
+
+	checkOK := func(v string) netsets.IPNet {
+		annotations := make(map[string]string)
+		annotations[v1.AnnotationLoadBalancerSourceRangesKey] = v
+		svc := v1.Service{}
+		svc.Annotations = annotations
+		cidrs, err := GetLoadBalancerSourceRanges(&svc)
+		if err != nil {
+			t.Errorf("Unexpected error parsing: %q", v)
+		}
+		svc = v1.Service{}
+		svc.Spec.LoadBalancerSourceRanges = strings.Split(v, ",")
+		cidrs, err = GetLoadBalancerSourceRanges(&svc)
+		if err != nil {
+			t.Errorf("Unexpected error parsing: %q", v)
+		}
+		return cidrs
+	}
+	cidrs := checkOK("192.168.0.1/32")
+	if len(cidrs) != 1 {
+		t.Errorf("Expected exactly one CIDR: %v", cidrs.StringSlice())
+	}
+	cidrs = checkOK("192.168.0.1/32,192.168.0.1/32")
+	if len(cidrs) != 1 {
+		t.Errorf("Expected exactly one CIDR (after de-dup): %v", cidrs.StringSlice())
+	}
+	cidrs = checkOK("192.168.0.1/32,192.168.0.2/32")
+	if len(cidrs) != 2 {
+		t.Errorf("Expected two CIDRs: %v", cidrs.StringSlice())
+	}
+	cidrs = checkOK("  192.168.0.1/32 , 192.168.0.2/32   ")
+	if len(cidrs) != 2 {
+		t.Errorf("Expected two CIDRs: %v", cidrs.StringSlice())
+	}
+	// check LoadBalancerSourceRanges not specified
+	svc := v1.Service{}
+	cidrs, err := GetLoadBalancerSourceRanges(&svc)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if len(cidrs) != 1 {
+		t.Errorf("Expected exactly one CIDR: %v", cidrs.StringSlice())
+	}
+	if !IsAllowAll(cidrs) {
+		t.Errorf("Expected default to be allow-all: %v", cidrs.StringSlice())
+	}
+	// check SourceRanges annotation is empty
+	annotations := make(map[string]string)
+	annotations[v1.AnnotationLoadBalancerSourceRangesKey] = ""
+	svc = v1.Service{}
+	svc.Annotations = annotations
+	cidrs, err = GetLoadBalancerSourceRanges(&svc)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if len(cidrs) != 1 {
+		t.Errorf("Expected exactly one CIDR: %v", cidrs.StringSlice())
+	}
+	if !IsAllowAll(cidrs) {
+		t.Errorf("Expected default to be allow-all: %v", cidrs.StringSlice())
+	}
+}
+
+func TestAllowAll(t *testing.T) {
+	checkAllowAll := func(allowAll bool, cidrs ...string) {
+		ipnets, err := netsets.ParseIPNets(cidrs...)
+		if err != nil {
+			t.Errorf("Unexpected error parsing cidrs: %v", cidrs)
+		}
+		if allowAll != IsAllowAll(ipnets) {
+			t.Errorf("IsAllowAll did not return expected value for %v", cidrs)
+		}
+	}
+	checkAllowAll(false, "10.0.0.1/32")
+	checkAllowAll(false, "10.0.0.1/32", "10.0.0.2/32")
+	checkAllowAll(false, "10.0.0.1/32", "10.0.0.1/32")
+
+	checkAllowAll(true, "0.0.0.0/0")
+	checkAllowAll(true, "192.168.0.0/0")
+	checkAllowAll(true, "192.168.0.1/32", "0.0.0.0/0")
+}
+
+func TestRequestsOnlyLocalTraffic(t *testing.T) {
+	checkRequestsOnlyLocalTraffic := func(requestsOnlyLocalTraffic bool, service *v1.Service) {
+		res := RequestsOnlyLocalTraffic(service)
+		if res != requestsOnlyLocalTraffic {
+			t.Errorf("Expected requests OnlyLocal traffic = %v, got %v",
+				requestsOnlyLocalTraffic, res)
+		}
+	}
+
+	checkRequestsOnlyLocalTraffic(false, &v1.Service{})
+	checkRequestsOnlyLocalTraffic(false, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeClusterIP,
+		},
+	})
+	checkRequestsOnlyLocalTraffic(false, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeNodePort,
+		},
+	})
+	checkRequestsOnlyLocalTraffic(false, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeNodePort,
+			ExternalTrafficPolicy: v1.ServiceExternalTrafficPolicyTypeCluster,
+		},
+	})
+	checkRequestsOnlyLocalTraffic(true, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeNodePort,
+			ExternalTrafficPolicy: v1.ServiceExternalTrafficPolicyTypeLocal,
+		},
+	})
+	checkRequestsOnlyLocalTraffic(false, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeLoadBalancer,
+			ExternalTrafficPolicy: v1.ServiceExternalTrafficPolicyTypeCluster,
+		},
+	})
+	checkRequestsOnlyLocalTraffic(true, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeLoadBalancer,
+			ExternalTrafficPolicy: v1.ServiceExternalTrafficPolicyTypeLocal,
+		},
+	})
+}
+
+func TestNeedsHealthCheck(t *testing.T) {
+	checkNeedsHealthCheck := func(needsHealthCheck bool, service *v1.Service) {
+		res := NeedsHealthCheck(service)
+		if res != needsHealthCheck {
+			t.Errorf("Expected needs health check = %v, got %v",
+				needsHealthCheck, res)
+		}
+	}
+
+	checkNeedsHealthCheck(false, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeClusterIP,
+		},
+	})
+	checkNeedsHealthCheck(false, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeNodePort,
+			ExternalTrafficPolicy: v1.ServiceExternalTrafficPolicyTypeCluster,
+		},
+	})
+	checkNeedsHealthCheck(false, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeNodePort,
+			ExternalTrafficPolicy: v1.ServiceExternalTrafficPolicyTypeLocal,
+		},
+	})
+	checkNeedsHealthCheck(false, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeLoadBalancer,
+			ExternalTrafficPolicy: v1.ServiceExternalTrafficPolicyTypeCluster,
+		},
+	})
+	checkNeedsHealthCheck(true, &v1.Service{
+		Spec: v1.ServiceSpec{
+			Type: v1.ServiceTypeLoadBalancer,
+			ExternalTrafficPolicy: v1.ServiceExternalTrafficPolicyTypeLocal,
+		},
+	})
+}