Merge pull request #46360 from khenidak/azure-pd-final

Godeps/Godeps.json

@@ -39,6 +39,11 @@
 			"Rev": "786cc84138518bf7fd6d60e92fad1ac9d1a117ad"
 		},
 		{
+			"ImportPath": "github.com/Azure/azure-sdk-for-go/arm/disk",
+			"Comment": "v10.0.4-beta-1-g786cc84",
+			"Rev": "786cc84138518bf7fd6d60e92fad1ac9d1a117ad"
+		},
+		{
 			"ImportPath": "github.com/Azure/azure-sdk-for-go/arm/network",
 			"Comment": "v10.0.4-beta-1-g786cc84",
 			"Rev": "786cc84138518bf7fd6d60e92fad1ac9d1a117ad"

hack/verify-flags/excluded-flags.txt

@@ -24,3 +24,4 @@ valid_flag
 retry_time
 file_content_in_loop
 break_on_expected_content
+Premium_LRS

pkg/cloudprovider/providers/azure/BUILD

@@ -13,18 +13,19 @@ go_library(
     srcs = [
         "azure.go",
         "azure_backoff.go",
-        "azure_blob.go",
+        "azure_blobDiskController.go",
+        "azure_controllerCommon.go",
         "azure_file.go",
         "azure_instance_metadata.go",
         "azure_instances.go",
         "azure_loadbalancer.go",
+        "azure_managedDiskController.go",
         "azure_routes.go",
         "azure_storage.go",
         "azure_storageaccount.go",
         "azure_util.go",
         "azure_wrap.go",
         "azure_zones.go",
-        "vhd.go",
     ],
     tags = ["automanaged"],
     deps = [
@@ -34,6 +35,7 @@ go_library(
         "//pkg/version:go_default_library",
         "//pkg/volume: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/disk:go_default_library",
         "//vendor/github.com/Azure/azure-sdk-for-go/arm/network:go_default_library",
         "//vendor/github.com/Azure/azure-sdk-for-go/arm/storage:go_default_library",
         "//vendor/github.com/Azure/azure-sdk-for-go/storage:go_default_library",

pkg/cloudprovider/providers/azure/azure.go

@@ -30,6 +30,7 @@ import (
 	"k8s.io/kubernetes/pkg/version"
 
 	"github.com/Azure/azure-sdk-for-go/arm/compute"
+	"github.com/Azure/azure-sdk-for-go/arm/disk"
 	"github.com/Azure/azure-sdk-for-go/arm/network"
 	"github.com/Azure/azure-sdk-for-go/arm/storage"
 	"github.com/Azure/go-autorest/autorest"
@@ -122,8 +123,13 @@ type Cloud struct {
 	SecurityGroupsClient     network.SecurityGroupsClient
 	VirtualMachinesClient    compute.VirtualMachinesClient
 	StorageAccountClient     storage.AccountsClient
+	DisksClient              disk.DisksClient
 	operationPollRateLimiter flowcontrol.RateLimiter
 	resourceRequestBackoff   wait.Backoff
+
+	*BlobDiskController
+	*ManagedDiskController
+	*controllerCommon
 }
 
 func init() {
@@ -255,6 +261,11 @@ func NewCloud(configReader io.Reader) (cloudprovider.Interface, error) {
 
 	az.StorageAccountClient = storage.NewAccountsClientWithBaseURI(az.Environment.ResourceManagerEndpoint, az.SubscriptionID)
 	az.StorageAccountClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
+	configureUserAgent(&az.StorageAccountClient.Client)
+
+	az.DisksClient = disk.NewDisksClientWithBaseURI(az.Environment.ResourceManagerEndpoint, az.SubscriptionID)
+	az.DisksClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
+	configureUserAgent(&az.DisksClient.Client)
 
 	// Conditionally configure rate limits
 	if az.CloudProviderRateLimit {
@@ -304,6 +315,9 @@ func NewCloud(configReader io.Reader) (cloudprovider.Interface, error) {
 			az.CloudProviderBackoffJitter)
 	}
 
+	if err := initDiskControllers(&az); err != nil {
+		return nil, err
+	}
 	return &az, nil
 }
 
@@ -353,3 +367,42 @@ func configureUserAgent(client *autorest.Client) {
 	k8sVersion := version.Get().GitVersion
 	client.UserAgent = fmt.Sprintf("%s; kubernetes-cloudprovider/%s", client.UserAgent, k8sVersion)
 }
+
+func initDiskControllers(az *Cloud) error {
+	// Common controller contains the function
+	// needed by both blob disk and managed disk controllers
+
+	common := &controllerCommon{
+		aadResourceEndPoint:   az.Environment.ServiceManagementEndpoint,
+		clientID:              az.AADClientID,
+		clientSecret:          az.AADClientSecret,
+		location:              az.Location,
+		storageEndpointSuffix: az.Environment.StorageEndpointSuffix,
+		managementEndpoint:    az.Environment.ResourceManagerEndpoint,
+		resourceGroup:         az.ResourceGroup,
+		tenantID:              az.TenantID,
+		tokenEndPoint:         az.Environment.ActiveDirectoryEndpoint,
+		subscriptionID:        az.SubscriptionID,
+		cloud:                 az,
+	}
+
+	// BlobDiskController: contains the function needed to
+	// create/attach/detach/delete blob based (unmanaged disks)
+	blobController, err := newBlobDiskController(common)
+	if err != nil {
+		return fmt.Errorf("AzureDisk -  failed to init Blob Disk Controller with error (%s)", err.Error())
+	}
+
+	// ManagedDiskController: contains the functions needed to
+	// create/attach/detach/delete managed disks
+	managedController, err := newManagedDiskController(common)
+	if err != nil {
+		return fmt.Errorf("AzureDisk -  failed to init Managed  Disk Controller with error (%s)", err.Error())
+	}
+
+	az.BlobDiskController = blobController
+	az.ManagedDiskController = managedController
+	az.controllerCommon = common
+
+	return nil
+}

pkg/cloudprovider/providers/azure/azure_blob.go

-/*
-Copyright 2016 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 azure
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-
-	"bytes"
-
-	azs "github.com/Azure/azure-sdk-for-go/storage"
-)
-
-const (
-	vhdContainerName = "vhds"
-	useHTTPS         = true
-	blobServiceName  = "blob"
-)
-
-// create page blob
-func (az *Cloud) createVhdBlob(accountName, accountKey, name string, sizeGB int64, tags map[string]string) (string, string, error) {
-	blobClient, err := az.getBlobClient(accountName, accountKey)
-	if err != nil {
-		return "", "", err
-	}
-	size := 1024 * 1024 * 1024 * sizeGB
-	vhdSize := size + vhdHeaderSize /* header size */
-	// Blob name in URL must end with '.vhd' extension.
-	name = name + ".vhd"
-	cnt := blobClient.GetContainerReference(vhdContainerName)
-	b := cnt.GetBlobReference(name)
-	b.Properties.ContentLength = vhdSize
-	b.Metadata = tags
-	err = b.PutPageBlob(nil)
-	if err != nil {
-		// if container doesn't exist, create one and retry PutPageBlob
-		detail := err.Error()
-		if strings.Contains(detail, errContainerNotFound) {
-			err = cnt.Create(&azs.CreateContainerOptions{Access: azs.ContainerAccessTypePrivate})
-			if err == nil {
-				b := cnt.GetBlobReference(name)
-				b.Properties.ContentLength = vhdSize
-				b.Metadata = tags
-				err = b.PutPageBlob(nil)
-			}
-		}
-	}
-	if err != nil {
-		return "", "", fmt.Errorf("failed to put page blob: %v", err)
-	}
-
-	// add VHD signature to the blob
-	h, err := createVHDHeader(uint64(size))
-	if err != nil {
-		az.deleteVhdBlob(accountName, accountKey, name)
-		return "", "", fmt.Errorf("failed to create vhd header, err: %v", err)
-	}
-	blobRange := azs.BlobRange{
-		Start: uint64(size),
-		End:   uint64(vhdSize - 1),
-	}
-	if err = b.WriteRange(blobRange, bytes.NewBuffer(h[:vhdHeaderSize]), nil); err != nil {
-		az.deleteVhdBlob(accountName, accountKey, name)
-		return "", "", fmt.Errorf("failed to update vhd header, err: %v", err)
-	}
-
-	scheme := "http"
-	if useHTTPS {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s.%s.%s", scheme, accountName, blobServiceName, az.Environment.StorageEndpointSuffix)
-	uri := fmt.Sprintf("%s/%s/%s", host, vhdContainerName, name)
-	return name, uri, nil
-
-}
-
-// delete a vhd blob
-func (az *Cloud) deleteVhdBlob(accountName, accountKey, blobName string) error {
-	blobClient, err := az.getBlobClient(accountName, accountKey)
-	if err == nil {
-		cnt := blobClient.GetContainerReference(vhdContainerName)
-		b := cnt.GetBlobReference(blobName)
-		return b.Delete(nil)
-	}
-	return err
-}
-
-func (az *Cloud) getBlobClient(accountName, accountKey string) (*azs.BlobStorageClient, error) {
-	client, err := azs.NewClient(accountName, accountKey, az.Environment.StorageEndpointSuffix, azs.DefaultAPIVersion, useHTTPS)
-	if err != nil {
-		return nil, fmt.Errorf("error creating azure client: %v", err)
-	}
-	b := client.GetBlobService()
-	return &b, nil
-}
-
-// get uri https://foo.blob.core.windows.net/vhds/bar.vhd and return foo (account) and bar.vhd (blob name)
-func (az *Cloud) getBlobNameAndAccountFromURI(uri string) (string, string, error) {
-	scheme := "http"
-	if useHTTPS {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://(.*).%s.%s", scheme, blobServiceName, az.Environment.StorageEndpointSuffix)
-	reStr := fmt.Sprintf("%s/%s/(.*)", host, vhdContainerName)
-	re := regexp.MustCompile(reStr)
-	res := re.FindSubmatch([]byte(uri))
-	if len(res) < 3 {
-		return "", "", fmt.Errorf("invalid vhd URI for regex %s: %s", reStr, uri)
-	}
-	return string(res[1]), string(res[2]), nil
-}

pkg/cloudprovider/providers/azure/azure_controllerCommon.go

+/*
+Copyright 2017 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 azure
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"k8s.io/apimachinery/pkg/types"
+	kwait "k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/kubernetes/pkg/cloudprovider"
+
+	"github.com/Azure/azure-sdk-for-go/arm/compute"
+	"github.com/golang/glog"
+)
+
+const (
+	defaultDataDiskCount       int = 16 // which will allow you to work with most medium size VMs (if not found in map)
+	storageAccountNameTemplate     = "pvc%s"
+
+	// for limits check https://docs.microsoft.com/en-us/azure/azure-subscription-service-limits#storage-limits
+	maxStorageAccounts                     = 100 // max # is 200 (250 with special request). this allows 100 for everything else including stand alone disks
+	maxDisksPerStorageAccounts             = 60
+	storageAccountUtilizationBeforeGrowing = 0.5
+	storageAccountsCountInit               = 2 // When the plug-in is init-ed, 2 storage accounts will be created to allow fast pvc create/attach/mount
+
+	maxLUN               = 64 // max number of LUNs per VM
+	errLeaseFailed       = "AcquireDiskLeaseFailed"
+	errLeaseIDMissing    = "LeaseIdMissing"
+	errContainerNotFound = "ContainerNotFound"
+)
+
+var defaultBackOff = kwait.Backoff{
+	Steps:    20,
+	Duration: 2 * time.Second,
+	Factor:   1.5,
+	Jitter:   0.0,
+}
+
+type controllerCommon struct {
+	tenantID              string
+	subscriptionID        string
+	location              string
+	storageEndpointSuffix string
+	resourceGroup         string
+	clientID              string
+	clientSecret          string
+	managementEndpoint    string
+	tokenEndPoint         string
+	aadResourceEndPoint   string
+	aadToken              string
+	expiresOn             time.Time
+	cloud                 *Cloud
+}
+
+// AttachDisk attaches a vhd to vm
+// the vhd must exist, can be identified by diskName, diskURI, and lun.
+func (c *controllerCommon) AttachDisk(isManagedDisk bool, diskName, diskURI string, nodeName types.NodeName, lun int32, cachingMode compute.CachingTypes) error {
+	vm, exists, err := c.cloud.getVirtualMachine(nodeName)
+	if err != nil {
+		return err
+	} else if !exists {
+		return cloudprovider.InstanceNotFound
+	}
+	disks := *vm.StorageProfile.DataDisks
+	if isManagedDisk {
+		disks = append(disks,
+			compute.DataDisk{
+				Name:         &diskName,
+				Lun:          &lun,
+				Caching:      cachingMode,
+				CreateOption: "attach",
+				ManagedDisk: &compute.ManagedDiskParameters{
+					ID: &diskURI,
+				},
+			})
+	} else {
+		disks = append(disks,
+			compute.DataDisk{
+				Name: &diskName,
+				Vhd: &compute.VirtualHardDisk{
+					URI: &diskURI,
+				},
+				Lun:          &lun,
+				Caching:      cachingMode,
+				CreateOption: "attach",
+			})
+	}
+
+	newVM := compute.VirtualMachine{
+		Location: vm.Location,
+		VirtualMachineProperties: &compute.VirtualMachineProperties{
+			StorageProfile: &compute.StorageProfile{
+				DataDisks: &disks,
+			},
+		},
+	}
+	vmName := mapNodeNameToVMName(nodeName)
+	glog.V(2).Infof("azureDisk - update(%s): vm(%s) - attach disk", c.resourceGroup, vmName)
+	c.cloud.operationPollRateLimiter.Accept()
+	respChan, errChan := c.cloud.VirtualMachinesClient.CreateOrUpdate(c.resourceGroup, vmName, newVM, nil)
+	resp := <-respChan
+	err = <-errChan
+	if c.cloud.CloudProviderBackoff && shouldRetryAPIRequest(resp.Response, err) {
+		glog.V(2).Infof("azureDisk - update(%s) backing off: vm(%s)", c.resourceGroup, vmName)
+		retryErr := c.cloud.CreateOrUpdateVMWithRetry(vmName, newVM)
+		if retryErr != nil {
+			err = retryErr
+			glog.V(2).Infof("azureDisk - update(%s) abort backoff: vm(%s)", c.resourceGroup, vmName)
+		}
+	}
+	if err != nil {
+		glog.Errorf("azureDisk - azure attach failed, err: %v", err)
+		detail := err.Error()
+		if strings.Contains(detail, errLeaseFailed) {
+			// if lease cannot be acquired, immediately detach the disk and return the original error
+			glog.Infof("azureDisk - failed to acquire disk lease, try detach")
+			c.cloud.DetachDiskByName(diskName, diskURI, nodeName)
+		}
+	} else {
+		glog.V(4).Infof("azureDisk - azure attach succeeded")
+	}
+	return err
+}
+
+// DetachDiskByName detaches a vhd from host
+// the vhd can be identified by diskName or diskURI
+func (c *controllerCommon) DetachDiskByName(diskName, diskURI string, nodeName types.NodeName) error {
+	vm, exists, err := c.cloud.getVirtualMachine(nodeName)
+	if err != nil || !exists {
+		// if host doesn't exist, no need to detach
+		glog.Warningf("azureDisk - cannot find node %s, skip detaching disk %s", nodeName, diskName)
+		return nil
+	}
+
+	disks := *vm.StorageProfile.DataDisks
+	bFoundDisk := false
+	for i, disk := range disks {
+		if disk.Lun != nil && (disk.Name != nil && diskName != "" && *disk.Name == diskName) ||
+			(disk.Vhd != nil && disk.Vhd.URI != nil && diskURI != "" && *disk.Vhd.URI == diskURI) ||
+			(disk.ManagedDisk != nil && diskURI != "" && *disk.ManagedDisk.ID == diskURI) {
+			// found the disk
+			glog.V(4).Infof("azureDisk - detach disk: name %q uri %q", diskName, diskURI)
+			disks = append(disks[:i], disks[i+1:]...)
+			bFoundDisk = true
+			break
+		}
+	}
+
+	if !bFoundDisk {
+		return fmt.Errorf("detach azure disk failure, disk %s not found, diskURI: %s", diskName, diskURI)
+	}
+
+	newVM := compute.VirtualMachine{
+		Location: vm.Location,
+		VirtualMachineProperties: &compute.VirtualMachineProperties{
+			StorageProfile: &compute.StorageProfile{
+				DataDisks: &disks,
+			},
+		},
+	}
+	vmName := mapNodeNameToVMName(nodeName)
+	glog.V(2).Infof("azureDisk - update(%s): vm(%s) - detach disk", c.resourceGroup, vmName)
+	c.cloud.operationPollRateLimiter.Accept()
+	respChan, errChan := c.cloud.VirtualMachinesClient.CreateOrUpdate(c.resourceGroup, vmName, newVM, nil)
+	resp := <-respChan
+	err = <-errChan
+	if c.cloud.CloudProviderBackoff && shouldRetryAPIRequest(resp.Response, err) {
+		glog.V(2).Infof("azureDisk - update(%s) backing off: vm(%s)", c.resourceGroup, vmName)
+		retryErr := c.cloud.CreateOrUpdateVMWithRetry(vmName, newVM)
+		if retryErr != nil {
+			err = retryErr
+			glog.V(2).Infof("azureDisk - update(%s) abort backoff: vm(%s)", c.cloud.ResourceGroup, vmName)
+		}
+	}
+	if err != nil {
+		glog.Errorf("azureDisk - azure disk detach failed, err: %v", err)
+	} else {
+		glog.V(4).Infof("azureDisk - azure disk detach succeeded")
+	}
+	return err
+}
+
+// GetDiskLun finds the lun on the host that the vhd is attached to, given a vhd's diskName and diskURI
+func (c *controllerCommon) GetDiskLun(diskName, diskURI string, nodeName types.NodeName) (int32, error) {
+	vm, exists, err := c.cloud.getVirtualMachine(nodeName)
+	if err != nil {
+		return -1, err
+	} else if !exists {
+		return -1, cloudprovider.InstanceNotFound
+	}
+	disks := *vm.StorageProfile.DataDisks
+	for _, disk := range disks {
+		if disk.Lun != nil && (disk.Name != nil && diskName != "" && *disk.Name == diskName) ||
+			(disk.Vhd != nil && disk.Vhd.URI != nil && diskURI != "" && *disk.Vhd.URI == diskURI) ||
+			(disk.ManagedDisk != nil && *disk.ManagedDisk.ID == diskURI) {
+			// found the disk
+			glog.V(4).Infof("azureDisk - find disk: lun %d name %q uri %q", *disk.Lun, diskName, diskURI)
+			return *disk.Lun, nil
+		}
+	}
+	return -1, fmt.Errorf("Cannot find Lun for disk %s", diskName)
+}
+
+// GetNextDiskLun searches all vhd attachment on the host and find unused lun
+// return -1 if all luns are used
+func (c *controllerCommon) GetNextDiskLun(nodeName types.NodeName) (int32, error) {
+	vm, exists, err := c.cloud.getVirtualMachine(nodeName)
+	if err != nil {
+		return -1, err
+	} else if !exists {
+		return -1, cloudprovider.InstanceNotFound
+	}
+	used := make([]bool, maxLUN)
+	disks := *vm.StorageProfile.DataDisks
+	for _, disk := range disks {
+		if disk.Lun != nil {
+			used[*disk.Lun] = true
+		}
+	}
+	for k, v := range used {
+		if !v {
+			return int32(k), nil
+		}
+	}
+	return -1, fmt.Errorf("All Luns are used")
+}
+
+// DisksAreAttached checks if a list of volumes are attached to the node with the specified NodeName
+func (c *controllerCommon) DisksAreAttached(diskNames []string, nodeName types.NodeName) (map[string]bool, error) {
+	attached := make(map[string]bool)
+	for _, diskName := range diskNames {
+		attached[diskName] = false
+	}
+	vm, exists, err := c.cloud.getVirtualMachine(nodeName)
+	if !exists {
+		// if host doesn't exist, no need to detach
+		glog.Warningf("azureDisk - Cannot find node %q, DisksAreAttached will assume disks %v are not attached to it.",
+			nodeName, diskNames)
+		return attached, nil
+	} else if err != nil {
+		return attached, err
+	}
+
+	disks := *vm.StorageProfile.DataDisks
+	for _, disk := range disks {
+		for _, diskName := range diskNames {
+			if disk.Name != nil && diskName != "" && *disk.Name == diskName {
+				attached[diskName] = true
+			}
+		}
+	}
+
+	return attached, nil
+}

pkg/cloudprovider/providers/azure/azure_file.go

@@ -23,6 +23,10 @@ import (
 	"github.com/golang/glog"
 )
 
+const (
+	useHTTPS = true
+)
+
 // create file share
 func (az *Cloud) createFileShare(accountName, accountKey, name string, sizeGB int) error {
 	fileClient, err := az.getFileSvcClient(accountName, accountKey)
@@ -55,7 +59,7 @@ func (az *Cloud) deleteFileShare(accountName, accountKey, name string) error {
 		share := fileClient.GetShareReference(name)
 		return share.Delete(nil)
 	}
-	return err
+	return nil
 }
 
 func (az *Cloud) getFileSvcClient(accountName, accountKey string) (*azs.FileServiceClient, error) {

pkg/cloudprovider/providers/azure/azure_managedDiskController.go

+/*
+Copyright 2017 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 azure
+
+import (
+	"path"
+	"strings"
+
+	"github.com/Azure/azure-sdk-for-go/arm/disk"
+	storage "github.com/Azure/azure-sdk-for-go/arm/storage"
+	"github.com/golang/glog"
+	kwait "k8s.io/apimachinery/pkg/util/wait"
+)
+
+//ManagedDiskController : managed disk controller struct
+type ManagedDiskController struct {
+	common *controllerCommon
+}
+
+func newManagedDiskController(common *controllerCommon) (*ManagedDiskController, error) {
+	return &ManagedDiskController{common: common}, nil
+}
+
+//CreateManagedDisk : create managed disk
+func (c *ManagedDiskController) CreateManagedDisk(diskName string, storageAccountType storage.SkuName, sizeGB int, tags map[string]string) (string, error) {
+	glog.V(4).Infof("azureDisk - creating new managed Name:%s StorageAccountType:%s Size:%v", diskName, storageAccountType, sizeGB)
+
+	newTags := make(map[string]*string)
+	azureDDTag := "kubernetes-azure-dd"
+	newTags["created-by"] = &azureDDTag
+
+	// insert original tags to newTags
+	if tags != nil {
+		for k, v := range tags {
+			// Azure won't allow / (forward slash) in tags
+			newKey := strings.Replace(k, "/", "-", -1)
+			newValue := strings.Replace(v, "/", "-", -1)
+			newTags[newKey] = &newValue
+		}
+	}
+
+	diskSizeGB := int32(sizeGB)
+	model := disk.Model{
+		Location: &c.common.location,
+		Tags:     &newTags,
+		Properties: &disk.Properties{
+			AccountType:  disk.StorageAccountTypes(storageAccountType),
+			DiskSizeGB:   &diskSizeGB,
+			CreationData: &disk.CreationData{CreateOption: disk.Empty},
+		}}
+	cancel := make(chan struct{})
+	respChan, errChan := c.common.cloud.DisksClient.CreateOrUpdate(c.common.resourceGroup, diskName, model, cancel)
+	<-respChan
+	err := <-errChan
+	if err != nil {
+		return "", err
+	}
+
+	diskID := ""
+
+	err = kwait.ExponentialBackoff(defaultBackOff, func() (bool, error) {
+		provisonState, id, err := c.getDisk(diskName)
+		diskID = id
+		// We are waiting for provisioningState==Succeeded
+		// We don't want to hand-off managed disks to k8s while they are
+		//still being provisioned, this is to avoid some race conditions
+		if err != nil {
+			return false, err
+		}
+		if strings.ToLower(provisonState) == "succeeded" {
+			return true, nil
+		}
+		return false, nil
+	})
+
+	if err != nil {
+		glog.V(2).Infof("azureDisk - created new MD Name:%s StorageAccountType:%s Size:%v but was unable to confirm provisioningState in poll process", diskName, storageAccountType, sizeGB)
+	} else {
+		glog.V(2).Infof("azureDisk - created new MD Name:%s StorageAccountType:%s Size:%v", diskName, storageAccountType, sizeGB)
+	}
+
+	return diskID, nil
+}
+
+//DeleteManagedDisk : delete managed disk
+func (c *ManagedDiskController) DeleteManagedDisk(diskURI string) error {
+	diskName := path.Base(diskURI)
+	cancel := make(chan struct{})
+	respChan, errChan := c.common.cloud.DisksClient.Delete(c.common.resourceGroup, diskName, cancel)
+	<-respChan
+	err := <-errChan
+	if err != nil {
+		return err
+	}
+	// We don't need poll here, k8s will immediatly stop referencing the disk
+	// the disk will be evantually deleted - cleanly - by ARM
+
+	glog.V(2).Infof("azureDisk - deleted a managed disk: %s", diskURI)
+
+	return nil
+}
+
+// return: disk provisionState, diskID, error
+func (c *ManagedDiskController) getDisk(diskName string) (string, string, error) {
+	result, err := c.common.cloud.DisksClient.Get(c.common.resourceGroup, diskName)
+	if err != nil {
+		return "", "", err
+	}
+
+	if result.Properties != nil && (*result.Properties).ProvisioningState != nil {
+		return *(*result.Properties).ProvisioningState, *result.ID, nil
+	}
+
+	return "", "", err
+}

pkg/cloudprovider/providers/azure/azure_storage.go

@@ -18,264 +18,10 @@ package azure
 
 import (
 	"fmt"
-	"strings"
 
-	"github.com/Azure/azure-sdk-for-go/arm/compute"
 	"github.com/golang/glog"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/kubernetes/pkg/cloudprovider"
-	"k8s.io/kubernetes/pkg/volume"
 )
 
-const (
-	maxLUN               = 64 // max number of LUNs per VM
-	errLeaseFailed       = "AcquireDiskLeaseFailed"
-	errLeaseIDMissing    = "LeaseIdMissing"
-	errContainerNotFound = "ContainerNotFound"
-)
-
-// AttachDisk attaches a vhd to vm
-// the vhd must exist, can be identified by diskName, diskURI, and lun.
-func (az *Cloud) AttachDisk(diskName, diskURI string, nodeName types.NodeName, lun int32, cachingMode compute.CachingTypes) error {
-	vm, exists, err := az.getVirtualMachine(nodeName)
-	if err != nil {
-		return err
-	} else if !exists {
-		return cloudprovider.InstanceNotFound
-	}
-	disks := *vm.StorageProfile.DataDisks
-	disks = append(disks,
-		compute.DataDisk{
-			Name: &diskName,
-			Vhd: &compute.VirtualHardDisk{
-				URI: &diskURI,
-			},
-			Lun:          &lun,
-			Caching:      cachingMode,
-			CreateOption: "attach",
-		})
-
-	newVM := compute.VirtualMachine{
-		Location: vm.Location,
-		VirtualMachineProperties: &compute.VirtualMachineProperties{
-			StorageProfile: &compute.StorageProfile{
-				DataDisks: &disks,
-			},
-		},
-	}
-	vmName := mapNodeNameToVMName(nodeName)
-	glog.V(2).Infof("create(%s): vm(%s)", az.ResourceGroup, vmName)
-	az.operationPollRateLimiter.Accept()
-	respChan, errChan := az.VirtualMachinesClient.CreateOrUpdate(az.ResourceGroup, vmName, newVM, nil)
-	resp := <-respChan
-	err = <-errChan
-	if az.CloudProviderBackoff && shouldRetryAPIRequest(resp.Response, err) {
-		glog.V(2).Infof("create(%s) backing off: vm(%s)", az.ResourceGroup, vmName)
-		retryErr := az.CreateOrUpdateVMWithRetry(vmName, newVM)
-		if retryErr != nil {
-			err = retryErr
-			glog.V(2).Infof("create(%s) abort backoff: vm(%s)", az.ResourceGroup, vmName)
-		}
-	}
-	if err != nil {
-		glog.Errorf("azure attach failed, err: %v", err)
-		detail := err.Error()
-		if strings.Contains(detail, errLeaseFailed) {
-			// if lease cannot be acquired, immediately detach the disk and return the original error
-			glog.Infof("failed to acquire disk lease, try detach")
-			az.DetachDiskByName(diskName, diskURI, nodeName)
-		}
-	} else {
-		glog.V(4).Infof("azure attach succeeded")
-	}
-	return err
-}
-
-// DisksAreAttached checks if a list of volumes are attached to the node with the specified NodeName
-func (az *Cloud) DisksAreAttached(diskNames []string, nodeName types.NodeName) (map[string]bool, error) {
-	attached := make(map[string]bool)
-	for _, diskName := range diskNames {
-		attached[diskName] = false
-	}
-	vm, exists, err := az.getVirtualMachine(nodeName)
-	if !exists {
-		// if host doesn't exist, no need to detach
-		glog.Warningf("Cannot find node %q, DisksAreAttached will assume disks %v are not attached to it.",
-			nodeName, diskNames)
-		return attached, nil
-	} else if err != nil {
-		return attached, err
-	}
-
-	disks := *vm.StorageProfile.DataDisks
-	for _, disk := range disks {
-		for _, diskName := range diskNames {
-			if disk.Name != nil && diskName != "" && *disk.Name == diskName {
-				attached[diskName] = true
-			}
-		}
-	}
-
-	return attached, nil
-}
-
-// DetachDiskByName detaches a vhd from host
-// the vhd can be identified by diskName or diskURI
-func (az *Cloud) DetachDiskByName(diskName, diskURI string, nodeName types.NodeName) error {
-	vm, exists, err := az.getVirtualMachine(nodeName)
-	if err != nil || !exists {
-		// if host doesn't exist, no need to detach
-		glog.Warningf("cannot find node %s, skip detaching disk %s", nodeName, diskName)
-		return nil
-	}
-
-	disks := *vm.StorageProfile.DataDisks
-	for i, disk := range disks {
-		if (disk.Name != nil && diskName != "" && *disk.Name == diskName) || (disk.Vhd.URI != nil && diskURI != "" && *disk.Vhd.URI == diskURI) {
-			// found the disk
-			glog.V(4).Infof("detach disk: name %q uri %q", diskName, diskURI)
-			disks = append(disks[:i], disks[i+1:]...)
-			break
-		}
-	}
-	newVM := compute.VirtualMachine{
-		Location: vm.Location,
-		VirtualMachineProperties: &compute.VirtualMachineProperties{
-			StorageProfile: &compute.StorageProfile{
-				DataDisks: &disks,
-			},
-		},
-	}
-	vmName := mapNodeNameToVMName(nodeName)
-	glog.V(2).Infof("create(%s): vm(%s)", az.ResourceGroup, vmName)
-	az.operationPollRateLimiter.Accept()
-	respChan, errChan := az.VirtualMachinesClient.CreateOrUpdate(az.ResourceGroup, vmName, newVM, nil)
-	resp := <-respChan
-	err = <-errChan
-	if az.CloudProviderBackoff && shouldRetryAPIRequest(resp.Response, err) {
-		glog.V(2).Infof("create(%s) backing off: vm(%s)", az.ResourceGroup, vmName)
-		retryErr := az.CreateOrUpdateVMWithRetry(vmName, newVM)
-		if retryErr != nil {
-			err = retryErr
-			glog.V(2).Infof("create(%s) abort backoff: vm(%s)", az.ResourceGroup, vmName)
-		}
-	}
-	if err != nil {
-		glog.Errorf("azure disk detach failed, err: %v", err)
-	} else {
-		glog.V(4).Infof("azure disk detach succeeded")
-	}
-	return err
-}
-
-// GetDiskLun finds the lun on the host that the vhd is attached to, given a vhd's diskName and diskURI
-func (az *Cloud) GetDiskLun(diskName, diskURI string, nodeName types.NodeName) (int32, error) {
-	vm, exists, err := az.getVirtualMachine(nodeName)
-	if err != nil {
-		return -1, err
-	} else if !exists {
-		return -1, cloudprovider.InstanceNotFound
-	}
-	disks := *vm.StorageProfile.DataDisks
-	for _, disk := range disks {
-		if disk.Lun != nil && (disk.Name != nil && diskName != "" && *disk.Name == diskName) || (disk.Vhd.URI != nil && diskURI != "" && *disk.Vhd.URI == diskURI) {
-			// found the disk
-			glog.V(4).Infof("find disk: lun %d name %q uri %q", *disk.Lun, diskName, diskURI)
-			return *disk.Lun, nil
-		}
-	}
-	return -1, fmt.Errorf("Cannot find Lun for disk %s", diskName)
-}
-
-// GetNextDiskLun searches all vhd attachment on the host and find unused lun
-// return -1 if all luns are used
-func (az *Cloud) GetNextDiskLun(nodeName types.NodeName) (int32, error) {
-	vm, exists, err := az.getVirtualMachine(nodeName)
-	if err != nil {
-		return -1, err
-	} else if !exists {
-		return -1, cloudprovider.InstanceNotFound
-	}
-	used := make([]bool, maxLUN)
-	disks := *vm.StorageProfile.DataDisks
-	for _, disk := range disks {
-		if disk.Lun != nil {
-			used[*disk.Lun] = true
-		}
-	}
-	for k, v := range used {
-		if !v {
-			return int32(k), nil
-		}
-	}
-	return -1, fmt.Errorf("All Luns are used")
-}
-
-// CreateVolume creates a VHD blob in a storage account that has storageType and location using the given storage account.
-// If no storage account is given, search all the storage accounts associated with the resource group and pick one that
-// fits storage type and location.
-func (az *Cloud) CreateVolume(name, storageAccount, storageType, location string, requestGB int) (string, string, int, error) {
-	var err error
-	accounts := []accountWithLocation{}
-	if len(storageAccount) > 0 {
-		accounts = append(accounts, accountWithLocation{Name: storageAccount})
-	} else {
-		// find a storage account
-		accounts, err = az.getStorageAccounts()
-		if err != nil {
-			// TODO: create a storage account and container
-			return "", "", 0, err
-		}
-	}
-	for _, account := range accounts {
-		glog.V(4).Infof("account %s type %s location %s", account.Name, account.StorageType, account.Location)
-		if ((storageType == "" || account.StorageType == storageType) && (location == "" || account.Location == location)) || len(storageAccount) > 0 {
-			// find the access key with this account
-			key, err := az.getStorageAccesskey(account.Name)
-			if err != nil {
-				glog.V(2).Infof("no key found for storage account %s", account.Name)
-				continue
-			}
-
-			// create a page blob in this account's vhd container
-			name, uri, err := az.createVhdBlob(account.Name, key, name, int64(requestGB), nil)
-			if err != nil {
-				glog.V(2).Infof("failed to create vhd in account %s: %v", account.Name, err)
-				continue
-			}
-			glog.V(4).Infof("created vhd blob uri: %s", uri)
-			return name, uri, requestGB, err
-		}
-	}
-	return "", "", 0, fmt.Errorf("failed to find a matching storage account")
-}
-
-// DeleteVolume deletes a VHD blob
-func (az *Cloud) DeleteVolume(name, uri string) error {
-	accountName, blob, err := az.getBlobNameAndAccountFromURI(uri)
-	if err != nil {
-		return fmt.Errorf("failed to parse vhd URI %v", err)
-	}
-	key, err := az.getStorageAccesskey(accountName)
-	if err != nil {
-		return fmt.Errorf("no key for storage account %s, err %v", accountName, err)
-	}
-	err = az.deleteVhdBlob(accountName, key, blob)
-	if err != nil {
-		glog.Warningf("failed to delete blob %s err: %v", uri, err)
-		detail := err.Error()
-		if strings.Contains(detail, errLeaseIDMissing) {
-			// disk is still being used
-			// see https://msdn.microsoft.com/en-us/library/microsoft.windowsazure.storage.blob.protocol.bloberrorcodestrings.leaseidmissing.aspx
-			return volume.NewDeletedVolumeInUseError(fmt.Sprintf("disk %q is still in use while being deleted", name))
-		}
-		return fmt.Errorf("failed to delete vhd %v, account %s, blob %s, err: %v", uri, accountName, blob, err)
-	}
-	glog.V(4).Infof("blob %s deleted", uri)
-	return nil
-
-}
-
 // CreateFileShare creates a file share, using a matching storage account
 func (az *Cloud) CreateFileShare(name, storageAccount, storageType, location string, requestGB int) (string, string, error) {
 	var err error

pkg/cloudprovider/providers/azure/azure_util.go

@@ -19,7 +19,9 @@ package azure
 import (
 	"errors"
 	"fmt"
+	"hash/crc32"
 	"regexp"
+	"strconv"
 	"strings"
 
 	"k8s.io/api/core/v1"
@@ -293,3 +295,58 @@ func splitProviderID(providerID string) (types.NodeName, error) {
 	}
 	return types.NodeName(matches[1]), nil
 }
+
+var polyTable = crc32.MakeTable(crc32.Koopman)
+
+//MakeCRC32 : convert string to CRC32 format
+func MakeCRC32(str string) string {
+	crc := crc32.New(polyTable)
+	crc.Write([]byte(str))
+	hash := crc.Sum32()
+	return strconv.FormatUint(uint64(hash), 10)
+}
+
+//ExtractVMData : extract dataDisks, storageProfile from a map struct
+func ExtractVMData(vmData map[string]interface{}) (dataDisks []interface{},
+	storageProfile map[string]interface{},
+	hardwareProfile map[string]interface{}, err error) {
+	props, ok := vmData["properties"].(map[string]interface{})
+	if !ok {
+		return nil, nil, nil, fmt.Errorf("convert vmData(properties) to map error")
+	}
+
+	storageProfile, ok = props["storageProfile"].(map[string]interface{})
+	if !ok {
+		return nil, nil, nil, fmt.Errorf("convert vmData(storageProfile) to map error")
+	}
+
+	hardwareProfile, ok = props["hardwareProfile"].(map[string]interface{})
+	if !ok {
+		return nil, nil, nil, fmt.Errorf("convert vmData(hardwareProfile) to map error")
+	}
+
+	dataDisks, ok = storageProfile["dataDisks"].([]interface{})
+	if !ok {
+		return nil, nil, nil, fmt.Errorf("convert vmData(dataDisks) to map error")
+	}
+	return dataDisks, storageProfile, hardwareProfile, nil
+}
+
+//ExtractDiskData : extract provisioningState, diskState from a map struct
+func ExtractDiskData(diskData interface{}) (provisioningState string, diskState string, err error) {
+	fragment, ok := diskData.(map[string]interface{})
+	if !ok {
+		return "", "", fmt.Errorf("convert diskData to map error")
+	}
+
+	properties, ok := fragment["properties"].(map[string]interface{})
+	if !ok {
+		return "", "", fmt.Errorf("convert diskData(properties) to map error")
+	}
+
+	provisioningState, ok = properties["provisioningState"].(string) // if there is a disk, provisioningState property will be there
+	if ref, ok := properties["diskState"]; ok {
+		diskState = ref.(string)
+	}
+	return provisioningState, diskState, nil
+}

pkg/cloudprovider/providers/azure/vhd.go

-/*
-Copyright 2016 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 azure
-
-import (
-	"bytes"
-	"encoding/binary"
-
-	"github.com/rubiojr/go-vhd/vhd"
-)
-
-const (
-	vhdHeaderSize = vhd.VHD_HEADER_SIZE
-)
-
-func createVHDHeader(size uint64) ([]byte, error) {
-	h := vhd.CreateFixedHeader(size, &vhd.VHDOptions{})
-	b := new(bytes.Buffer)
-	err := binary.Write(b, binary.BigEndian, h)
-	if err != nil {
-		return nil, err
-	}
-	return b.Bytes(), nil
-}

pkg/volume/azure_dd/BUILD

@@ -12,12 +12,14 @@ go_library(
     name = "go_default_library",
     srcs = [
         "attacher.go",
+        "azure_common.go",
         "azure_dd.go",
+        "azure_mounter.go",
         "azure_provision.go",
-        "vhd_util.go",
     ],
     tags = ["automanaged"],
     deps = [
+        "//pkg/api:go_default_library",
         "//pkg/cloudprovider:go_default_library",
         "//pkg/cloudprovider/providers/azure:go_default_library",
         "//pkg/util/exec:go_default_library",
@@ -26,46 +28,44 @@ 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",
         "//vendor/k8s.io/api/core/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
     ],
 )
 
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
 go_test(
     name = "go_default_test",
     srcs = [
+        "azure_common_test.go",
         "azure_dd_test.go",
-        "vhd_util_test.go",
     ],
     library = ":go_default_library",
     tags = ["automanaged"],
     deps = [
         "//pkg/util/exec:go_default_library",
-        "//pkg/util/mount:go_default_library",
         "//pkg/volume:go_default_library",
         "//pkg/volume/testing:go_default_library",
-        "//vendor/github.com/Azure/azure-sdk-for-go/arm/compute:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
         "//vendor/k8s.io/client-go/util/testing:go_default_library",
     ],
 )
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-)

pkg/volume/azure_dd/vhd_util_test.go → pkg/volume/azure_dd/azure_common_test.go

 /*
-Copyright 2016 The Kubernetes Authors.
+Copyright 2017 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.

pkg/volume/azure_dd/azure_dd_test.go

@@ -17,17 +17,11 @@ limitations under the License.
 package azure_dd
 
 import (
-	"fmt"
 	"os"
-	"path"
 	"testing"
 
-	"github.com/Azure/azure-sdk-for-go/arm/compute"
-
 	"k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/types"
 	utiltesting "k8s.io/client-go/util/testing"
-	"k8s.io/kubernetes/pkg/util/mount"
 	"k8s.io/kubernetes/pkg/volume"
 	volumetest "k8s.io/kubernetes/pkg/volume/testing"
 )
@@ -57,121 +51,5 @@ func TestCanSupport(t *testing.T) {
 	}
 }
 
-const (
-	fakeDiskName = "foo"
-	fakeDiskUri  = "https://azure/vhds/bar.vhd"
-	fakeLun      = 2
-)
-
-type fakeAzureProvider struct {
-}
-
-func (fake *fakeAzureProvider) AttachDisk(diskName, diskUri, vmName string, lun int32, cachingMode compute.CachingTypes) error {
-	if diskName != fakeDiskName || diskUri != fakeDiskUri || lun != fakeLun {
-		return fmt.Errorf("wrong disk")
-	}
-	return nil
-
-}
-
-func (fake *fakeAzureProvider) DetachDiskByName(diskName, diskUri, vmName string) error {
-	if diskName != fakeDiskName || diskUri != fakeDiskUri {
-		return fmt.Errorf("wrong disk")
-	}
-	return nil
-}
-func (fake *fakeAzureProvider) GetDiskLun(diskName, diskUri, vmName string) (int32, error) {
-	return int32(fakeLun), nil
-}
-
-func (fake *fakeAzureProvider) GetNextDiskLun(vmName string) (int32, error) {
-	return fakeLun, nil
-}
-func (fake *fakeAzureProvider) InstanceID(name string) (string, error) {
-	return "localhost", nil
-}
-
-func (fake *fakeAzureProvider) CreateVolume(name, storageAccount, storageType, location string, requestGB int) (string, string, int, error) {
-	return "", "", 0, fmt.Errorf("not implemented")
-}
-
-func (fake *fakeAzureProvider) DeleteVolume(name, uri string) error {
-	return fmt.Errorf("not implemented")
-}
-
-func TestPlugin(t *testing.T) {
-	tmpDir, err := utiltesting.MkTmpdir("azure_ddTest")
-	if err != nil {
-		t.Fatalf("can't make a temp dir: %v", err)
-	}
-	defer os.RemoveAll(tmpDir)
-	plugMgr := volume.VolumePluginMgr{}
-	plugMgr.InitPlugins(ProbeVolumePlugins(), volumetest.NewFakeVolumeHost(tmpDir, nil, nil))
-
-	plug, err := plugMgr.FindPluginByName(azureDataDiskPluginName)
-	if err != nil {
-		t.Errorf("Can't find the plugin by name")
-	}
-	fs := "ext4"
-	ro := false
-	caching := v1.AzureDataDiskCachingNone
-	spec := &v1.Volume{
-		Name: "vol1",
-		VolumeSource: v1.VolumeSource{
-			AzureDisk: &v1.AzureDiskVolumeSource{
-				DiskName:    fakeDiskName,
-				DataDiskURI: fakeDiskUri,
-				FSType:      &fs,
-				CachingMode: &caching,
-				ReadOnly:    &ro,
-			},
-		},
-	}
-	mounter, err := plug.(*azureDataDiskPlugin).newMounterInternal(volume.NewSpecFromVolume(spec), types.UID("poduid"), &mount.FakeMounter{})
-	if err != nil {
-		t.Errorf("Failed to make a new Mounter: %v", err)
-	}
-	if mounter == nil {
-		t.Errorf("Got a nil Mounter")
-	}
-	volPath := path.Join(tmpDir, "pods/poduid/volumes/kubernetes.io~azure-disk/vol1")
-	path := mounter.GetPath()
-	if path != volPath {
-		t.Errorf("Got unexpected path: %s, should be %s", path, volPath)
-	}
-
-	if err := mounter.SetUp(nil); err != nil {
-		t.Errorf("Expected success, got: %v", err)
-	}
-	if _, err := os.Stat(path); err != nil {
-		if os.IsNotExist(err) {
-			t.Errorf("SetUp() failed, volume path not created: %s", path)
-		} else {
-			t.Errorf("SetUp() failed: %v", err)
-		}
-	}
-	if _, err := os.Stat(path); err != nil {
-		if os.IsNotExist(err) {
-			t.Errorf("SetUp() failed, volume path not created: %s", path)
-		} else {
-			t.Errorf("SetUp() failed: %v", err)
-		}
-	}
-
-	unmounter, err := plug.(*azureDataDiskPlugin).newUnmounterInternal("vol1", types.UID("poduid"), &mount.FakeMounter{})
-	if err != nil {
-		t.Errorf("Failed to make a new Unmounter: %v", err)
-	}
-	if unmounter == nil {
-		t.Errorf("Got a nil Unmounter")
-	}
-
-	if err := unmounter.TearDown(); err != nil {
-		t.Errorf("Expected success, got: %v", err)
-	}
-	if _, err := os.Stat(path); err == nil {
-		t.Errorf("TearDown() failed, volume path still exists: %s", path)
-	} else if !os.IsNotExist(err) {
-		t.Errorf("SetUp() failed: %v", err)
-	}
-}
+// fakeAzureProvider type was removed because all functions were not used
+// Testing mounting will require path calculation which depends on the cloud provider, which is faked in the above test.

pkg/volume/azure_dd/azure_mounter.go

+/*
+Copyright 2017 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 azure_dd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/golang/glog"
+	"k8s.io/api/core/v1"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util"
+)
+
+type azureDiskMounter struct {
+	*dataDisk
+	spec    *volume.Spec
+	plugin  *azureDataDiskPlugin
+	options volume.VolumeOptions
+}
+
+type azureDiskUnmounter struct {
+	*dataDisk
+	plugin *azureDataDiskPlugin
+}
+
+var _ volume.Unmounter = &azureDiskUnmounter{}
+var _ volume.Mounter = &azureDiskMounter{}
+
+func (m *azureDiskMounter) GetAttributes() volume.Attributes {
+	volumeSource, _ := getVolumeSource(m.spec)
+	return volume.Attributes{
+		ReadOnly:        *volumeSource.ReadOnly,
+		Managed:         !*volumeSource.ReadOnly,
+		SupportsSELinux: true,
+	}
+}
+
+func (m *azureDiskMounter) CanMount() error {
+	return nil
+}
+
+func (m *azureDiskMounter) SetUp(fsGroup *int64) error {
+	return m.SetUpAt(m.GetPath(), fsGroup)
+}
+
+func (m *azureDiskMounter) GetPath() string {
+	return getPath(m.dataDisk.podUID, m.dataDisk.volumeName, m.plugin.host)
+}
+
+func (m *azureDiskMounter) SetUpAt(dir string, fsGroup *int64) error {
+	mounter := m.plugin.host.GetMounter()
+	volumeSource, err := getVolumeSource(m.spec)
+
+	if err != nil {
+		glog.Infof("azureDisk - mounter failed to get volume source for spec %s", m.spec.Name())
+		return err
+	}
+
+	diskName := volumeSource.DiskName
+	mountPoint, err := mounter.IsLikelyNotMountPoint(dir)
+
+	if err != nil && !os.IsNotExist(err) {
+		glog.Infof("azureDisk - cannot validate mount point for disk %s on  %s %v", diskName, dir, err)
+		return err
+	}
+	if !mountPoint {
+		return fmt.Errorf("azureDisk - Not a mounting point for disk %s on %s", diskName, dir)
+	}
+
+	if err := os.MkdirAll(dir, 0750); err != nil {
+		glog.Infof("azureDisk - mkdir failed on disk %s on dir: %s (%v)", diskName, dir, err)
+		return err
+	}
+
+	options := []string{"bind"}
+
+	if *volumeSource.ReadOnly {
+		options = append(options, "ro")
+	}
+
+	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)
+
+	if err != nil {
+		return err
+	}
+
+	mountErr := mounter.Mount(globalPDPath, dir, *volumeSource.FSType, options)
+	// Everything in the following control flow is meant as an
+	// attempt cleanup a failed setupAt (bind mount)
+	if mountErr != nil {
+		glog.Infof("azureDisk - SetupAt:Mount disk:%s at dir:%s failed during mounting with error:%v, will attempt to clean up", diskName, dir, mountErr)
+		mountPoint, err := mounter.IsLikelyNotMountPoint(dir)
+		if err != nil {
+			return fmt.Errorf("azureDisk - SetupAt:Mount:Failure:cleanup IsLikelyNotMountPoint check failed for disk:%s on dir:%s with error %v original-mountErr:%v", diskName, dir, err, mountErr)
+		}
+
+		if !mountPoint {
+			if err = mounter.Unmount(dir); err != nil {
+				return fmt.Errorf("azureDisk - SetupAt:Mount:Failure:cleanup failed to unmount disk:%s on dir:%s with error:%v original-mountErr:%v", diskName, dir, err, mountErr)
+			}
+			mountPoint, err := mounter.IsLikelyNotMountPoint(dir)
+			if err != nil {
+				return fmt.Errorf("azureDisk - SetupAt:Mount:Failure:cleanup IsLikelyNotMountPoint for disk:%s on dir:%s check failed with error:%v original-mountErr:%v", diskName, dir, err, mountErr)
+			}
+			if !mountPoint {
+				// not cool. leave for next sync loop.
+				return fmt.Errorf("azureDisk - SetupAt:Mount:Failure:cleanup disk %s is still mounted on %s during cleanup original-mountErr:%v, despite call to unmount(). Will try again next sync loop.", diskName, dir, mountErr)
+			}
+		}
+
+		if err = os.Remove(dir); err != nil {
+			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)
+		return mountErr
+	}
+
+	if !*volumeSource.ReadOnly {
+		volume.SetVolumeOwnership(m, fsGroup)
+	}
+
+	glog.V(2).Infof("azureDisk - successfully mounted disk %s on %s", diskName, dir)
+	return nil
+}
+
+func (u *azureDiskUnmounter) TearDown() error {
+	return u.TearDownAt(u.GetPath())
+}
+
+func (u *azureDiskUnmounter) TearDownAt(dir string) error {
+	if pathExists, pathErr := util.PathExists(dir); pathErr != nil {
+		return fmt.Errorf("Error checking if path exists: %v", pathErr)
+	} else if !pathExists {
+		glog.Warningf("Warning: Unmount skipped because path does not exist: %v", dir)
+		return nil
+	}
+
+	glog.V(4).Infof("azureDisk - TearDownAt: %s", dir)
+	mounter := u.plugin.host.GetMounter()
+	mountPoint, err := mounter.IsLikelyNotMountPoint(dir)
+	if err != nil {
+		return fmt.Errorf("azureDisk - TearDownAt: %s failed to do IsLikelyNotMountPoint %s", dir, err)
+	}
+	if mountPoint {
+		if err := os.Remove(dir); err != nil {
+			return fmt.Errorf("azureDisk - TearDownAt: %s failed to do os.Remove %s", dir, err)
+		}
+	}
+	if err := mounter.Unmount(dir); err != nil {
+		return fmt.Errorf("azureDisk - TearDownAt: %s failed to do mounter.Unmount %s", dir, err)
+	}
+	mountPoint, err = mounter.IsLikelyNotMountPoint(dir)
+	if err != nil {
+		return fmt.Errorf("azureDisk - TearTownAt:IsLikelyNotMountPoint check failed: %v", err)
+	}
+
+	if mountPoint {
+		return os.Remove(dir)
+	}
+
+	return fmt.Errorf("azureDisk - failed to un-bind-mount volume dir")
+}
+
+func (u *azureDiskUnmounter) GetPath() string {
+	return getPath(u.dataDisk.podUID, u.dataDisk.volumeName, u.plugin.host)
+}

pkg/volume/azure_dd/azure_provision.go

 /*
-Copyright 2016 The Kubernetes Authors.
+Copyright 2017 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.
@@ -20,147 +20,182 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/golang/glog"
 	"k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	utilstrings "k8s.io/kubernetes/pkg/util/strings"
 	"k8s.io/kubernetes/pkg/volume"
-	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
 )
 
-var _ volume.DeletableVolumePlugin = &azureDataDiskPlugin{}
-var _ volume.ProvisionableVolumePlugin = &azureDataDiskPlugin{}
+type azureDiskProvisioner struct {
+	plugin  *azureDataDiskPlugin
+	options volume.VolumeOptions
+}
 
 type azureDiskDeleter struct {
-	*azureDisk
-	azureProvider azureCloudProvider
+	*dataDisk
+	spec   *volume.Spec
+	plugin *azureDataDiskPlugin
 }
 
-func (plugin *azureDataDiskPlugin) NewDeleter(spec *volume.Spec) (volume.Deleter, error) {
-	azure, err := getAzureCloudProvider(plugin.host.GetCloudProvider())
-	if err != nil {
-		glog.V(4).Infof("failed to get azure provider")
-		return nil, err
-	}
+var _ volume.Provisioner = &azureDiskProvisioner{}
+var _ volume.Deleter = &azureDiskDeleter{}
 
-	return plugin.newDeleterInternal(spec, azure)
+func (d *azureDiskDeleter) GetPath() string {
+	return getPath(d.podUID, d.dataDisk.diskName, d.plugin.host)
 }
 
-func (plugin *azureDataDiskPlugin) newDeleterInternal(spec *volume.Spec, azure azureCloudProvider) (volume.Deleter, error) {
-	if spec.PersistentVolume != nil && spec.PersistentVolume.Spec.AzureDisk == nil {
-		return nil, fmt.Errorf("invalid PV spec")
+func (d *azureDiskDeleter) Delete() error {
+	volumeSource, err := getVolumeSource(d.spec)
+	if err != nil {
+		return err
 	}
-	diskName := spec.PersistentVolume.Spec.AzureDisk.DiskName
-	diskUri := spec.PersistentVolume.Spec.AzureDisk.DataDiskURI
-	return &azureDiskDeleter{
-		azureDisk: &azureDisk{
-			volName:  spec.Name(),
-			diskName: diskName,
-			diskUri:  diskUri,
-			plugin:   plugin,
-		},
-		azureProvider: azure,
-	}, nil
-}
 
-func (plugin *azureDataDiskPlugin) NewProvisioner(options volume.VolumeOptions) (volume.Provisioner, error) {
-	azure, err := getAzureCloudProvider(plugin.host.GetCloudProvider())
+	diskController, err := getDiskController(d.plugin.host)
 	if err != nil {
-		glog.V(4).Infof("failed to get azure provider")
-		return nil, err
-	}
-	if len(options.PVC.Spec.AccessModes) == 0 {
-		options.PVC.Spec.AccessModes = plugin.GetAccessModes()
+		return err
 	}
-	return plugin.newProvisionerInternal(options, azure)
-}
 
-func (plugin *azureDataDiskPlugin) newProvisionerInternal(options volume.VolumeOptions, azure azureCloudProvider) (volume.Provisioner, error) {
-	return &azureDiskProvisioner{
-		azureDisk: &azureDisk{
-			plugin: plugin,
-		},
-		azureProvider: azure,
-		options:       options,
-	}, nil
-}
+	wasStandAlone := (*volumeSource.Kind != v1.AzureSharedBlobDisk)
+	managed := (*volumeSource.Kind == v1.AzureManagedDisk)
 
-var _ volume.Deleter = &azureDiskDeleter{}
-
-func (d *azureDiskDeleter) GetPath() string {
-	name := azureDataDiskPluginName
-	return d.plugin.host.GetPodVolumeDir(d.podUID, utilstrings.EscapeQualifiedNameForDisk(name), d.volName)
-}
+	if managed {
+		return diskController.DeleteManagedDisk(volumeSource.DataDiskURI)
+	}
 
-func (d *azureDiskDeleter) Delete() error {
-	glog.V(4).Infof("deleting volume %s", d.diskUri)
-	return d.azureProvider.DeleteVolume(d.diskName, d.diskUri)
+	return diskController.DeleteBlobDisk(volumeSource.DataDiskURI, wasStandAlone)
 }
 
-type azureDiskProvisioner struct {
-	*azureDisk
-	azureProvider azureCloudProvider
-	options       volume.VolumeOptions
-}
+func (p *azureDiskProvisioner) Provision() (*v1.PersistentVolume, error) {
+	if !volume.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()
 
-var _ volume.Provisioner = &azureDiskProvisioner{}
+	// perform static validation first
+	if p.options.PVC.Spec.Selector != nil {
+		return nil, fmt.Errorf("azureDisk - claim.Spec.Selector is not supported for dynamic provisioning on Azure disk")
+	}
 
-func (a *azureDiskProvisioner) Provision() (*v1.PersistentVolume, error) {
-	if !volume.AccessModesContainedInAll(a.plugin.GetAccessModes(), a.options.PVC.Spec.AccessModes) {
-		return nil, fmt.Errorf("invalid AccessModes %v: only AccessModes %v are supported", a.options.PVC.Spec.AccessModes, a.plugin.GetAccessModes())
+	if len(p.options.PVC.Spec.AccessModes) > 1 {
+		return nil, fmt.Errorf("AzureDisk - multiple access modes are not supported on AzureDisk plugin")
 	}
 
-	var sku, location, account string
+	if len(p.options.PVC.Spec.AccessModes) == 1 {
+		if p.options.PVC.Spec.AccessModes[0] != supportedModes[0] {
+			return nil, fmt.Errorf("AzureDisk - mode %s is not supporetd by AzureDisk plugin supported mode is %s", p.options.PVC.Spec.AccessModes[0], supportedModes)
+		}
+	}
 
+	var (
+		location, account          string
+		storageAccountType, fsType string
+		cachingMode                v1.AzureDataDiskCachingMode
+		strKind                    string
+		err                        error
+	)
 	// maxLength = 79 - (4 for ".vhd") = 75
-	name := volume.GenerateVolumeName(a.options.ClusterName, a.options.PVName, 75)
-	capacity := a.options.PVC.Spec.Resources.Requests[v1.ResourceName(v1.ResourceStorage)]
+	name := volume.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))
 
-	// Apply ProvisionerParameters (case-insensitive). We leave validation of
-	// the values to the cloud provider.
-	for k, v := range a.options.Parameters {
+	for k, v := range p.options.Parameters {
 		switch strings.ToLower(k) {
 		case "skuname":
-			sku = v
+			storageAccountType = v
 		case "location":
 			location = v
 		case "storageaccount":
 			account = v
+		case "storageaccounttype":
+			storageAccountType = v
+		case "kind":
+			strKind = v
+		case "cachingmode":
+			cachingMode = v1.AzureDataDiskCachingMode(v)
+		case "fstype":
+			fsType = strings.ToLower(v)
 		default:
-			return nil, fmt.Errorf("invalid option %q for volume plugin %s", k, a.plugin.GetPluginName())
+			return nil, fmt.Errorf("AzureDisk - invalid option %s in storage class", k)
 		}
 	}
-	// TODO: implement c.options.ProvisionerSelector parsing
-	if a.options.PVC.Spec.Selector != nil {
-		return nil, fmt.Errorf("claim.Spec.Selector is not supported for dynamic provisioning on Azure disk")
+
+	// normalize values
+	fsType = normalizeFsType(fsType)
+	skuName, err := normalizeStorageAccountType(storageAccountType)
+	if err != nil {
+		return nil, err
+	}
+
+	kind, err := normalizeKind(strFirstLetterToUpper(strKind))
+	if err != nil {
+		return nil, err
 	}
 
-	diskName, diskUri, sizeGB, err := a.azureProvider.CreateVolume(name, account, sku, location, requestGB)
+	if cachingMode, err = normalizeCachingMode(cachingMode); err != nil {
+		return nil, err
+	}
+
+	diskController, err := getDiskController(p.plugin.host)
 	if err != nil {
 		return nil, err
 	}
 
+	// create disk
+	diskURI := ""
+	if kind == v1.AzureManagedDisk {
+		diskURI, err = diskController.CreateManagedDisk(name, skuName, requestGB, *(p.options.CloudTags))
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		forceStandAlone := (kind == v1.AzureDedicatedBlobDisk)
+		if kind == v1.AzureDedicatedBlobDisk {
+			if location != "" && account != "" {
+				// use dedicated kind (by default) for compatibility
+				_, diskURI, _, err = diskController.CreateVolume(name, account, skuName, location, requestGB)
+				if err != nil {
+					return nil, err
+				}
+			} else {
+				if location != "" || account != "" {
+					return nil, fmt.Errorf("AzureDisk - location(%s) and account(%s) must be both empty or specified for dedicated kind, only one value specified is not allowed",
+						location, account)
+				}
+				diskURI, err = diskController.CreateBlobDisk(name, skuName, requestGB, forceStandAlone)
+				if err != nil {
+					return nil, err
+				}
+			}
+		} else {
+			diskURI, err = diskController.CreateBlobDisk(name, skuName, requestGB, forceStandAlone)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
 	pv := &v1.PersistentVolume{
 		ObjectMeta: metav1.ObjectMeta{
-			Name:   a.options.PVName,
+			Name:   p.options.PVName,
 			Labels: map[string]string{},
 			Annotations: map[string]string{
-				volumehelper.VolumeDynamicallyCreatedByKey: "azure-disk-dynamic-provisioner",
+				"volumehelper.VolumeDynamicallyCreatedByKey": "azure-disk-dynamic-provisioner",
 			},
 		},
 		Spec: v1.PersistentVolumeSpec{
-			PersistentVolumeReclaimPolicy: a.options.PersistentVolumeReclaimPolicy,
-			AccessModes:                   a.options.PVC.Spec.AccessModes,
+			PersistentVolumeReclaimPolicy: p.options.PersistentVolumeReclaimPolicy,
+			AccessModes:                   supportedModes,
 			Capacity: v1.ResourceList{
-				v1.ResourceName(v1.ResourceStorage): resource.MustParse(fmt.Sprintf("%dGi", sizeGB)),
+				v1.ResourceName(v1.ResourceStorage): resource.MustParse(fmt.Sprintf("%dGi", requestGB)),
 			},
 			PersistentVolumeSource: v1.PersistentVolumeSource{
 				AzureDisk: &v1.AzureDiskVolumeSource{
-					DiskName:    diskName,
-					DataDiskURI: diskUri,
+					CachingMode: &cachingMode,
+					DiskName:    name,
+					DataDiskURI: diskURI,
+					Kind:        &kind,
+					FSType:      &fsType,
 				},
 			},
 		},

pkg/volume/azure_dd/vhd_util.go

-/*
-Copyright 2016 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 azure_dd
-
-import (
-	"io/ioutil"
-	"os"
-	"path"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/golang/glog"
-	"k8s.io/kubernetes/pkg/util/exec"
-)
-
-type ioHandler interface {
-	ReadDir(dirname string) ([]os.FileInfo, error)
-	WriteFile(filename string, data []byte, perm os.FileMode) error
-	Readlink(name string) (string, error)
-}
-
-type osIOHandler struct{}
-
-func (handler *osIOHandler) ReadDir(dirname string) ([]os.FileInfo, error) {
-	return ioutil.ReadDir(dirname)
-}
-func (handler *osIOHandler) WriteFile(filename string, data []byte, perm os.FileMode) error {
-	return ioutil.WriteFile(filename, data, perm)
-}
-func (handler *osIOHandler) Readlink(name string) (string, error) {
-	return os.Readlink(name)
-}
-
-// exclude those used by azure as resource and OS root in /dev/disk/azure
-func listAzureDiskPath(io ioHandler) []string {
-	azureDiskPath := "/dev/disk/azure/"
-	var azureDiskList []string
-	if dirs, err := io.ReadDir(azureDiskPath); err == nil {
-		for _, f := range dirs {
-			name := f.Name()
-			diskPath := azureDiskPath + name
-			if link, linkErr := io.Readlink(diskPath); linkErr == nil {
-				sd := link[(strings.LastIndex(link, "/") + 1):]
-				azureDiskList = append(azureDiskList, sd)
-			}
-		}
-	}
-	glog.V(12).Infof("Azure sys disks paths: %v", azureDiskList)
-	return azureDiskList
-}
-
-// given a LUN find the VHD device path like /dev/sdd
-// exclude those disks used by Azure resources and OS root
-func findDiskByLun(lun int, io ioHandler, exe exec.Interface) (string, error) {
-	azureDisks := listAzureDiskPath(io)
-	return findDiskByLunWithConstraint(lun, io, exe, azureDisks)
-}
-
-// look for device /dev/sdX and validate it is a VHD
-// return empty string if no disk is found
-func findDiskByLunWithConstraint(lun int, io ioHandler, exe exec.Interface, azureDisks []string) (string, error) {
-	var err error
-	sys_path := "/sys/bus/scsi/devices"
-	if dirs, err := io.ReadDir(sys_path); err == nil {
-		for _, f := range dirs {
-			name := f.Name()
-			// look for path like /sys/bus/scsi/devices/3:0:0:1
-			arr := strings.Split(name, ":")
-			if len(arr) < 4 {
-				continue
-			}
-			// extract LUN from the path.
-			// LUN is the last index of the array, i.e. 1 in /sys/bus/scsi/devices/3:0:0:1
-			l, err := strconv.Atoi(arr[3])
-			if err != nil {
-				// unknown path format, continue to read the next one
-				glog.Errorf("failed to parse lun from %v (%v), err %v", arr[3], name, err)
-				continue
-			}
-			if lun == l {
-				// find the matching LUN
-				// read vendor and model to ensure it is a VHD disk
-				vendor := path.Join(sys_path, name, "vendor")
-				model := path.Join(sys_path, name, "model")
-				out, err := exe.Command("cat", vendor, model).CombinedOutput()
-				if err != nil {
-					glog.Errorf("failed to cat device vendor and model, err: %v", err)
-					continue
-				}
-				matched, err := regexp.MatchString("^MSFT[ ]{0,}\nVIRTUAL DISK[ ]{0,}\n$", strings.ToUpper(string(out)))
-				if err != nil || !matched {
-					glog.V(4).Infof("doesn't match VHD, output %v, error %v", string(out), err)
-					continue
-				}
-				// find a disk, validate name
-				dir := path.Join(sys_path, name, "block")
-				if dev, err := io.ReadDir(dir); err == nil {
-					found := false
-					for _, diskName := range azureDisks {
-						glog.V(12).Infof("validating disk %q with sys disk %q", dev[0].Name(), diskName)
-						if string(dev[0].Name()) == diskName {
-							found = true
-							break
-						}
-					}
-					if !found {
-						return "/dev/" + dev[0].Name(), nil
-					}
-				}
-			}
-		}
-	}
-	return "", err
-}
-
-// rescan scsi bus
-func scsiHostRescan(io ioHandler) {
-	scsi_path := "/sys/class/scsi_host/"
-	if dirs, err := io.ReadDir(scsi_path); err == nil {
-		for _, f := range dirs {
-			name := scsi_path + f.Name() + "/scan"
-			data := []byte("- - -")
-			if err = io.WriteFile(name, data, 0666); err != nil {
-				glog.Errorf("failed to rescan scsi host %s", name)
-			}
-		}
-	} else {
-		glog.Errorf("failed to read %s, err %v", scsi_path, err)
-	}
-}

test/e2e/framework/pv_util.go

@@ -716,16 +716,21 @@ func createPD(zone string) (string, error) {
 	} else if TestContext.Provider == "azure" {
 		pdName := fmt.Sprintf("%s-%s", TestContext.Prefix, string(uuid.NewUUID()))
 		azureCloud, err := GetAzureCloud()
+
 		if err != nil {
 			return "", err
 		}
 
-		_, diskUri, _, err := azureCloud.CreateVolume(pdName, "" /* account */, "" /* sku */, "" /* location */, 1 /* sizeGb */)
+		if azureCloud.BlobDiskController == nil {
+			return "", fmt.Errorf("BlobDiskController is nil, it's not expected.")
+		}
+
+		diskUri, err := azureCloud.BlobDiskController.CreateBlobDisk(pdName, "standard_lrs", 1, false)
 		if err != nil {
 			return "", err
 		}
-		return diskUri, nil
 
+		return diskUri, nil
 	} else {
 		return "", fmt.Errorf("provider does not support volume creation")
 	}
@@ -770,8 +775,11 @@ func deletePD(pdName string) error {
 		if err != nil {
 			return err
 		}
+		if azureCloud.BlobDiskController == nil {
+			return fmt.Errorf("BlobDiskController is nil, it's not expected.")
+		}
 		diskName := pdName[(strings.LastIndex(pdName, "/") + 1):]
-		err = azureCloud.DeleteVolume(diskName, pdName)
+		err = azureCloud.BlobDiskController.DeleteBlobDisk(diskName, false)
 		if err != nil {
 			Logf("failed to delete Azure volume %q: %v", pdName, err)
 			return err

vendor/BUILD

@@ -19,6 +19,7 @@ filegroup(
         "//vendor/cloud.google.com/go/internal:all-srcs",
         "//vendor/github.com/Azure/azure-sdk-for-go/arm/compute:all-srcs",
         "//vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry:all-srcs",
+        "//vendor/github.com/Azure/azure-sdk-for-go/arm/disk:all-srcs",
         "//vendor/github.com/Azure/azure-sdk-for-go/arm/network:all-srcs",
         "//vendor/github.com/Azure/azure-sdk-for-go/arm/storage:all-srcs",
         "//vendor/github.com/Azure/azure-sdk-for-go/storage:all-srcs",

vendor/github.com/Azure/azure-sdk-for-go/arm/disk/BUILD

+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "client.go",
+        "disks.go",
+        "models.go",
+        "snapshots.go",
+        "version.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/github.com/Azure/go-autorest/autorest:go_default_library",
+        "//vendor/github.com/Azure/go-autorest/autorest/azure:go_default_library",
+        "//vendor/github.com/Azure/go-autorest/autorest/date:go_default_library",
+        "//vendor/github.com/Azure/go-autorest/autorest/to:go_default_library",
+        "//vendor/github.com/Azure/go-autorest/autorest/validation:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/github.com/Azure/azure-sdk-for-go/arm/disk/client.go

+// Package disk implements the Azure ARM Disk service API version
+// 2016-04-30-preview.
+//
+// The Disk Resource Provider Client.
+package disk
+
+// Copyright (c) Microsoft and contributors.  All rights reserved.
+//
+// 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.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+	"github.com/Azure/go-autorest/autorest"
+)
+
+const (
+	// DefaultBaseURI is the default URI used for the service Disk
+	DefaultBaseURI = "https://management.azure.com"
+)
+
+// ManagementClient is the base client for Disk.
+type ManagementClient struct {
+	autorest.Client
+	BaseURI        string
+	SubscriptionID string
+}
+
+// New creates an instance of the ManagementClient client.
+func New(subscriptionID string) ManagementClient {
+	return NewWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewWithBaseURI creates an instance of the ManagementClient client.
+func NewWithBaseURI(baseURI string, subscriptionID string) ManagementClient {
+	return ManagementClient{
+		Client:         autorest.NewClientWithUserAgent(UserAgent()),
+		BaseURI:        baseURI,
+		SubscriptionID: subscriptionID,
+	}
+}

vendor/github.com/Azure/azure-sdk-for-go/arm/disk/version.go

+package disk
+
+// Copyright (c) Microsoft and contributors.  All rights reserved.
+//
+// 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.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+// UserAgent returns the UserAgent string to use when sending http.Requests.
+func UserAgent() string {
+	return "Azure-SDK-For-Go/v10.0.2-beta arm-disk/2016-04-30-preview"
+}
+
+// Version returns the semantic version (see http://semver.org) of the client.
+func Version() string {
+	return "v10.0.2-beta"
+}