dualstack: incorporate IsIPv4 updates from utils repo

This dependency bump will allow for cleanup of duplicate code in
the dualstack e2e tests.

Signed-off-by: Christopher M. Luciano <cmluciano@us.ibm.com>

vendor/k8s.io/utils/clock/clock.go

@@ -18,11 +18,18 @@ package clock
 
 import "time"
 
+// PassiveClock allows for injecting fake or real clocks into code
+// that needs to read the current time but does not support scheduling
+// activity in the future.
+type PassiveClock interface {
+	Now() time.Time
+	Since(time.Time) time.Duration
+}
+
 // Clock allows for injecting fake or real clocks into code that
 // needs to do arbitrary things based on time.
 type Clock interface {
-	Now() time.Time
-	Since(time.Time) time.Duration
+	PassiveClock
 	After(d time.Duration) <-chan time.Time
 	NewTimer(d time.Duration) Timer
 	Sleep(d time.Duration)

vendor/k8s.io/utils/mount/OWNERS

@@ -8,6 +8,7 @@ reviewers:
   - andyzhangx
   - gnufied
 approvers:
+  - andyzhangx
   - jingxu97
   - saad-ali
   - jsafrane

vendor/k8s.io/utils/mount/mount_windows.go

@@ -29,6 +29,10 @@ import (
 	"k8s.io/utils/keymutex"
 )
 
+const (
+	accessDenied string = "access is denied"
+)
+
 // Mounter provides the default implementation of mount.Interface
 // for the windows platform.  This implementation assumes that the
 // kubelet is running in the host's root mount namespace.
@@ -84,9 +88,8 @@ func (mounter *Mounter) MountSensitive(source string, target string, fstype stri
 		allOptions = append(allOptions, options...)
 		allOptions = append(allOptions, sensitiveOptions...)
 		if len(allOptions) < 2 {
-			klog.Warningf("mount options(%q) command number(%d) less than 2, source:%q, target:%q, skip mounting",
+			return fmt.Errorf("mount options(%q) should have at least 2 options, current number:%d, source:%q, target:%q",
 				sanitizedOptionsForLogging, len(allOptions), source, target)
-			return nil
 		}
 
 		// currently only cifs mount is supported
@@ -98,17 +101,27 @@ func (mounter *Mounter) MountSensitive(source string, target string, fstype stri
 		getSMBMountMutex.LockKey(source)
 		defer getSMBMountMutex.UnlockKey(source)
 
-		if output, err := newSMBMapping(allOptions[0], allOptions[1], source); err != nil {
+		username := allOptions[0]
+		password := allOptions[1]
+		if output, err := newSMBMapping(username, password, source); err != nil {
+			klog.Warningf("SMB Mapping(%s) returned with error(%v), output(%s)", source, err, string(output))
 			if isSMBMappingExist(source) {
-				klog.V(2).Infof("SMB Mapping(%s) already exists, now begin to remove and remount", source)
-				if output, err := removeSMBMapping(source); err != nil {
-					return fmt.Errorf("Remove-SmbGlobalMapping failed: %v, output: %q", err, output)
-				}
-				if output, err := newSMBMapping(allOptions[0], allOptions[1], source); err != nil {
-					return fmt.Errorf("New-SmbGlobalMapping remount failed: %v, output: %q", err, output)
+				valid, err := isValidPath(source)
+				if !valid {
+					if err == nil || isAccessDeniedError(err) {
+						klog.V(2).Infof("SMB Mapping(%s) already exists while it's not valid, return error: %v, now begin to remove and remount", source, err)
+						if output, err = removeSMBMapping(source); err != nil {
+							return fmt.Errorf("Remove-SmbGlobalMapping failed: %v, output: %q", err, output)
+						}
+						if output, err := newSMBMapping(username, password, source); err != nil {
+							return fmt.Errorf("New-SmbGlobalMapping(%s) failed: %v, output: %q", source, err, output)
+						}
+					}
+				} else {
+					klog.V(2).Infof("SMB Mapping(%s) already exists and is still valid, skip error(%v)", source, err)
 				}
 			} else {
-				return fmt.Errorf("New-SmbGlobalMapping failed: %v, output: %q", err, output)
+				return fmt.Errorf("New-SmbGlobalMapping(%s) failed: %v, output: %q", source, err, output)
 			}
 		}
 	}
@@ -153,6 +166,23 @@ func isSMBMappingExist(remotepath string) bool {
 	return err == nil
 }
 
+// check whether remotepath is valid
+// return (true, nil) if remotepath is valid
+func isValidPath(remotepath string) (bool, error) {
+	cmd := exec.Command("powershell", "/c", `Test-Path $Env:remoteapth`)
+	cmd.Env = append(os.Environ(), fmt.Sprintf("remoteapth=%s", remotepath))
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return false, fmt.Errorf("returned output: %s, error: %v", string(output), err)
+	}
+
+	return strings.HasPrefix(strings.ToLower(string(output)), "true"), nil
+}
+
+func isAccessDeniedError(err error) bool {
+	return err != nil && strings.Contains(strings.ToLower(err.Error()), accessDenied)
+}
+
 // remove SMB mapping
 func removeSMBMapping(remotepath string) (string, error) {
 	cmd := exec.Command("powershell", "/c", `Remove-SmbGlobalMapping -RemotePath $Env:smbremotepath -Force`)

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

@@ -137,6 +137,30 @@ func IsIPv6CIDR(cidr *net.IPNet) bool {
 	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 := net.ParseIP(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, _, _ := net.ParseCIDR(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/pointer/pointer.go

@@ -51,14 +51,23 @@ func Int32Ptr(i int32) *int32 {
 	return &i
 }
 
+// Int32PtrDerefOr dereference the int32 ptr and returns it if not nil,
+// else returns def.
+func Int32PtrDerefOr(ptr *int32, def int32) int32 {
+	if ptr != nil {
+		return *ptr
+	}
+	return def
+}
+
 // Int64Ptr returns a pointer to an int64
 func Int64Ptr(i int64) *int64 {
 	return &i
 }
 
-// Int32PtrDerefOr dereference the int32 ptr and returns it if not nil,
+// Int64PtrDerefOr dereference the int64 ptr and returns it if not nil,
 // else returns def.
-func Int32PtrDerefOr(ptr *int32, def int32) int32 {
+func Int64PtrDerefOr(ptr *int64, def int64) int64 {
 	if ptr != nil {
 		return *ptr
 	}
@@ -70,17 +79,53 @@ func BoolPtr(b bool) *bool {
 	return &b
 }
 
+// BoolPtrDerefOr dereference the bool ptr and returns it if not nil,
+// else returns def.
+func BoolPtrDerefOr(ptr *bool, def bool) bool {
+	if ptr != nil {
+		return *ptr
+	}
+	return def
+}
+
 // StringPtr returns a pointer to the passed string.
 func StringPtr(s string) *string {
 	return &s
 }
 
+// StringPtrDerefOr dereference the string ptr and returns it if not nil,
+// else returns def.
+func StringPtrDerefOr(ptr *string, def string) string {
+	if ptr != nil {
+		return *ptr
+	}
+	return def
+}
+
 // Float32Ptr returns a pointer to the passed float32.
 func Float32Ptr(i float32) *float32 {
 	return &i
 }
 
+// Float32PtrDerefOr dereference the float32 ptr and returns it if not nil,
+// else returns def.
+func Float32PtrDerefOr(ptr *float32, def float32) float32 {
+	if ptr != nil {
+		return *ptr
+	}
+	return def
+}
+
 // Float64Ptr returns a pointer to the passed float64.
 func Float64Ptr(i float64) *float64 {
 	return &i
 }
+
+// Float64PtrDerefOr dereference the float64 ptr and returns it if not nil,
+// else returns def.
+func Float64PtrDerefOr(ptr *float64, def float64) float64 {
+	if ptr != nil {
+		return *ptr
+	}
+	return def
+}