Update vendor files to point to kubernetes-1.12.0-beta.1

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

@@ -108,6 +108,14 @@ func limit(aObj, bObj interface{}, max int) (string, string) {
 	elidedASuffix := ""
 	elidedBSuffix := ""
 	a, b := fmt.Sprintf("%#v", aObj), fmt.Sprintf("%#v", bObj)
+
+	if aObj != nil && bObj != nil {
+		if aType, bType := fmt.Sprintf("%T", aObj), fmt.Sprintf("%T", bObj); aType != bType {
+			a = fmt.Sprintf("%s (%s)", a, aType)
+			b = fmt.Sprintf("%s (%s)", b, bType)
+		}
+	}
+
 	for {
 		switch {
 		case len(a) > max && len(a) > 4 && len(b) > 4 && a[:4] == b[:4]:

vendor/k8s.io/apimachinery/pkg/util/diff/diff_test.go

@@ -75,6 +75,11 @@ object.A:
   a: []int(nil)
   b: []int{}`,
 		},
+		"display type differences": {a: []interface{}{int64(1)}, b: []interface{}{uint64(1)}, out: `
+object[0]:
+  a: 1 (int64)
+  b: 0x1 (uint64)`,
+		},
 	}
 	for name, test := range testCases {
 		expect := test.out

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

@@ -41,3 +41,49 @@ func ShortHumanDuration(d time.Duration) string {
 	}
 	return fmt.Sprintf("%dy", int(d.Hours()/24/365))
 }
+
+// HumanDuration returns a succint representation of the provided duration
+// with limited precision for consumption by humans. It provides ~2-3 significant
+// figures of duration.
+func HumanDuration(d time.Duration) string {
+	// Allow deviation no more than 2 seconds(excluded) to tolerate machine time
+	// inconsistence, it can be considered as almost now.
+	if seconds := int(d.Seconds()); seconds < -1 {
+		return fmt.Sprintf("<invalid>")
+	} else if seconds < 0 {
+		return fmt.Sprintf("0s")
+	} else if seconds < 60*2 {
+		return fmt.Sprintf("%ds", seconds)
+	}
+	minutes := int(d / time.Minute)
+	if minutes < 10 {
+		s := int(d/time.Second) % 60
+		if s == 0 {
+			return fmt.Sprintf("%dm", minutes)
+		}
+		return fmt.Sprintf("%dm%ds", minutes, s)
+	} else if minutes < 60*3 {
+		return fmt.Sprintf("%dm", minutes)
+	}
+	hours := int(d / time.Hour)
+	if hours < 8 {
+		m := int(d/time.Minute) % 60
+		if m == 0 {
+			return fmt.Sprintf("%dh", hours)
+		}
+		return fmt.Sprintf("%dh%dm", hours, m)
+	} else if hours < 48 {
+		return fmt.Sprintf("%dh", hours)
+	} else if hours < 24*8 {
+		h := hours % 24
+		if h == 0 {
+			return fmt.Sprintf("%dd", hours/24)
+		}
+		return fmt.Sprintf("%dd%dh", hours/24, h)
+	} else if hours < 24*365*2 {
+		return fmt.Sprintf("%dd", hours/24)
+	} else if hours < 24*365*8 {
+		return fmt.Sprintf("%dy%dd", hours/24/365, (hours/24)%365)
+	}
+	return fmt.Sprintf("%dy", int(hours/24/365))
+}

vendor/k8s.io/apimachinery/pkg/util/duration/duration_test.go

@@ -0,0 +1,47 @@
+/*
+Copyright 2018 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 duration
+
+import (
+	"testing"
+	"time"
+)
+
+func TestHumanDuration(t *testing.T) {
+	tests := []struct {
+		d    time.Duration
+		want string
+	}{
+		{d: time.Second, want: "1s"},
+		{d: 70 * time.Second, want: "70s"},
+		{d: 190 * time.Second, want: "3m10s"},
+		{d: 70 * time.Minute, want: "70m"},
+		{d: 47 * time.Hour, want: "47h"},
+		{d: 49 * time.Hour, want: "2d1h"},
+		{d: (8*24 + 2) * time.Hour, want: "8d"},
+		{d: (367 * 24) * time.Hour, want: "367d"},
+		{d: (365*2*24 + 25) * time.Hour, want: "2y1d"},
+		{d: (365*8*24 + 2) * time.Hour, want: "8y"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.d.String(), func(t *testing.T) {
+			if got := HumanDuration(tt.d); got != tt.want {
+				t.Errorf("HumanDuration() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

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

@@ -18,6 +18,7 @@ package intstr
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math"
 	"runtime/debug"
@@ -142,7 +143,17 @@ func (intstr *IntOrString) Fuzz(c fuzz.Continue) {
 	}
 }
 
+func ValueOrDefault(intOrPercent *IntOrString, defaultValue IntOrString) *IntOrString {
+	if intOrPercent == nil {
+		return &defaultValue
+	}
+	return intOrPercent
+}
+
 func GetValueFromIntOrPercent(intOrPercent *IntOrString, total int, roundUp bool) (int, error) {
+	if intOrPercent == nil {
+		return 0, errors.New("nil value for IntOrString")
+	}
 	value, isPercent, err := getIntOrPercentValue(intOrPercent)
 	if err != nil {
 		return 0, fmt.Errorf("invalid value for IntOrString: %v", err)

vendor/k8s.io/apimachinery/pkg/util/intstr/intstr_test.go

@@ -174,3 +174,10 @@ func TestGetValueFromIntOrPercent(t *testing.T) {
 		}
 	}
 }
+
+func TestGetValueFromIntOrPercentNil(t *testing.T) {
+	_, err := GetValueFromIntOrPercent(nil, 0, false)
+	if err == nil {
+		t.Errorf("expected error got none")
+	}
+}

vendor/k8s.io/apimachinery/pkg/util/jsonmergepatch/patch.go

@@ -136,7 +136,7 @@ func keepOrDeleteNullInObj(m map[string]interface{}, keepNull bool) (map[string]
 					filteredMap[key] = filteredSubMap
 				}
 
-			case []interface{}, string, float64, bool, int, int64, nil:
+			case []interface{}, string, float64, bool, int64, nil:
 				// Lists are always replaced in Json, no need to check each entry in the list.
 				if !keepNull {
 					filteredMap[key] = val

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

@@ -125,7 +125,7 @@ func HasConflicts(left, right interface{}) (bool, error) {
 		default:
 			return true, nil
 		}
-	case string, float64, bool, int, int64, nil:
+	case string, float64, bool, int64, nil:
 		return !reflect.DeepEqual(left, right), nil
 	default:
 		return true, fmt.Errorf("unknown type: %v", reflect.TypeOf(left))

vendor/k8s.io/apimachinery/pkg/util/mergepatch/util_test.go

@@ -30,82 +30,80 @@ func TestHasConflicts(t *testing.T) {
 		{A: "hello", B: "hello", Ret: false},
 		{A: "hello", B: "hell", Ret: true},
 		{A: "hello", B: nil, Ret: true},
-		{A: "hello", B: 1, Ret: true},
+		{A: "hello", B: int64(1), Ret: true},
 		{A: "hello", B: float64(1.0), Ret: true},
 		{A: "hello", B: false, Ret: true},
-		{A: 1, B: 1, Ret: false},
+		{A: int64(1), B: int64(1), Ret: false},
 		{A: nil, B: nil, Ret: false},
 		{A: false, B: false, Ret: false},
 		{A: float64(3), B: float64(3), Ret: false},
 
 		{A: "hello", B: []interface{}{}, Ret: true},
-		{A: []interface{}{1}, B: []interface{}{}, Ret: true},
+		{A: []interface{}{int64(1)}, B: []interface{}{}, Ret: true},
 		{A: []interface{}{}, B: []interface{}{}, Ret: false},
-		{A: []interface{}{1}, B: []interface{}{1}, Ret: false},
-		{A: map[string]interface{}{}, B: []interface{}{1}, Ret: true},
+		{A: []interface{}{int64(1)}, B: []interface{}{int64(1)}, Ret: false},
+		{A: map[string]interface{}{}, B: []interface{}{int64(1)}, Ret: true},
 
-		{A: map[string]interface{}{}, B: map[string]interface{}{"a": 1}, Ret: false},
-		{A: map[string]interface{}{"a": 1}, B: map[string]interface{}{"a": 1}, Ret: false},
-		{A: map[string]interface{}{"a": 1}, B: map[string]interface{}{"a": 2}, Ret: true},
-		{A: map[string]interface{}{"a": 1}, B: map[string]interface{}{"b": 2}, Ret: false},
+		{A: map[string]interface{}{}, B: map[string]interface{}{"a": int64(1)}, Ret: false},
+		{A: map[string]interface{}{"a": int64(1)}, B: map[string]interface{}{"a": int64(1)}, Ret: false},
+		{A: map[string]interface{}{"a": int64(1)}, B: map[string]interface{}{"a": int64(2)}, Ret: true},
+		{A: map[string]interface{}{"a": int64(1)}, B: map[string]interface{}{"b": int64(2)}, Ret: false},
 
 		{
-			A:   map[string]interface{}{"a": []interface{}{1}},
-			B:   map[string]interface{}{"a": []interface{}{1}},
+			A:   map[string]interface{}{"a": []interface{}{int64(1)}},
+			B:   map[string]interface{}{"a": []interface{}{int64(1)}},
 			Ret: false,
 		},
 		{
-			A:   map[string]interface{}{"a": []interface{}{1}},
+			A:   map[string]interface{}{"a": []interface{}{int64(1)}},
 			B:   map[string]interface{}{"a": []interface{}{}},
 			Ret: true,
 		},
 		{
-			A:   map[string]interface{}{"a": []interface{}{1}},
-			B:   map[string]interface{}{"a": 1},
+			A:   map[string]interface{}{"a": []interface{}{int64(1)}},
+			B:   map[string]interface{}{"a": int64(1)},
 			Ret: true,
 		},
 
 		// Maps and lists with multiple entries.
 		{
-			A:   map[string]interface{}{"a": 1, "b": 2},
-			B:   map[string]interface{}{"a": 1, "b": 0},
+			A:   map[string]interface{}{"a": int64(1), "b": int64(2)},
+			B:   map[string]interface{}{"a": int64(1), "b": int64(0)},
 			Ret: true,
 		},
 		{
-			A:   map[string]interface{}{"a": 1, "b": 2},
-			B:   map[string]interface{}{"a": 1, "b": 2},
+			A:   map[string]interface{}{"a": int64(1), "b": int64(2)},
+			B:   map[string]interface{}{"a": int64(1), "b": int64(2)},
 			Ret: false,
 		},
 		{
-			A:   map[string]interface{}{"a": 1, "b": 2},
-			B:   map[string]interface{}{"a": 1, "b": 0, "c": 3},
+			A:   map[string]interface{}{"a": int64(1), "b": int64(2)},
+			B:   map[string]interface{}{"a": int64(1), "b": int64(0), "c": int64(3)},
 			Ret: true,
 		},
 		{
-			A:   map[string]interface{}{"a": 1, "b": 2},
-			B:   map[string]interface{}{"a": 1, "b": 2, "c": 3},
+			A:   map[string]interface{}{"a": int64(1), "b": int64(2)},
+			B:   map[string]interface{}{"a": int64(1), "b": int64(2), "c": int64(3)},
 			Ret: false,
 		},
 		{
-			A:   map[string]interface{}{"a": []interface{}{1, 2}},
-			B:   map[string]interface{}{"a": []interface{}{1, 0}},
+			A:   map[string]interface{}{"a": []interface{}{int64(1), int64(2)}},
+			B:   map[string]interface{}{"a": []interface{}{int64(1), int64(0)}},
 			Ret: true,
 		},
 		{
-			A:   map[string]interface{}{"a": []interface{}{1, 2}},
-			B:   map[string]interface{}{"a": []interface{}{1, 2}},
+			A:   map[string]interface{}{"a": []interface{}{int64(1), int64(2)}},
+			B:   map[string]interface{}{"a": []interface{}{int64(1), int64(2)}},
 			Ret: false,
 		},
 
 		// Numeric types are not interchangeable.
 		// Callers are expected to ensure numeric types are consistent in 'left' and 'right'.
-		{A: int(0), B: int64(0), Ret: true},
-		{A: int(0), B: float64(0), Ret: true},
 		{A: int64(0), B: float64(0), Ret: true},
 		// Other types are not interchangeable.
-		{A: int(0), B: "0", Ret: true},
-		{A: int(0), B: nil, Ret: true},
-		{A: int(0), B: false, Ret: true},
+		{A: int64(0), B: "0", Ret: true},
+		{A: int64(0), B: nil, Ret: true},
+		{A: int64(0), B: false, Ret: true},
 		{A: "true", B: true, Ret: true},
 		{A: "null", B: nil, Ret: true},
 	}

vendor/k8s.io/apimachinery/pkg/util/naming/from_stack.go

@@ -0,0 +1,93 @@
+/*
+Copyright 2018 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 naming
+
+import (
+	"fmt"
+	"regexp"
+	goruntime "runtime"
+	"runtime/debug"
+	"strconv"
+	"strings"
+)
+
+// GetNameFromCallsite walks back through the call stack until we find a caller from outside of the ignoredPackages
+// it returns back a shortpath/filename:line to aid in identification of this reflector when it starts logging
+func GetNameFromCallsite(ignoredPackages ...string) string {
+	name := "????"
+	const maxStack = 10
+	for i := 1; i < maxStack; i++ {
+		_, file, line, ok := goruntime.Caller(i)
+		if !ok {
+			file, line, ok = extractStackCreator()
+			if !ok {
+				break
+			}
+			i += maxStack
+		}
+		if hasPackage(file, append(ignoredPackages, "/runtime/asm_")) {
+			continue
+		}
+
+		file = trimPackagePrefix(file)
+		name = fmt.Sprintf("%s:%d", file, line)
+		break
+	}
+	return name
+}
+
+// hasPackage returns true if the file is in one of the ignored packages.
+func hasPackage(file string, ignoredPackages []string) bool {
+	for _, ignoredPackage := range ignoredPackages {
+		if strings.Contains(file, ignoredPackage) {
+			return true
+		}
+	}
+	return false
+}
+
+// trimPackagePrefix reduces duplicate values off the front of a package name.
+func trimPackagePrefix(file string) string {
+	if l := strings.LastIndex(file, "/vendor/"); l >= 0 {
+		return file[l+len("/vendor/"):]
+	}
+	if l := strings.LastIndex(file, "/src/"); l >= 0 {
+		return file[l+5:]
+	}
+	if l := strings.LastIndex(file, "/pkg/"); l >= 0 {
+		return file[l+1:]
+	}
+	return file
+}
+
+var stackCreator = regexp.MustCompile(`(?m)^created by (.*)\n\s+(.*):(\d+) \+0x[[:xdigit:]]+$`)
+
+// extractStackCreator retrieves the goroutine file and line that launched this stack. Returns false
+// if the creator cannot be located.
+// TODO: Go does not expose this via runtime https://github.com/golang/go/issues/11440
+func extractStackCreator() (string, int, bool) {
+	stack := debug.Stack()
+	matches := stackCreator.FindStringSubmatch(string(stack))
+	if matches == nil || len(matches) != 4 {
+		return "", 0, false
+	}
+	line, err := strconv.Atoi(matches[3])
+	if err != nil {
+		return "", 0, false
+	}
+	return matches[2], line, true
+}

vendor/k8s.io/apimachinery/pkg/util/naming/from_stack_test.go

@@ -0,0 +1,56 @@
+/*
+Copyright 2018 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 naming
+
+import "testing"
+
+func TestGetNameFromCallsite(t *testing.T) {
+	tests := []struct {
+		name            string
+		ignoredPackages []string
+		expected        string
+	}{
+		{
+			name:     "simple",
+			expected: "k8s.io/apimachinery/pkg/util/naming/from_stack_test.go:50",
+		},
+		{
+			name:            "ignore-package",
+			ignoredPackages: []string{"k8s.io/apimachinery/pkg/util/naming"},
+			expected:        "testing/testing.go:777",
+		},
+		{
+			name:            "ignore-file",
+			ignoredPackages: []string{"k8s.io/apimachinery/pkg/util/naming/from_stack_test.go"},
+			expected:        "testing/testing.go:777",
+		},
+		{
+			name:            "ignore-multiple",
+			ignoredPackages: []string{"k8s.io/apimachinery/pkg/util/naming/from_stack_test.go", "testing/testing.go"},
+			expected:        "????",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := GetNameFromCallsite(tc.ignoredPackages...)
+			if tc.expected != actual {
+				t.Fatalf("expected %q, got %q", tc.expected, actual)
+			}
+		})
+	}
+}

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

@@ -91,7 +91,8 @@ func SetOldTransportDefaults(t *http.Transport) *http.Transport {
 		// ProxierWithNoProxyCIDR allows CIDR rules in NO_PROXY
 		t.Proxy = NewProxierWithNoProxyCIDR(http.ProxyFromEnvironment)
 	}
-	if t.DialContext == nil {
+	// If no custom dialer is set, use the default context dialer
+	if t.DialContext == nil && t.Dial == nil {
 		t.DialContext = defaultTransport.DialContext
 	}
 	if t.TLSHandshakeTimeout == 0 {
@@ -129,7 +130,18 @@ func DialerFor(transport http.RoundTripper) (DialFunc, error) {
 
 	switch transport := transport.(type) {
 	case *http.Transport:
-		return transport.DialContext, nil
+		// transport.DialContext takes precedence over transport.Dial
+		if transport.DialContext != nil {
+			return transport.DialContext, nil
+		}
+		// adapt transport.Dial to the DialWithContext signature
+		if transport.Dial != nil {
+			return func(ctx context.Context, net, addr string) (net.Conn, error) {
+				return transport.Dial(net, addr)
+			}, nil
+		}
+		// otherwise return nil
+		return nil, nil
 	case RoundTripperWrapper:
 		return DialerFor(transport.WrappedRoundTripper())
 	default:
@@ -167,10 +179,8 @@ func FormatURL(scheme string, host string, port int, path string) *url.URL {
 }
 
 func GetHTTPClient(req *http.Request) string {
-	if userAgent, ok := req.Header["User-Agent"]; ok {
-		if len(userAgent) > 0 {
-			return userAgent[0]
-		}
+	if ua := req.UserAgent(); len(ua) != 0 {
+		return ua
 	}
 	return "unknown"
 }

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

@@ -53,6 +53,28 @@ type RouteFile struct {
 	parse func(input io.Reader) ([]Route, error)
 }
 
+// noRoutesError can be returned by ChooseBindAddress() in case of no routes
+type noRoutesError struct {
+	message string
+}
+
+func (e noRoutesError) Error() string {
+	return e.message
+}
+
+// IsNoRoutesError checks if an error is of type noRoutesError
+func IsNoRoutesError(err error) bool {
+	if err == nil {
+		return false
+	}
+	switch err.(type) {
+	case noRoutesError:
+		return true
+	default:
+		return false
+	}
+}
+
 var (
 	v4File = RouteFile{name: ipv4RouteFile, parse: getIPv4DefaultRoutes}
 	v6File = RouteFile{name: ipv6RouteFile, parse: getIPv6DefaultRoutes}
@@ -347,7 +369,9 @@ func getAllDefaultRoutes() ([]Route, error) {
 	v6Routes, _ := v6File.extract()
 	routes = append(routes, v6Routes...)
 	if len(routes) == 0 {
-		return nil, fmt.Errorf("No default routes.")
+		return nil, noRoutesError{
+			message: fmt.Sprintf("no default routes found in %q or %q", v4File.name, v6File.name),
+		}
 	}
 	return routes, nil
 }

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

@@ -669,7 +669,7 @@ func TestGetAllDefaultRoutes(t *testing.T) {
 		expected   []Route
 		errStrFrag string
 	}{
-		{"no routes", noInternetConnection, v6noDefaultRoutes, 0, nil, "No default routes"},
+		{"no routes", noInternetConnection, v6noDefaultRoutes, 0, nil, "no default routes"},
 		{"only v4 route", gatewayfirst, v6noDefaultRoutes, 1, routeV4, ""},
 		{"only v6 route", noInternetConnection, v6gatewayfirst, 1, routeV6, ""},
 		{"v4 and v6 routes", gatewayfirst, v6gatewayfirst, 2, bothRoutes, ""},

vendor/k8s.io/apimachinery/pkg/util/proxy/upgradeaware.go

@@ -27,7 +27,6 @@ import (
 	"net/http/httputil"
 	"net/url"
 	"strings"
-	"sync"
 	"time"
 
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -294,9 +293,12 @@ func (h *UpgradeAwareHandler) tryUpgrade(w http.ResponseWriter, req *http.Reques
 		}
 	}
 
-	// Proxy the connection.
-	wg := &sync.WaitGroup{}
-	wg.Add(2)
+	// Proxy the connection. This is bidirectional, so we need a goroutine
+	// to copy in each direction. Once one side of the connection exits, we
+	// exit the function which performs cleanup and in the process closes
+	// the other half of the connection in the defer.
+	writerComplete := make(chan struct{})
+	readerComplete := make(chan struct{})
 
 	go func() {
 		var writer io.WriteCloser
@@ -309,7 +311,7 @@ func (h *UpgradeAwareHandler) tryUpgrade(w http.ResponseWriter, req *http.Reques
 		if err != nil && !strings.Contains(err.Error(), "use of closed network connection") {
 			glog.Errorf("Error proxying data from client to backend: %v", err)
 		}
-		wg.Done()
+		close(writerComplete)
 	}()
 
 	go func() {
@@ -323,10 +325,17 @@ func (h *UpgradeAwareHandler) tryUpgrade(w http.ResponseWriter, req *http.Reques
 		if err != nil && !strings.Contains(err.Error(), "use of closed network connection") {
 			glog.Errorf("Error proxying data from backend to client: %v", err)
 		}
-		wg.Done()
+		close(readerComplete)
 	}()
 
-	wg.Wait()
+	// Wait for one half the connection to exit. Once it does the defer will
+	// clean up the other half of the connection.
+	select {
+	case <-writerComplete:
+	case <-readerComplete:
+	}
+	glog.V(6).Infof("Disconnecting from backend proxy %s\n  Headers: %v", &location, clone.Header)
+
 	return true
 }
 

vendor/k8s.io/apimachinery/pkg/util/strategicpatch/OWNERS

@@ -1,5 +1,6 @@
 approvers:
 - pwittrock
+- mengqiy
 reviewers:
 - mengqiy
 - apelisse

vendor/k8s.io/apimachinery/pkg/util/strategicpatch/patch.go

@@ -1876,7 +1876,7 @@ func mergingMapFieldsHaveConflicts(
 			return true, nil
 		}
 		return slicesHaveConflicts(leftType, rightType, schema, fieldPatchStrategy, fieldPatchMergeKey)
-	case string, float64, bool, int, int64, nil:
+	case string, float64, bool, int64, nil:
 		return !reflect.DeepEqual(left, right), nil
 	default:
 		return true, fmt.Errorf("unknown type: %v", reflect.TypeOf(left))

vendor/k8s.io/apimachinery/pkg/util/validation/field/errors.go

@@ -48,7 +48,7 @@ func (v *Error) ErrorBody() string {
 	var s string
 	switch v.Type {
 	case ErrorTypeRequired, ErrorTypeForbidden, ErrorTypeTooLong, ErrorTypeInternal:
-		s = fmt.Sprintf("%s", v.Type)
+		s = v.Type.String()
 	default:
 		value := v.BadValue
 		valueType := reflect.TypeOf(value)

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

@@ -21,6 +21,7 @@ import (
 	"math"
 	"net"
 	"regexp"
+	"strconv"
 	"strings"
 
 	"k8s.io/apimachinery/pkg/util/validation/field"
@@ -389,3 +390,18 @@ func hasChDirPrefix(value string) []string {
 	}
 	return errs
 }
+
+// IsSocketAddr checks that a string conforms is a valid socket address
+// as defined in RFC 789. (e.g 0.0.0.0:10254 or [::]:10254))
+func IsValidSocketAddr(value string) []string {
+	var errs []string
+	ip, port, err := net.SplitHostPort(value)
+	if err != nil {
+		return append(errs, "must be a valid socket address format, (e.g. 0.0.0.0:10254 or [::]:10254)")
+		return errs
+	}
+	portInt, _ := strconv.Atoi(port)
+	errs = append(errs, IsValidPortNum(portInt)...)
+	errs = append(errs, IsValidIP(ip)...)
+	return errs
+}

vendor/k8s.io/apimachinery/pkg/util/validation/validation_test.go

@@ -511,3 +511,31 @@ func TestIsFullyQualifiedName(t *testing.T) {
 		}
 	}
 }
+
+func TestIsValidSocketAddr(t *testing.T) {
+	goodValues := []string{
+		"0.0.0.0:10254",
+		"127.0.0.1:8888",
+		"[2001:db8:1f70::999:de8:7648:6e8]:10254",
+		"[::]:10254",
+	}
+	for _, val := range goodValues {
+		if errs := IsValidSocketAddr(val); len(errs) != 0 {
+			t.Errorf("expected no errors for %q: %v", val, errs)
+		}
+	}
+
+	badValues := []string{
+		"0.0.0.0.0:2020",
+		"0.0.0.0",
+		"6.6.6.6:909090",
+		"2001:db8:1f70::999:de8:7648:6e8:87567:102545",
+		"",
+		"*",
+	}
+	for _, val := range badValues {
+		if errs := IsValidSocketAddr(val); len(errs) == 0 {
+			t.Errorf("expected errors for %q", val)
+		}
+	}
+}

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

@@ -230,13 +230,13 @@ func pollInternal(wait WaitFunc, condition ConditionFunc) error {
 // PollImmediate tries a condition func until it returns true, an error, or the timeout
 // is reached.
 //
-// Poll always checks 'condition' before waiting for the interval. 'condition'
+// PollImmediate always checks 'condition' before waiting for the interval. 'condition'
 // will always be invoked at least once.
 //
 // Some intervals may be missed if the condition takes too long or the time
 // window is too short.
 //
-// If you want to Poll something forever, see PollInfinite.
+// If you want to immediately Poll something forever, see PollImmediateInfinite.
 func PollImmediate(interval, timeout time.Duration, condition ConditionFunc) error {
 	return pollImmediateInternal(poller(interval, timeout), condition)
 }