rebase: update kubernetes to v1.21.2

Updated kubernetes packages to latest release.
resizefs package has been included into k8s.io/mount-utils
package. updated code to use the same.

Updates: #1968

Signed-off-by: Rakshith R <rar@redhat.com>

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

@@ -34,6 +34,7 @@ type PassiveClock interface {
 type Clock interface {
 	PassiveClock
 	After(time.Duration) <-chan time.Time
+	AfterFunc(time.Duration, func()) Timer
 	NewTimer(time.Duration) Timer
 	Sleep(time.Duration)
 	NewTicker(time.Duration) Ticker
@@ -57,6 +58,13 @@ func (RealClock) After(d time.Duration) <-chan time.Time {
 	return time.After(d)
 }
 
+// AfterFunc is the same as time.AfterFunc(d, f).
+func (RealClock) AfterFunc(d time.Duration, f func()) Timer {
+	return &realTimer{
+		timer: time.AfterFunc(d, f),
+	}
+}
+
 // NewTimer returns a new Timer.
 func (RealClock) NewTimer(d time.Duration) Timer {
 	return &realTimer{
@@ -95,6 +103,7 @@ type fakeClockWaiter struct {
 	stepInterval  time.Duration
 	skipIfBlocked bool
 	destChan      chan time.Time
+	afterFunc     func()
 }
 
 // NewFakePassiveClock returns a new FakePassiveClock.
@@ -145,6 +154,25 @@ func (f *FakeClock) After(d time.Duration) <-chan time.Time {
 	return ch
 }
 
+// AfterFunc is the Fake version of time.AfterFunc(d, callback).
+func (f *FakeClock) AfterFunc(d time.Duration, cb func()) Timer {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+	stopTime := f.time.Add(d)
+	ch := make(chan time.Time, 1) // Don't block!
+
+	timer := &fakeTimer{
+		fakeClock: f,
+		waiter: fakeClockWaiter{
+			targetTime: stopTime,
+			destChan:   ch,
+			afterFunc:  cb,
+		},
+	}
+	f.waiters = append(f.waiters, timer.waiter)
+	return timer
+}
+
 // NewTimer is the Fake version of time.NewTimer(d).
 func (f *FakeClock) NewTimer(d time.Duration) Timer {
 	f.lock.Lock()
@@ -211,6 +239,10 @@ func (f *FakeClock) setTimeLocked(t time.Time) {
 				w.destChan <- t
 			}
 
+			if w.afterFunc != nil {
+				w.afterFunc()
+			}
+
 			if w.stepInterval > 0 {
 				for !w.targetTime.After(t) {
 					w.targetTime = w.targetTime.Add(w.stepInterval)
@@ -225,8 +257,8 @@ func (f *FakeClock) setTimeLocked(t time.Time) {
 	f.waiters = newWaiters
 }
 
-// HasWaiters returns true if After has been called on f but not yet satisfied (so you can
-// write race-free tests).
+// HasWaiters returns true if After or AfterFunc has been called on f but not yet satisfied
+// (so you can write race-free tests).
 func (f *FakeClock) HasWaiters() bool {
 	f.lock.RLock()
 	defer f.lock.RUnlock()
@@ -261,6 +293,12 @@ func (*IntervalClock) After(d time.Duration) <-chan time.Time {
 	panic("IntervalClock doesn't implement After")
 }
 
+// AfterFunc is currently unimplemented, will panic.
+// TODO: make interval clock use FakeClock so this can be implemented.
+func (*IntervalClock) AfterFunc(d time.Duration, cb func()) Timer {
+	panic("IntervalClock doesn't implement AfterFunc")
+}
+
 // NewTimer is currently unimplemented, will panic.
 // TODO: make interval clock use FakeClock so this can be implemented.
 func (*IntervalClock) NewTimer(d time.Duration) Timer {

vendor/k8s.io/apimachinery/pkg/util/httpstream/spdy/connection.go

@@ -22,7 +22,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/docker/spdystream"
+	"github.com/moby/spdystream"
 	"k8s.io/apimachinery/pkg/util/httpstream"
 	"k8s.io/klog/v2"
 )

vendor/k8s.io/apimachinery/pkg/util/managedfields/extract.go

@@ -0,0 +1,86 @@
+/*
+Copyright 2021 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 managedfields
+
+import (
+	"bytes"
+	"fmt"
+
+	"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
+	"sigs.k8s.io/structured-merge-diff/v4/typed"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+// ExtractInto extracts the applied configuration state from object for fieldManager
+// into applyConfiguration. If no managed fields are found for the given fieldManager,
+// no error is returned, but applyConfiguration is left unpopulated. It is possible
+// that no managed fields were found for the fieldManager because other field managers
+// have taken ownership of all the fields previously owned by the fieldManager. It is
+// also possible the fieldManager never owned fields.
+func ExtractInto(object runtime.Object, objectType typed.ParseableType, fieldManager string, applyConfiguration interface{}) error {
+	typedObj, err := toTyped(object, objectType)
+	if err != nil {
+		return fmt.Errorf("error converting obj to typed: %w", err)
+	}
+
+	accessor, err := meta.Accessor(object)
+	if err != nil {
+		return fmt.Errorf("error accessing metadata: %w", err)
+	}
+	fieldsEntry, ok := findManagedFields(accessor, fieldManager)
+	if !ok {
+		return nil
+	}
+	fieldset := &fieldpath.Set{}
+	err = fieldset.FromJSON(bytes.NewReader(fieldsEntry.FieldsV1.Raw))
+	if err != nil {
+		return fmt.Errorf("error marshalling FieldsV1 to JSON: %w", err)
+	}
+
+	u := typedObj.ExtractItems(fieldset.Leaves()).AsValue().Unstructured()
+	m, ok := u.(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("unable to convert managed fields for %s to unstructured, expected map, got %T", fieldManager, u)
+	}
+	if err := runtime.DefaultUnstructuredConverter.FromUnstructured(m, applyConfiguration); err != nil {
+		return fmt.Errorf("error extracting into obj from unstructured: %w", err)
+	}
+	return nil
+}
+
+func findManagedFields(accessor metav1.Object, fieldManager string) (metav1.ManagedFieldsEntry, bool) {
+	objManagedFields := accessor.GetManagedFields()
+	for _, mf := range objManagedFields {
+		if mf.Manager == fieldManager && mf.Operation == metav1.ManagedFieldsOperationApply {
+			return mf, true
+		}
+	}
+	return metav1.ManagedFieldsEntry{}, false
+}
+
+func toTyped(obj runtime.Object, objectType typed.ParseableType) (*typed.TypedValue, error) {
+	switch o := obj.(type) {
+	case *unstructured.Unstructured:
+		return objectType.FromUnstructured(o.Object)
+	default:
+		return objectType.FromStructured(o)
+	}
+}

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

@@ -131,7 +131,7 @@ func SetTransportDefaults(t *http.Transport) *http.Transport {
 	t = SetOldTransportDefaults(t)
 	// Allow clients to disable http2 if needed.
 	if s := os.Getenv("DISABLE_HTTP2"); len(s) > 0 {
-		klog.Infof("HTTP2 has been explicitly disabled")
+		klog.Info("HTTP2 has been explicitly disabled")
 	} else if allowsHTTP2(t) {
 		if err := configureHTTP2Transport(t); err != nil {
 			klog.Warningf("Transport failed http2 configuration: %v", err)
@@ -693,7 +693,7 @@ func parseQuotedString(quotedString string) (string, string, error) {
 	var remainder string
 	escaping := false
 	closedQuote := false
-	result := &bytes.Buffer{}
+	result := &strings.Builder{}
 loop:
 	for i := 0; i < len(quotedString); i++ {
 		b := quotedString[i]

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

@@ -266,6 +266,36 @@ func getIPFromInterface(intfName string, forFamily AddressFamily, nw networkInte
 	return nil, nil
 }
 
+// getIPFromLoopbackInterface gets the IPs on a loopback interface and returns a global unicast address, if any.
+// The loopback interface must be up, the IP must in the family requested, and the IP must be a global unicast address.
+func getIPFromLoopbackInterface(forFamily AddressFamily, nw networkInterfacer) (net.IP, error) {
+	intfs, err := nw.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+	for _, intf := range intfs {
+		if !isInterfaceUp(&intf) {
+			continue
+		}
+		if intf.Flags&(net.FlagLoopback) != 0 {
+			addrs, err := nw.Addrs(&intf)
+			if err != nil {
+				return nil, err
+			}
+			klog.V(4).Infof("Interface %q has %d addresses :%v.", intf.Name, len(addrs), addrs)
+			matchingIP, err := getMatchingGlobalIP(addrs, forFamily)
+			if err != nil {
+				return nil, err
+			}
+			if matchingIP != nil {
+				klog.V(4).Infof("Found valid IPv%d address %v for interface %q.", int(forFamily), matchingIP, intf.Name)
+				return matchingIP, nil
+			}
+		}
+	}
+	return nil, nil
+}
+
 // memberOf tells if the IP is of the desired family. Used for checking interface addresses.
 func memberOf(ip net.IP, family AddressFamily) bool {
 	if ip.To4() != nil {
@@ -393,8 +423,9 @@ func getAllDefaultRoutes() ([]Route, error) {
 }
 
 // chooseHostInterfaceFromRoute cycles through each default route provided, looking for a
-// global IP address from the interface for the route. addressFamilies determines whether it
-// prefers IPv4 or IPv6
+// global IP address from the interface for the route. If there are routes but no global
+// address is obtained from the interfaces, it checks if the loopback interface has a global address.
+// addressFamilies determines whether it prefers IPv4 or IPv6
 func chooseHostInterfaceFromRoute(routes []Route, nw networkInterfacer, addressFamilies AddressFamilyPreference) (net.IP, error) {
 	for _, family := range addressFamilies {
 		klog.V(4).Infof("Looking for default routes with IPv%d addresses", uint(family))
@@ -411,6 +442,17 @@ func chooseHostInterfaceFromRoute(routes []Route, nw networkInterfacer, addressF
 				klog.V(4).Infof("Found active IP %v ", finalIP)
 				return finalIP, nil
 			}
+			// In case of network setups where default routes are present, but network
+			// interfaces use only link-local addresses (e.g. as described in RFC5549).
+			// the global IP is assigned to the loopback interface, and we should use it
+			loopbackIP, err := getIPFromLoopbackInterface(family, nw)
+			if err != nil {
+				return nil, err
+			}
+			if loopbackIP != nil {
+				klog.V(4).Infof("Found active IP %v on Loopback interface", loopbackIP)
+				return loopbackIP, nil
+			}
 		}
 	}
 	klog.V(4).Infof("No active IP found by looking at default routes")

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

@@ -22,6 +22,29 @@ import (
 	"strconv"
 )
 
+type pathOptions struct {
+	path *Path
+}
+
+// PathOption modifies a pathOptions
+type PathOption func(o *pathOptions)
+
+// WithPath generates a PathOption
+func WithPath(p *Path) PathOption {
+	return func(o *pathOptions) {
+		o.path = p
+	}
+}
+
+// ToPath produces *Path from a set of PathOption
+func ToPath(opts ...PathOption) *Path {
+	c := &pathOptions{}
+	for _, opt := range opts {
+		opt(c)
+	}
+	return c.path
+}
+
 // Path represents the path from some root to a particular field.
 type Path struct {
 	name   string // the name of this field or "" if this is an index

vendor/k8s.io/apimachinery/pkg/util/yaml/decoder.go

@@ -22,13 +22,11 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"strings"
 	"unicode"
 
 	jsonutil "k8s.io/apimachinery/pkg/util/json"
 
-	"k8s.io/klog/v2"
 	"sigs.k8s.io/yaml"
 )
 
@@ -215,16 +213,15 @@ type YAMLOrJSONDecoder struct {
 	bufferSize int
 
 	decoder decoder
-	rawData []byte
 }
 
 type JSONSyntaxError struct {
-	Line int
-	Err  error
+	Offset int64
+	Err    error
 }
 
 func (e JSONSyntaxError) Error() string {
-	return fmt.Sprintf("json: line %d: %s", e.Line, e.Err.Error())
+	return fmt.Sprintf("json: offset %d: %s", e.Offset, e.Err.Error())
 }
 
 type YAMLSyntaxError struct {
@@ -250,35 +247,18 @@ func NewYAMLOrJSONDecoder(r io.Reader, bufferSize int) *YAMLOrJSONDecoder {
 // provide object, or returns an error.
 func (d *YAMLOrJSONDecoder) Decode(into interface{}) error {
 	if d.decoder == nil {
-		buffer, origData, isJSON := GuessJSONStream(d.r, d.bufferSize)
+		buffer, _, isJSON := GuessJSONStream(d.r, d.bufferSize)
 		if isJSON {
 			d.decoder = json.NewDecoder(buffer)
-			d.rawData = origData
 		} else {
 			d.decoder = NewYAMLToJSONDecoder(buffer)
 		}
 	}
 	err := d.decoder.Decode(into)
-	if jsonDecoder, ok := d.decoder.(*json.Decoder); ok {
-		if syntax, ok := err.(*json.SyntaxError); ok {
-			data, readErr := ioutil.ReadAll(jsonDecoder.Buffered())
-			if readErr != nil {
-				klog.V(4).Infof("reading stream failed: %v", readErr)
-			}
-			js := string(data)
-
-			// if contents from io.Reader are not complete,
-			// use the original raw data to prevent panic
-			if int64(len(js)) <= syntax.Offset {
-				js = string(d.rawData)
-			}
-
-			start := strings.LastIndex(js[:syntax.Offset], "\n") + 1
-			line := strings.Count(js[:start], "\n")
-			return JSONSyntaxError{
-				Line: line,
-				Err:  fmt.Errorf(syntax.Error()),
-			}
+	if syntax, ok := err.(*json.SyntaxError); ok {
+		return JSONSyntaxError{
+			Offset: syntax.Offset,
+			Err:    syntax,
 		}
 	}
 	return err
@@ -363,6 +343,12 @@ func GuessJSONStream(r io.Reader, size int) (io.Reader, []byte, bool) {
 	return buffer, b, hasJSONPrefix(b)
 }
 
+// IsJSONBuffer scans the provided buffer, looking
+// for an open brace indicating this is JSON.
+func IsJSONBuffer(buf []byte) bool {
+	return hasJSONPrefix(buf)
+}
+
 var jsonPrefix = []byte("{")
 
 // hasJSONPrefix returns true if the provided buffer appears to start with