Update Go version and package dependencies

vendor/k8s.io/utils/net/ipfamily.go

@@ -0,0 +1,181 @@
+/*
+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 net
+
+import (
+	"fmt"
+	"net"
+)
+
+// IPFamily refers to a specific family if not empty, i.e. "4" or "6".
+type IPFamily string
+
+// Constants for valid IPFamilys:
+const (
+	IPFamilyUnknown IPFamily = ""
+
+	IPv4 IPFamily = "4"
+	IPv6 IPFamily = "6"
+)
+
+// IsDualStackIPs returns true if:
+// - all elements of ips are valid
+// - at least one IP from each family (v4 and v6) is present
+func IsDualStackIPs(ips []net.IP) (bool, error) {
+	v4Found := false
+	v6Found := false
+	for i, ip := range ips {
+		switch IPFamilyOf(ip) {
+		case IPv4:
+			v4Found = true
+		case IPv6:
+			v6Found = true
+		default:
+			return false, fmt.Errorf("invalid IP[%d]: %v", i, ip)
+		}
+	}
+
+	return (v4Found && v6Found), nil
+}
+
+// IsDualStackIPStrings returns true if:
+// - all elements of ips can be parsed as IPs
+// - at least one IP from each family (v4 and v6) is present
+func IsDualStackIPStrings(ips []string) (bool, error) {
+	parsedIPs := make([]net.IP, 0, len(ips))
+	for i, ip := range ips {
+		parsedIP := ParseIPSloppy(ip)
+		if parsedIP == nil {
+			return false, fmt.Errorf("invalid IP[%d]: %v", i, ip)
+		}
+		parsedIPs = append(parsedIPs, parsedIP)
+	}
+	return IsDualStackIPs(parsedIPs)
+}
+
+// IsDualStackCIDRs returns true if:
+// - all elements of cidrs are non-nil
+// - at least one CIDR from each family (v4 and v6) is present
+func IsDualStackCIDRs(cidrs []*net.IPNet) (bool, error) {
+	v4Found := false
+	v6Found := false
+	for i, cidr := range cidrs {
+		switch IPFamilyOfCIDR(cidr) {
+		case IPv4:
+			v4Found = true
+		case IPv6:
+			v6Found = true
+		default:
+			return false, fmt.Errorf("invalid CIDR[%d]: %v", i, cidr)
+		}
+	}
+
+	return (v4Found && v6Found), nil
+}
+
+// IsDualStackCIDRStrings returns if
+// - all elements of cidrs can be parsed as CIDRs
+// - at least one CIDR from each family (v4 and v6) is present
+func IsDualStackCIDRStrings(cidrs []string) (bool, error) {
+	parsedCIDRs, err := ParseCIDRs(cidrs)
+	if err != nil {
+		return false, err
+	}
+	return IsDualStackCIDRs(parsedCIDRs)
+}
+
+// IPFamilyOf returns the IP family of ip, or IPFamilyUnknown if it is invalid.
+func IPFamilyOf(ip net.IP) IPFamily {
+	switch {
+	case ip.To4() != nil:
+		return IPv4
+	case ip.To16() != nil:
+		return IPv6
+	default:
+		return IPFamilyUnknown
+	}
+}
+
+// IPFamilyOfString returns the IP family of ip, or IPFamilyUnknown if ip cannot
+// be parsed as an IP.
+func IPFamilyOfString(ip string) IPFamily {
+	return IPFamilyOf(ParseIPSloppy(ip))
+}
+
+// IPFamilyOfCIDR returns the IP family of cidr.
+func IPFamilyOfCIDR(cidr *net.IPNet) IPFamily {
+	if cidr == nil {
+		return IPFamilyUnknown
+	}
+	return IPFamilyOf(cidr.IP)
+}
+
+// IPFamilyOfCIDRString returns the IP family of cidr.
+func IPFamilyOfCIDRString(cidr string) IPFamily {
+	ip, _, _ := ParseCIDRSloppy(cidr)
+	return IPFamilyOf(ip)
+}
+
+// IsIPv6 returns true if netIP is IPv6 (and false if it is IPv4, nil, or invalid).
+func IsIPv6(netIP net.IP) bool {
+	return IPFamilyOf(netIP) == IPv6
+}
+
+// IsIPv6String returns true if ip contains a single IPv6 address and nothing else. It
+// returns false if ip is an empty string, an IPv4 address, or anything else that is not a
+// single IPv6 address.
+func IsIPv6String(ip string) bool {
+	return IPFamilyOfString(ip) == IPv6
+}
+
+// IsIPv6CIDR returns true if a cidr is a valid IPv6 CIDR. It returns false if cidr is
+// nil or an IPv4 CIDR. Its behavior is not defined if cidr is invalid.
+func IsIPv6CIDR(cidr *net.IPNet) bool {
+	return IPFamilyOfCIDR(cidr) == IPv6
+}
+
+// IsIPv6CIDRString returns true if cidr contains a single IPv6 CIDR and nothing else. It
+// returns false if cidr is an empty string, an IPv4 CIDR, or anything else that is not a
+// single valid IPv6 CIDR.
+func IsIPv6CIDRString(cidr string) bool {
+	return IPFamilyOfCIDRString(cidr) == IPv6
+}
+
+// IsIPv4 returns true if netIP is IPv4 (and false if it is IPv6, nil, or invalid).
+func IsIPv4(netIP net.IP) bool {
+	return IPFamilyOf(netIP) == IPv4
+}
+
+// IsIPv4String returns true if ip contains a single IPv4 address and nothing else. It
+// returns false if ip is an empty string, an IPv6 address, or anything else that is not a
+// single IPv4 address.
+func IsIPv4String(ip string) bool {
+	return IPFamilyOfString(ip) == IPv4
+}
+
+// IsIPv4CIDR returns true if cidr is a valid IPv4 CIDR. It returns false if cidr is nil
+// or an IPv6 CIDR. Its behavior is not defined if cidr is invalid.
+func IsIPv4CIDR(cidr *net.IPNet) bool {
+	return IPFamilyOfCIDR(cidr) == IPv4
+}
+
+// IsIPv4CIDRString returns true if cidr contains a single IPv4 CIDR and nothing else. It
+// returns false if cidr is an empty string, an IPv6 CIDR, or anything else that is not a
+// single valid IPv4 CIDR.
+func IsIPv4CIDRString(cidr string) bool {
+	return IPFamilyOfCIDRString(cidr) == IPv4
+}

vendor/k8s.io/utils/net/net.go

@@ -29,138 +29,16 @@ import (
 // order is maintained
 func ParseCIDRs(cidrsString []string) ([]*net.IPNet, error) {
 	cidrs := make([]*net.IPNet, 0, len(cidrsString))
-	for _, cidrString := range cidrsString {
+	for i, cidrString := range cidrsString {
 		_, cidr, err := ParseCIDRSloppy(cidrString)
 		if err != nil {
-			return nil, fmt.Errorf("failed to parse cidr value:%q with error:%v", cidrString, err)
+			return nil, fmt.Errorf("invalid CIDR[%d]: %v (%v)", i, cidr, err)
 		}
 		cidrs = append(cidrs, cidr)
 	}
 	return cidrs, nil
 }
 
-// IsDualStackIPs returns if a slice of ips is:
-// - all are valid ips
-// - at least one ip from each family (v4 or v6)
-func IsDualStackIPs(ips []net.IP) (bool, error) {
-	v4Found := false
-	v6Found := false
-	for _, ip := range ips {
-		if ip == nil {
-			return false, fmt.Errorf("ip %v is invalid", ip)
-		}
-
-		if v4Found && v6Found {
-			continue
-		}
-
-		if IsIPv6(ip) {
-			v6Found = true
-			continue
-		}
-
-		v4Found = true
-	}
-
-	return (v4Found && v6Found), nil
-}
-
-// IsDualStackIPStrings returns if
-// - all are valid ips
-// - at least one ip from each family (v4 or v6)
-func IsDualStackIPStrings(ips []string) (bool, error) {
-	parsedIPs := make([]net.IP, 0, len(ips))
-	for _, ip := range ips {
-		parsedIP := ParseIPSloppy(ip)
-		parsedIPs = append(parsedIPs, parsedIP)
-	}
-	return IsDualStackIPs(parsedIPs)
-}
-
-// IsDualStackCIDRs returns if
-// - all are valid cidrs
-// - at least one cidr from each family (v4 or v6)
-func IsDualStackCIDRs(cidrs []*net.IPNet) (bool, error) {
-	v4Found := false
-	v6Found := false
-	for _, cidr := range cidrs {
-		if cidr == nil {
-			return false, fmt.Errorf("cidr %v is invalid", cidr)
-		}
-
-		if v4Found && v6Found {
-			continue
-		}
-
-		if IsIPv6(cidr.IP) {
-			v6Found = true
-			continue
-		}
-		v4Found = true
-	}
-
-	return v4Found && v6Found, nil
-}
-
-// IsDualStackCIDRStrings returns if
-// - all are valid cidrs
-// - at least one cidr from each family (v4 or v6)
-func IsDualStackCIDRStrings(cidrs []string) (bool, error) {
-	parsedCIDRs, err := ParseCIDRs(cidrs)
-	if err != nil {
-		return false, err
-	}
-	return IsDualStackCIDRs(parsedCIDRs)
-}
-
-// IsIPv6 returns if netIP is IPv6.
-func IsIPv6(netIP net.IP) bool {
-	return netIP != nil && netIP.To4() == nil
-}
-
-// IsIPv6String returns if ip is IPv6.
-func IsIPv6String(ip string) bool {
-	netIP := ParseIPSloppy(ip)
-	return IsIPv6(netIP)
-}
-
-// IsIPv6CIDRString returns if cidr is IPv6.
-// This assumes cidr is a valid CIDR.
-func IsIPv6CIDRString(cidr string) bool {
-	ip, _, _ := ParseCIDRSloppy(cidr)
-	return IsIPv6(ip)
-}
-
-// IsIPv6CIDR returns if a cidr is ipv6
-func IsIPv6CIDR(cidr *net.IPNet) bool {
-	ip := cidr.IP
-	return IsIPv6(ip)
-}
-
-// IsIPv4 returns if netIP is IPv4.
-func IsIPv4(netIP net.IP) bool {
-	return netIP != nil && netIP.To4() != nil
-}
-
-// IsIPv4String returns if ip is IPv4.
-func IsIPv4String(ip string) bool {
-	netIP := ParseIPSloppy(ip)
-	return IsIPv4(netIP)
-}
-
-// IsIPv4CIDR returns if a cidr is ipv4
-func IsIPv4CIDR(cidr *net.IPNet) bool {
-	ip := cidr.IP
-	return IsIPv4(ip)
-}
-
-// IsIPv4CIDRString returns if cidr is IPv4.
-// This assumes cidr is a valid CIDR.
-func IsIPv4CIDRString(cidr string) bool {
-	ip, _, _ := ParseCIDRSloppy(cidr)
-	return IsIPv4(ip)
-}
-
 // ParsePort parses a string representing an IP port.  If the string is not a
 // valid port number, this returns an error.
 func ParsePort(port string, allowZero bool) (int, error) {

vendor/k8s.io/utils/net/port.go

@@ -23,15 +23,6 @@ import (
 	"strings"
 )
 
-// IPFamily refers to a specific family if not empty, i.e. "4" or "6".
-type IPFamily string
-
-// Constants for valid IPFamilys:
-const (
-	IPv4 IPFamily = "4"
-	IPv6          = "6"
-)
-
 // Protocol is a network protocol support by LocalPort.
 type Protocol string
 
@@ -67,7 +58,7 @@ func NewLocalPort(desc, ip string, ipFamily IPFamily, port int, protocol Protoco
 	if protocol != TCP && protocol != UDP {
 		return nil, fmt.Errorf("Unsupported protocol %s", protocol)
 	}
-	if ipFamily != "" && ipFamily != "4" && ipFamily != "6" {
+	if ipFamily != IPFamilyUnknown && ipFamily != IPv4 && ipFamily != IPv6 {
 		return nil, fmt.Errorf("Invalid IP family %s", ipFamily)
 	}
 	if ip != "" {
@@ -75,9 +66,10 @@ func NewLocalPort(desc, ip string, ipFamily IPFamily, port int, protocol Protoco
 		if parsedIP == nil {
 			return nil, fmt.Errorf("invalid ip address %s", ip)
 		}
-		asIPv4 := parsedIP.To4()
-		if asIPv4 == nil && ipFamily == IPv4 || asIPv4 != nil && ipFamily == IPv6 {
-			return nil, fmt.Errorf("ip address and family mismatch %s, %s", ip, ipFamily)
+		if ipFamily != IPFamilyUnknown {
+			if IPFamily(parsedIP) != ipFamily {
+				return nil, fmt.Errorf("ip address and family mismatch %s, %s", ip, ipFamily)
+			}
 		}
 	}
 	return &LocalPort{Description: desc, IP: ip, IPFamily: ipFamily, Port: port, Protocol: protocol}, nil

vendor/k8s.io/utils/pointer/pointer.go

@@ -53,6 +53,7 @@ func Int(i int) *int {
 }
 
 // IntPtr is a function variable referring to Int.
+//
 // Deprecated: Use Int instead.
 var IntPtr = Int // for back-compat
 
@@ -66,6 +67,7 @@ func IntDeref(ptr *int, def int) int {
 }
 
 // IntPtrDerefOr is a function variable referring to IntDeref.
+//
 // Deprecated: Use IntDeref instead.
 var IntPtrDerefOr = IntDeref // for back-compat
 
@@ -75,6 +77,7 @@ func Int32(i int32) *int32 {
 }
 
 // Int32Ptr is a function variable referring to Int32.
+//
 // Deprecated: Use Int32 instead.
 var Int32Ptr = Int32 // for back-compat
 
@@ -88,6 +91,7 @@ func Int32Deref(ptr *int32, def int32) int32 {
 }
 
 // Int32PtrDerefOr is a function variable referring to Int32Deref.
+//
 // Deprecated: Use Int32Deref instead.
 var Int32PtrDerefOr = Int32Deref // for back-compat
 
@@ -109,6 +113,7 @@ func Uint(i uint) *uint {
 }
 
 // UintPtr is a function variable referring to Uint.
+//
 // Deprecated: Use Uint instead.
 var UintPtr = Uint // for back-compat
 
@@ -122,6 +127,7 @@ func UintDeref(ptr *uint, def uint) uint {
 }
 
 // UintPtrDerefOr is a function variable referring to UintDeref.
+//
 // Deprecated: Use UintDeref instead.
 var UintPtrDerefOr = UintDeref // for back-compat
 
@@ -131,6 +137,7 @@ func Uint32(i uint32) *uint32 {
 }
 
 // Uint32Ptr is a function variable referring to Uint32.
+//
 // Deprecated: Use Uint32 instead.
 var Uint32Ptr = Uint32 // for back-compat
 
@@ -144,6 +151,7 @@ func Uint32Deref(ptr *uint32, def uint32) uint32 {
 }
 
 // Uint32PtrDerefOr is a function variable referring to Uint32Deref.
+//
 // Deprecated: Use Uint32Deref instead.
 var Uint32PtrDerefOr = Uint32Deref // for back-compat
 
@@ -165,6 +173,7 @@ func Int64(i int64) *int64 {
 }
 
 // Int64Ptr is a function variable referring to Int64.
+//
 // Deprecated: Use Int64 instead.
 var Int64Ptr = Int64 // for back-compat
 
@@ -178,6 +187,7 @@ func Int64Deref(ptr *int64, def int64) int64 {
 }
 
 // Int64PtrDerefOr is a function variable referring to Int64Deref.
+//
 // Deprecated: Use Int64Deref instead.
 var Int64PtrDerefOr = Int64Deref // for back-compat
 
@@ -199,6 +209,7 @@ func Uint64(i uint64) *uint64 {
 }
 
 // Uint64Ptr is a function variable referring to Uint64.
+//
 // Deprecated: Use Uint64 instead.
 var Uint64Ptr = Uint64 // for back-compat
 
@@ -212,6 +223,7 @@ func Uint64Deref(ptr *uint64, def uint64) uint64 {
 }
 
 // Uint64PtrDerefOr is a function variable referring to Uint64Deref.
+//
 // Deprecated: Use Uint64Deref instead.
 var Uint64PtrDerefOr = Uint64Deref // for back-compat
 
@@ -233,6 +245,7 @@ func Bool(b bool) *bool {
 }
 
 // BoolPtr is a function variable referring to Bool.
+//
 // Deprecated: Use Bool instead.
 var BoolPtr = Bool // for back-compat
 
@@ -246,6 +259,7 @@ func BoolDeref(ptr *bool, def bool) bool {
 }
 
 // BoolPtrDerefOr is a function variable referring to BoolDeref.
+//
 // Deprecated: Use BoolDeref instead.
 var BoolPtrDerefOr = BoolDeref // for back-compat
 
@@ -267,6 +281,7 @@ func String(s string) *string {
 }
 
 // StringPtr is a function variable referring to String.
+//
 // Deprecated: Use String instead.
 var StringPtr = String // for back-compat
 
@@ -280,6 +295,7 @@ func StringDeref(ptr *string, def string) string {
 }
 
 // StringPtrDerefOr is a function variable referring to StringDeref.
+//
 // Deprecated: Use StringDeref instead.
 var StringPtrDerefOr = StringDeref // for back-compat
 
@@ -301,6 +317,7 @@ func Float32(i float32) *float32 {
 }
 
 // Float32Ptr is a function variable referring to Float32.
+//
 // Deprecated: Use Float32 instead.
 var Float32Ptr = Float32
 
@@ -314,6 +331,7 @@ func Float32Deref(ptr *float32, def float32) float32 {
 }
 
 // Float32PtrDerefOr is a function variable referring to Float32Deref.
+//
 // Deprecated: Use Float32Deref instead.
 var Float32PtrDerefOr = Float32Deref // for back-compat
 
@@ -335,6 +353,7 @@ func Float64(i float64) *float64 {
 }
 
 // Float64Ptr is a function variable referring to Float64.
+//
 // Deprecated: Use Float64 instead.
 var Float64Ptr = Float64
 
@@ -348,6 +367,7 @@ func Float64Deref(ptr *float64, def float64) float64 {
 }
 
 // Float64PtrDerefOr is a function variable referring to Float64Deref.
+//
 // Deprecated: Use Float64Deref instead.
 var Float64PtrDerefOr = Float64Deref // for back-compat
 

vendor/k8s.io/utils/trace/trace.go

@@ -21,6 +21,7 @@ import (
 	"context"
 	"fmt"
 	"math/rand"
+	"sync"
 	"time"
 
 	"k8s.io/klog/v2"
@@ -93,13 +94,16 @@ func (s traceStep) writeItem(b *bytes.Buffer, formatter string, startTime time.T
 // Trace keeps track of a set of "steps" and allows us to log a specific
 // step if it took longer than its share of the total allowed time
 type Trace struct {
+	// constant fields
 	name        string
 	fields      []Field
-	threshold   *time.Duration
 	startTime   time.Time
-	endTime     *time.Time
-	traceItems  []traceItem
 	parentTrace *Trace
+	// fields guarded by a lock
+	lock       sync.RWMutex
+	threshold  *time.Duration
+	endTime    *time.Time
+	traceItems []traceItem
 }
 
 func (t *Trace) time() time.Time {
@@ -138,6 +142,8 @@ func New(name string, fields ...Field) *Trace {
 // how long it took. The Fields add key value pairs to provide additional details about the trace
 // step.
 func (t *Trace) Step(msg string, fields ...Field) {
+	t.lock.Lock()
+	defer t.lock.Unlock()
 	if t.traceItems == nil {
 		// traces almost always have less than 6 steps, do this to avoid more than a single allocation
 		t.traceItems = make([]traceItem, 0, 6)
@@ -153,7 +159,9 @@ func (t *Trace) Nest(msg string, fields ...Field) *Trace {
 	newTrace := New(msg, fields...)
 	if t != nil {
 		newTrace.parentTrace = t
+		t.lock.Lock()
 		t.traceItems = append(t.traceItems, newTrace)
+		t.lock.Unlock()
 	}
 	return newTrace
 }
@@ -163,7 +171,9 @@ func (t *Trace) Nest(msg string, fields ...Field) *Trace {
 // is logged.
 func (t *Trace) Log() {
 	endTime := time.Now()
+	t.lock.Lock()
 	t.endTime = &endTime
+	t.lock.Unlock()
 	// an explicit logging request should dump all the steps out at the higher level
 	if t.parentTrace == nil { // We don't start logging until Log or LogIfLong is called on the root trace
 		t.logTrace()
@@ -178,13 +188,17 @@ func (t *Trace) Log() {
 // If the Trace is nested it is not immediately logged. Instead, it is logged when the trace it
 // is nested within is logged.
 func (t *Trace) LogIfLong(threshold time.Duration) {
+	t.lock.Lock()
 	t.threshold = &threshold
+	t.lock.Unlock()
 	t.Log()
 }
 
 // logTopLevelTraces finds all traces in a hierarchy of nested traces that should be logged but do not have any
 // parents that will be logged, due to threshold limits, and logs them as top level traces.
 func (t *Trace) logTrace() {
+	t.lock.RLock()
+	defer t.lock.RUnlock()
 	if t.durationIsWithinThreshold() {
 		var buffer bytes.Buffer
 		traceNum := rand.Int31()
@@ -244,9 +258,13 @@ func (t *Trace) calculateStepThreshold() *time.Duration {
 	traceThreshold := *t.threshold
 	for _, s := range t.traceItems {
 		nestedTrace, ok := s.(*Trace)
-		if ok && nestedTrace.threshold != nil {
-			traceThreshold = traceThreshold - *nestedTrace.threshold
-			lenTrace--
+		if ok {
+			nestedTrace.lock.RLock()
+			if nestedTrace.threshold != nil {
+				traceThreshold = traceThreshold - *nestedTrace.threshold
+				lenTrace--
+			}
+			nestedTrace.lock.RUnlock()
 		}
 	}