vendor updates

vendor/k8s.io/kubernetes/pkg/volume/azure_dd/BUILD

@@ -11,15 +11,41 @@ go_library(
     srcs = [
         "attacher.go",
         "azure_common.go",
-        "azure_common_unsupported.go",
         "azure_dd.go",
         "azure_mounter.go",
         "azure_provision.go",
     ] + select({
-        "@io_bazel_rules_go//go/platform:linux_amd64": [
+        "@io_bazel_rules_go//go/platform:android": [
+            "azure_common_unsupported.go",
+        ],
+        "@io_bazel_rules_go//go/platform:darwin": [
+            "azure_common_unsupported.go",
+        ],
+        "@io_bazel_rules_go//go/platform:dragonfly": [
+            "azure_common_unsupported.go",
+        ],
+        "@io_bazel_rules_go//go/platform:freebsd": [
+            "azure_common_unsupported.go",
+        ],
+        "@io_bazel_rules_go//go/platform:linux": [
             "azure_common_linux.go",
         ],
-        "@io_bazel_rules_go//go/platform:windows_amd64": [
+        "@io_bazel_rules_go//go/platform:nacl": [
+            "azure_common_unsupported.go",
+        ],
+        "@io_bazel_rules_go//go/platform:netbsd": [
+            "azure_common_unsupported.go",
+        ],
+        "@io_bazel_rules_go//go/platform:openbsd": [
+            "azure_common_unsupported.go",
+        ],
+        "@io_bazel_rules_go//go/platform:plan9": [
+            "azure_common_unsupported.go",
+        ],
+        "@io_bazel_rules_go//go/platform:solaris": [
+            "azure_common_unsupported.go",
+        ],
+        "@io_bazel_rules_go//go/platform:windows": [
             "azure_common_windows.go",
         ],
         "//conditions:default": [],
@@ -34,7 +60,6 @@ go_library(
         "//pkg/util/strings:go_default_library",
         "//pkg/volume:go_default_library",
         "//pkg/volume/util:go_default_library",
-        "//pkg/volume/util/volumehelper:go_default_library",
         "//vendor/github.com/Azure/azure-sdk-for-go/arm/compute:go_default_library",
         "//vendor/github.com/Azure/azure-sdk-for-go/arm/storage:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
@@ -66,8 +91,7 @@ go_test(
         "azure_common_test.go",
         "azure_dd_test.go",
     ],
-    importpath = "k8s.io/kubernetes/pkg/volume/azure_dd",
-    library = ":go_default_library",
+    embed = [":go_default_library"],
     deps = [
         "//pkg/util/mount:go_default_library",
         "//pkg/volume:go_default_library",

vendor/k8s.io/kubernetes/pkg/volume/azure_dd/OWNERS

@@ -1,11 +1,18 @@
 approvers:
+- andyzhangx
 - brendandburns
+- feiskyer
+- karataliu
+- khenidak
 - rootfs
 reviewers:
-- rootfs
-- brendandburns
-- saad-ali
-- jsafrane
-- jingxu97
-- msau42
 - andyzhangx
+- brendandburns
+- feiskyer
+- jingxu97
+- jsafrane
+- msau42
+- karataliu
+- khenidak
+- rootfs
+- saad-ali

vendor/k8s.io/kubernetes/pkg/volume/azure_dd/attacher.go

@@ -17,13 +17,13 @@ limitations under the License.
 package azure_dd
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path"
 	"path/filepath"
 	"runtime"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/Azure/azure-sdk-for-go/arm/compute"
@@ -36,8 +36,7 @@ import (
 	"k8s.io/kubernetes/pkg/util/keymutex"
 	"k8s.io/kubernetes/pkg/util/mount"
 	"k8s.io/kubernetes/pkg/volume"
-	volumeutil "k8s.io/kubernetes/pkg/volume/util"
-	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
+	"k8s.io/kubernetes/pkg/volume/util"
 )
 
 type azureDiskDetacher struct {
@@ -60,17 +59,14 @@ var getLunMutex = keymutex.NewKeyMutex()
 func (a *azureDiskAttacher) Attach(spec *volume.Spec, nodeName types.NodeName) (string, error) {
 	volumeSource, err := getVolumeSource(spec)
 	if err != nil {
-		glog.Warningf("failed to get azure disk spec")
+		glog.Warningf("failed to get azure disk spec (%v)", err)
 		return "", err
 	}
 
-	instanceid, err := a.cloud.InstanceID(nodeName)
+	instanceid, err := a.cloud.InstanceID(context.TODO(), nodeName)
 	if err != nil {
-		glog.Warningf("failed to get azure instance id")
-		return "", fmt.Errorf("failed to get azure instance id for node %q", nodeName)
-	}
-	if ind := strings.LastIndex(instanceid, "/"); ind >= 0 {
-		instanceid = instanceid[(ind + 1):]
+		glog.Warningf("failed to get azure instance id (%v)", err)
+		return "", fmt.Errorf("failed to get azure instance id for node %q (%v)", nodeName, err)
 	}
 
 	diskController, err := getDiskController(a.plugin.host)
@@ -96,8 +92,8 @@ func (a *azureDiskAttacher) Attach(spec *volume.Spec, nodeName types.NodeName) (
 
 		lun, err = diskController.GetNextDiskLun(nodeName)
 		if err != nil {
-			glog.Warningf("no LUN available for instance %q", nodeName)
-			return "", fmt.Errorf("all LUNs are used, cannot attach volume %q to instance %q", volumeSource.DiskName, instanceid)
+			glog.Warningf("no LUN available for instance %q (%v)", nodeName, err)
+			return "", fmt.Errorf("all LUNs are used, cannot attach volume %q to instance %q (%v)", volumeSource.DiskName, instanceid, err)
 		}
 		glog.V(4).Infof("Trying to attach volume %q lun %d to node %q.", volumeSource.DataDiskURI, lun, nodeName)
 		isManagedDisk := (*volumeSource.Kind == v1.AzureManagedDisk)
@@ -156,7 +152,7 @@ func (a *azureDiskAttacher) WaitForAttach(spec *volume.Spec, devicePath string,
 	var err error
 	lun, err := strconv.Atoi(devicePath)
 	if err != nil {
-		return "", fmt.Errorf("azureDisk - Wait for attach expect device path as a lun number, instead got: %s", devicePath)
+		return "", fmt.Errorf("azureDisk - Wait for attach expect device path as a lun number, instead got: %s (%v)", devicePath, err)
 	}
 
 	volumeSource, err := getVolumeSource(spec)
@@ -180,7 +176,7 @@ func (a *azureDiskAttacher) WaitForAttach(spec *volume.Spec, devicePath string,
 
 		// did we find it?
 		if newDevicePath != "" {
-			// the curent sequence k8s uses for unformated disk (check-disk, mount, fail, mkfs.extX) hangs on
+			// the current sequence k8s uses for unformated disk (check-disk, mount, fail, mkfs.extX) hangs on
 			// Azure Managed disk scsi interface. this is a hack and will be replaced once we identify and solve
 			// the root case on Azure.
 			formatIfNotFormatted(newDevicePath, *volumeSource.FSType, exec)
@@ -232,6 +228,19 @@ func (attacher *azureDiskAttacher) MountDevice(spec *volume.Spec, devicePath str
 		}
 	}
 
+	if !notMnt {
+		// testing original mount point, make sure the mount link is valid
+		if _, err := (&osIOHandler{}).ReadDir(deviceMountPath); err != nil {
+			// mount link is invalid, now unmount and remount later
+			glog.Warningf("azureDisk - ReadDir %s failed with %v, unmount this directory", deviceMountPath, err)
+			if err := mounter.Unmount(deviceMountPath); err != nil {
+				glog.Errorf("azureDisk - Unmount deviceMountPath %s failed with %v", deviceMountPath, err)
+				return err
+			}
+			notMnt = true
+		}
+	}
+
 	volumeSource, err := getVolumeSource(spec)
 	if err != nil {
 		return err
@@ -239,8 +248,8 @@ func (attacher *azureDiskAttacher) MountDevice(spec *volume.Spec, devicePath str
 
 	options := []string{}
 	if notMnt {
-		diskMounter := volumehelper.NewSafeFormatAndMountFromHost(azureDataDiskPluginName, attacher.plugin.host)
-		mountOptions := volume.MountOptionFromSpec(spec, options...)
+		diskMounter := util.NewSafeFormatAndMountFromHost(azureDataDiskPluginName, attacher.plugin.host)
+		mountOptions := util.MountOptionFromSpec(spec, options...)
 		err = diskMounter.FormatAndMount(devicePath, deviceMountPath, *volumeSource.FSType, mountOptions)
 		if err != nil {
 			if cleanErr := os.Remove(deviceMountPath); cleanErr != nil {
@@ -258,14 +267,11 @@ func (d *azureDiskDetacher) Detach(diskURI string, nodeName types.NodeName) erro
 		return fmt.Errorf("invalid disk to detach: %q", diskURI)
 	}
 
-	instanceid, err := d.cloud.InstanceID(nodeName)
+	instanceid, err := d.cloud.InstanceID(context.TODO(), nodeName)
 	if err != nil {
-		glog.Warningf("no instance id for node %q, skip detaching", nodeName)
+		glog.Warningf("no instance id for node %q, skip detaching (%v)", nodeName, err)
 		return nil
 	}
-	if ind := strings.LastIndex(instanceid, "/"); ind >= 0 {
-		instanceid = instanceid[(ind + 1):]
-	}
 
 	glog.V(4).Infof("detach %v from node %q", diskURI, nodeName)
 
@@ -273,6 +279,10 @@ func (d *azureDiskDetacher) Detach(diskURI string, nodeName types.NodeName) erro
 	if err != nil {
 		return err
 	}
+
+	getLunMutex.LockKey(instanceid)
+	defer getLunMutex.UnlockKey(instanceid)
+
 	err = diskController.DetachDiskByName("", diskURI, nodeName)
 	if err != nil {
 		glog.Errorf("failed to detach azure disk %q, err %v", diskURI, err)
@@ -284,7 +294,7 @@ func (d *azureDiskDetacher) Detach(diskURI string, nodeName types.NodeName) erro
 
 // UnmountDevice unmounts the volume on the node
 func (detacher *azureDiskDetacher) UnmountDevice(deviceMountPath string) error {
-	err := volumeutil.UnmountPath(deviceMountPath, detacher.plugin.host.GetMounter(detacher.plugin.GetPluginName()))
+	err := util.UnmountPath(deviceMountPath, detacher.plugin.host.GetMounter(detacher.plugin.GetPluginName()))
 	if err == nil {
 		glog.V(4).Infof("azureDisk - Device %s was unmounted", deviceMountPath)
 	} else {

vendor/k8s.io/kubernetes/pkg/volume/azure_dd/azure_common.go

@@ -35,9 +35,10 @@ import (
 )
 
 const (
-	defaultFSType             = "ext4"
-	defaultStorageAccountType = storage.StandardLRS
-	defaultAzureDiskKind      = v1.AzureSharedBlobDisk
+	defaultFSType                   = "ext4"
+	defaultStorageAccountType       = storage.StandardLRS
+	defaultAzureDiskKind            = v1.AzureSharedBlobDisk
+	defaultAzureDataDiskCachingMode = v1.AzureDataDiskCachingNone
 )
 
 type dataDisk struct {
@@ -141,7 +142,7 @@ func normalizeStorageAccountType(storageAccountType string) (storage.SkuName, er
 
 func normalizeCachingMode(cachingMode v1.AzureDataDiskCachingMode) (v1.AzureDataDiskCachingMode, error) {
 	if cachingMode == "" {
-		return v1.AzureDataDiskCachingReadWrite, nil
+		return defaultAzureDataDiskCachingMode, nil
 	}
 
 	if !supportedCachingModes.Has(string(cachingMode)) {

vendor/k8s.io/kubernetes/pkg/volume/azure_dd/azure_common_linux.go

@@ -19,6 +19,7 @@ limitations under the License.
 package azure_dd
 
 import (
+	"fmt"
 	"path"
 	"strconv"
 	libstrings "strings"
@@ -45,6 +46,28 @@ func listAzureDiskPath(io ioHandler) []string {
 	return azureDiskList
 }
 
+// getDiskLinkByDevName get disk link by device name from devLinkPath, e.g. /dev/disk/azure/, /dev/disk/by-id/
+func getDiskLinkByDevName(io ioHandler, devLinkPath, devName string) (string, error) {
+	dirs, err := io.ReadDir(devLinkPath)
+	glog.V(12).Infof("azureDisk - begin to find %s from %s", devName, devLinkPath)
+	if err == nil {
+		for _, f := range dirs {
+			diskPath := devLinkPath + f.Name()
+			glog.V(12).Infof("azureDisk - begin to Readlink: %s", diskPath)
+			link, linkErr := io.Readlink(diskPath)
+			if linkErr != nil {
+				glog.Warningf("azureDisk - read link (%s) error: %v", diskPath, linkErr)
+				continue
+			}
+			if libstrings.HasSuffix(link, devName) {
+				return diskPath, nil
+			}
+		}
+		return "", fmt.Errorf("device name(%s) is not found under %s", devName, devLinkPath)
+	}
+	return "", fmt.Errorf("read %s error: %v", devLinkPath, err)
+}
+
 func scsiHostRescan(io ioHandler, exec mount.Exec) {
 	scsi_path := "/sys/class/scsi_host/"
 	if dirs, err := io.ReadDir(scsi_path); err == nil {
@@ -129,15 +152,25 @@ func findDiskByLunWithConstraint(lun int, io ioHandler, azureDisks []string) (st
 				dir := path.Join(sys_path, name, "block")
 				if dev, err := io.ReadDir(dir); err == nil {
 					found := false
+					devName := dev[0].Name()
 					for _, diskName := range azureDisks {
-						glog.V(12).Infof("azure disk - validating disk %q with sys disk %q", dev[0].Name(), diskName)
-						if string(dev[0].Name()) == diskName {
+						glog.V(12).Infof("azureDisk - validating disk %q with sys disk %q", devName, diskName)
+						if devName == diskName {
 							found = true
 							break
 						}
 					}
 					if !found {
-						return "/dev/" + dev[0].Name(), nil
+						devLinkPaths := []string{"/dev/disk/azure/scsi1/", "/dev/disk/by-id/"}
+						for _, devLinkPath := range devLinkPaths {
+							diskPath, err := getDiskLinkByDevName(io, devLinkPath, devName)
+							if err == nil {
+								glog.V(4).Infof("azureDisk - found %s by %s under %s", diskPath, devName, devLinkPath)
+								return diskPath, nil
+							}
+							glog.Warningf("azureDisk - getDiskLinkByDevName by %s under %s failed, error: %v", devName, devLinkPath, err)
+						}
+						return "/dev/" + devName, nil
 					}
 				}
 			}

vendor/k8s.io/kubernetes/pkg/volume/azure_dd/azure_dd.go

@@ -26,7 +26,7 @@ import (
 	"k8s.io/kubernetes/pkg/volume"
 )
 
-// interface exposed by the cloud provider implementing Disk functionlity
+// interface exposed by the cloud provider implementing Disk functionality
 type DiskController interface {
 	CreateBlobDisk(dataDiskName string, storageAccountType storage.SkuName, sizeGB int) (string, error)
 	DeleteBlobDisk(diskUri string) error

vendor/k8s.io/kubernetes/pkg/volume/azure_dd/azure_mounter.go

@@ -86,8 +86,19 @@ func (m *azureDiskMounter) SetUpAt(dir string, fsGroup *int64) error {
 		return err
 	}
 	if !mountPoint {
-		glog.V(4).Infof("azureDisk - already mounted to target %s", dir)
-		return nil
+		// testing original mount point, make sure the mount link is valid
+		_, err := (&osIOHandler{}).ReadDir(dir)
+		if err == nil {
+			glog.V(4).Infof("azureDisk - already mounted to target %s", dir)
+			return nil
+		}
+		// mount link is invalid, now unmount and remount later
+		glog.Warningf("azureDisk - ReadDir %s failed with %v, unmount this directory", dir, err)
+		if err := mounter.Unmount(dir); err != nil {
+			glog.Errorf("azureDisk - Unmount directory %s failed with %v", dir, err)
+			return err
+		}
+		mountPoint = true
 	}
 
 	if runtime.GOOS != "windows" {
@@ -104,6 +115,10 @@ func (m *azureDiskMounter) SetUpAt(dir string, fsGroup *int64) error {
 		options = append(options, "ro")
 	}
 
+	if m.options.MountOptions != nil {
+		options = util.JoinMountOptions(m.options.MountOptions, options)
+	}
+
 	glog.V(4).Infof("azureDisk - Attempting to mount %s on %s", diskName, dir)
 	isManagedDisk := (*volumeSource.Kind == v1.AzureManagedDisk)
 	globalPDPath, err := makeGlobalPDPath(m.plugin.host, volumeSource.DataDiskURI, isManagedDisk)
@@ -140,7 +155,7 @@ func (m *azureDiskMounter) SetUpAt(dir string, fsGroup *int64) error {
 			return fmt.Errorf("azureDisk - SetupAt:Mount:Failure error cleaning up (removing dir:%s) with error:%v original-mountErr:%v", dir, err, mountErr)
 		}
 
-		glog.V(2).Infof("azureDisk - Mount of disk:%s on dir:%s failed with mount error:%v post failure clean up was completed", diskName, dir, err, mountErr)
+		glog.V(2).Infof("azureDisk - Mount of disk:%s on dir:%s failed with mount error:%v post failure clean up was completed", diskName, dir, mountErr)
 		return mountErr
 	}
 

vendor/k8s.io/kubernetes/pkg/volume/azure_dd/azure_provision.go

@@ -24,6 +24,7 @@ import (
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util"
 )
 
 type azureDiskProvisioner struct {
@@ -65,7 +66,7 @@ func (d *azureDiskDeleter) Delete() error {
 }
 
 func (p *azureDiskProvisioner) Provision() (*v1.PersistentVolume, error) {
-	if !volume.AccessModesContainedInAll(p.plugin.GetAccessModes(), p.options.PVC.Spec.AccessModes) {
+	if !util.AccessModesContainedInAll(p.plugin.GetAccessModes(), p.options.PVC.Spec.AccessModes) {
 		return nil, fmt.Errorf("invalid AccessModes %v: only AccessModes %v are supported", p.options.PVC.Spec.AccessModes, p.plugin.GetAccessModes())
 	}
 	supportedModes := p.plugin.GetAccessModes()
@@ -93,10 +94,10 @@ func (p *azureDiskProvisioner) Provision() (*v1.PersistentVolume, error) {
 		err                        error
 	)
 	// maxLength = 79 - (4 for ".vhd") = 75
-	name := volume.GenerateVolumeName(p.options.ClusterName, p.options.PVName, 75)
+	name := util.GenerateVolumeName(p.options.ClusterName, p.options.PVName, 75)
 	capacity := p.options.PVC.Spec.Resources.Requests[v1.ResourceName(v1.ResourceStorage)]
 	requestBytes := capacity.Value()
-	requestGB := int(volume.RoundUpSize(requestBytes, 1024*1024*1024))
+	requestGB := int(util.RoundUpSize(requestBytes, 1024*1024*1024))
 
 	for k, v := range p.options.Parameters {
 		switch strings.ToLower(k) {