Merge pull request #49164 from vmware/vSphereCloudProviderCodeRefactoring

pkg/cloudprovider/providers/vsphere/BUILD

@@ -12,32 +12,24 @@ go_library(
     name = "go_default_library",
     srcs = [
         "vsphere.go",
-        "vsphere_metrics.go",
         "vsphere_util.go",
     ],
     tags = ["automanaged"],
     deps = [
         "//pkg/api/v1/helper:go_default_library",
         "//pkg/cloudprovider:go_default_library",
+        "//pkg/cloudprovider/providers/vsphere/vclib:go_default_library",
+        "//pkg/cloudprovider/providers/vsphere/vclib/diskmanagers:go_default_library",
         "//pkg/controller:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
-        "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
         "//vendor/github.com/vmware/govmomi:go_default_library",
-        "//vendor/github.com/vmware/govmomi/find:go_default_library",
         "//vendor/github.com/vmware/govmomi/object:go_default_library",
-        "//vendor/github.com/vmware/govmomi/pbm:go_default_library",
-        "//vendor/github.com/vmware/govmomi/pbm/types:go_default_library",
-        "//vendor/github.com/vmware/govmomi/property:go_default_library",
-        "//vendor/github.com/vmware/govmomi/session:go_default_library",
         "//vendor/github.com/vmware/govmomi/vim25:go_default_library",
         "//vendor/github.com/vmware/govmomi/vim25/mo:go_default_library",
-        "//vendor/github.com/vmware/govmomi/vim25/soap:go_default_library",
-        "//vendor/github.com/vmware/govmomi/vim25/types:go_default_library",
         "//vendor/golang.org/x/net/context:go_default_library",
         "//vendor/gopkg.in/gcfg.v1:go_default_library",
         "//vendor/k8s.io/api/core/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
-        "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
     ],
 )
 
@@ -48,6 +40,7 @@ go_test(
     tags = ["automanaged"],
     deps = [
         "//pkg/cloudprovider:go_default_library",
+        "//pkg/cloudprovider/providers/vsphere/vclib:go_default_library",
         "//vendor/golang.org/x/net/context:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/rand:go_default_library",
@@ -63,6 +56,9 @@ filegroup(
 
 filegroup(
     name = "all-srcs",
-    srcs = [":package-srcs"],
+    srcs = [
+        ":package-srcs",
+        "//pkg/cloudprovider/providers/vsphere/vclib:all-srcs",
+    ],
     tags = ["automanaged"],
 )

pkg/cloudprovider/providers/vsphere/vclib/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 = [
+        "connection.go",
+        "constants.go",
+        "custom_errors.go",
+        "datacenter.go",
+        "datastore.go",
+        "folder.go",
+        "pbm.go",
+        "utils.go",
+        "virtualmachine.go",
+        "vmoptions.go",
+        "volumeoptions.go",
+        "vsphere_metrics.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/github.com/prometheus/client_golang/prometheus:go_default_library",
+        "//vendor/github.com/vmware/govmomi:go_default_library",
+        "//vendor/github.com/vmware/govmomi/find:go_default_library",
+        "//vendor/github.com/vmware/govmomi/object:go_default_library",
+        "//vendor/github.com/vmware/govmomi/pbm:go_default_library",
+        "//vendor/github.com/vmware/govmomi/pbm/types:go_default_library",
+        "//vendor/github.com/vmware/govmomi/property:go_default_library",
+        "//vendor/github.com/vmware/govmomi/session:go_default_library",
+        "//vendor/github.com/vmware/govmomi/vim25:go_default_library",
+        "//vendor/github.com/vmware/govmomi/vim25/mo:go_default_library",
+        "//vendor/github.com/vmware/govmomi/vim25/soap:go_default_library",
+        "//vendor/github.com/vmware/govmomi/vim25/types:go_default_library",
+        "//vendor/golang.org/x/net/context:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/cloudprovider/providers/vsphere/vclib/diskmanagers:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

pkg/cloudprovider/providers/vsphere/vclib/connection.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 vclib
+
+import (
+	"fmt"
+	neturl "net/url"
+	"sync"
+
+	"github.com/golang/glog"
+	"github.com/vmware/govmomi"
+	"github.com/vmware/govmomi/session"
+	"github.com/vmware/govmomi/vim25"
+	"golang.org/x/net/context"
+)
+
+// VSphereConnection contains information for connecting to vCenter
+type VSphereConnection struct {
+	GoVmomiClient     *govmomi.Client
+	Username          string
+	Password          string
+	Hostname          string
+	Port              string
+	Insecure          bool
+	RoundTripperCount uint
+}
+
+var (
+	clientLock sync.Mutex
+)
+
+// Connect makes connection to vCenter and sets VSphereConnection.GoVmomiClient.
+// If connection.GoVmomiClient is already set, it obtains the existing user session.
+// if user session is not valid, connection.GoVmomiClient will be set to the new client.
+func (connection *VSphereConnection) Connect(ctx context.Context) error {
+	var err error
+	clientLock.Lock()
+	defer clientLock.Unlock()
+
+	if connection.GoVmomiClient == nil {
+		connection.GoVmomiClient, err = connection.NewClient(ctx)
+		if err != nil {
+			glog.Errorf("Failed to create govmomi client. err: %+v", err)
+			return err
+		}
+		return nil
+	}
+	m := session.NewManager(connection.GoVmomiClient.Client)
+	userSession, err := m.UserSession(ctx)
+	if err != nil {
+		glog.Errorf("Error while obtaining user session. err: %+v", err)
+		return err
+	}
+	if userSession != nil {
+		return nil
+	}
+	glog.Warningf("Creating new client session since the existing session is not valid or not authenticated")
+	connection.GoVmomiClient.Logout(ctx)
+	connection.GoVmomiClient, err = connection.NewClient(ctx)
+	if err != nil {
+		glog.Errorf("Failed to create govmomi client. err: %+v", err)
+		return err
+	}
+	return nil
+}
+
+// NewClient creates a new govmomi client for the VSphereConnection obj
+func (connection *VSphereConnection) NewClient(ctx context.Context) (*govmomi.Client, error) {
+	url, err := neturl.Parse(fmt.Sprintf("https://%s:%s/sdk", connection.Hostname, connection.Port))
+	if err != nil {
+		glog.Errorf("Failed to parse URL: %s. err: %+v", url, err)
+		return nil, err
+	}
+	url.User = neturl.UserPassword(connection.Username, connection.Password)
+	client, err := govmomi.NewClient(ctx, url, connection.Insecure)
+	if err != nil {
+		glog.Errorf("Failed to create new client. err: %+v", err)
+		return nil, err
+	}
+	if connection.RoundTripperCount == 0 {
+		connection.RoundTripperCount = RoundTripperDefaultCount
+	}
+	client.RoundTripper = vim25.Retry(client.RoundTripper, vim25.TemporaryNetworkError(int(connection.RoundTripperCount)))
+	return client, nil
+}

pkg/cloudprovider/providers/vsphere/vclib/constants.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 vclib
+
+// Volume Constnts
+const (
+	ThinDiskType             = "thin"
+	PreallocatedDiskType     = "preallocated"
+	EagerZeroedThickDiskType = "eagerZeroedThick"
+	ZeroedThickDiskType      = "zeroedThick"
+)
+
+// Controller Constants
+const (
+	SCSIControllerLimit       = 4
+	SCSIControllerDeviceLimit = 15
+	SCSIDeviceSlots           = 16
+	SCSIReservedSlot          = 7
+
+	SCSIControllerType        = "scsi"
+	LSILogicControllerType    = "lsiLogic"
+	BusLogicControllerType    = "busLogic"
+	LSILogicSASControllerType = "lsiLogic-sas"
+	PVSCSIControllerType      = "pvscsi"
+)
+
+// Other Constants
+const (
+	LogLevel                 = 4
+	DatastoreProperty        = "datastore"
+	ResourcePoolProperty     = "resourcePool"
+	DatastoreInfoProperty    = "info"
+	VirtualMachineType       = "VirtualMachine"
+	RoundTripperDefaultCount = 3
+	VSANDatastoreType        = "vsan"
+	DummyVMPrefixName        = "vsphere-k8s"
+	ActivePowerState         = "poweredOn"
+)

pkg/cloudprovider/providers/vsphere/vclib/custom_errors.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 vclib
+
+import "errors"
+
+// Error Messages
+const (
+	FileAlreadyExistErrMsg     = "File requested already exist"
+	NoDiskUUIDFoundErrMsg      = "No disk UUID found"
+	NoDevicesFoundErrMsg       = "No devices found"
+	DiskNotFoundErrMsg         = "No vSphere disk ID found"
+	InvalidVolumeOptionsErrMsg = "VolumeOptions verification failed"
+)
+
+// Error constants
+var (
+	ErrFileAlreadyExist     = errors.New(FileAlreadyExistErrMsg)
+	ErrNoDiskUUIDFound      = errors.New(NoDiskUUIDFoundErrMsg)
+	ErrNoDevicesFound       = errors.New(NoDevicesFoundErrMsg)
+	ErrNoDiskIDFound        = errors.New(DiskNotFoundErrMsg)
+	ErrInvalidVolumeOptions = errors.New(InvalidVolumeOptionsErrMsg)
+)

pkg/cloudprovider/providers/vsphere/vclib/datacenter.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 vclib
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/golang/glog"
+	"github.com/vmware/govmomi/find"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+	"golang.org/x/net/context"
+)
+
+// Datacenter extends the govmomi Datacenter object
+type Datacenter struct {
+	*object.Datacenter
+}
+
+// GetDatacenter returns the DataCenter Object for the given datacenterPath
+// If datacenter is located in a folder, include full path to datacenter else just provide the datacenter name
+func GetDatacenter(ctx context.Context, connection *VSphereConnection, datacenterPath string) (*Datacenter, error) {
+	finder := find.NewFinder(connection.GoVmomiClient.Client, true)
+	datacenter, err := finder.Datacenter(ctx, datacenterPath)
+	if err != nil {
+		glog.Errorf("Failed to find the datacenter: %s. err: %+v", datacenterPath, err)
+		return nil, err
+	}
+	dc := Datacenter{datacenter}
+	return &dc, nil
+}
+
+// GetVMByUUID gets the VM object from the given vmUUID
+func (dc *Datacenter) GetVMByUUID(ctx context.Context, vmUUID string) (*VirtualMachine, error) {
+	s := object.NewSearchIndex(dc.Client())
+	vmUUID = strings.ToLower(strings.TrimSpace(vmUUID))
+	svm, err := s.FindByUuid(ctx, dc.Datacenter, vmUUID, true, nil)
+	if err != nil {
+		glog.Errorf("Failed to find VM by UUID. VM UUID: %s, err: %+v", vmUUID, err)
+		return nil, err
+	}
+	if svm == nil {
+		glog.Errorf("Unable to find VM by UUID. VM UUID: %s", vmUUID)
+		return nil, fmt.Errorf("Failed to find VM by UUID: %s", vmUUID)
+	}
+	virtualMachine := VirtualMachine{object.NewVirtualMachine(dc.Client(), svm.Reference()), dc}
+	return &virtualMachine, nil
+}
+
+// GetVMByPath gets the VM object from the given vmPath
+// vmPath should be the full path to VM and not just the name
+func (dc *Datacenter) GetVMByPath(ctx context.Context, vmPath string) (*VirtualMachine, error) {
+	finder := getFinder(dc)
+	vm, err := finder.VirtualMachine(ctx, vmPath)
+	if err != nil {
+		glog.Errorf("Failed to find VM by Path. VM Path: %s, err: %+v", vmPath, err)
+		return nil, err
+	}
+	virtualMachine := VirtualMachine{vm, dc}
+	return &virtualMachine, nil
+}
+
+// GetDatastoreByPath gets the Datastore object from the given vmDiskPath
+func (dc *Datacenter) GetDatastoreByPath(ctx context.Context, vmDiskPath string) (*Datastore, error) {
+	datastorePathObj := new(object.DatastorePath)
+	isSuccess := datastorePathObj.FromString(vmDiskPath)
+	if !isSuccess {
+		glog.Errorf("Failed to parse vmDiskPath: %s", vmDiskPath)
+		return nil, errors.New("Failed to parse vmDiskPath")
+	}
+	finder := getFinder(dc)
+	ds, err := finder.Datastore(ctx, datastorePathObj.Datastore)
+	if err != nil {
+		glog.Errorf("Failed while searching for datastore: %s. err: %+v", datastorePathObj.Datastore, err)
+		return nil, err
+	}
+	datastore := Datastore{ds, dc}
+	return &datastore, nil
+}
+
+// GetDatastoreByName gets the Datastore object for the given datastore name
+func (dc *Datacenter) GetDatastoreByName(ctx context.Context, name string) (*Datastore, error) {
+	finder := getFinder(dc)
+	ds, err := finder.Datastore(ctx, name)
+	if err != nil {
+		glog.Errorf("Failed while searching for datastore: %s. err: %+v", name, err)
+		return nil, err
+	}
+	datastore := Datastore{ds, dc}
+	return &datastore, nil
+}
+
+// GetFolderByPath gets the Folder Object from the given folder path
+// folderPath should be the full path to folder
+func (dc *Datacenter) GetFolderByPath(ctx context.Context, folderPath string) (*Folder, error) {
+	finder := getFinder(dc)
+	vmFolder, err := finder.Folder(ctx, folderPath)
+	if err != nil {
+		glog.Errorf("Failed to get the folder reference for %s. err: %+v", folderPath, err)
+		return nil, err
+	}
+	folder := Folder{vmFolder, dc}
+	return &folder, nil
+}
+
+// GetVMMoList gets the VM Managed Objects with the given properties from the VM object
+func (dc *Datacenter) GetVMMoList(ctx context.Context, vmObjList []*VirtualMachine, properties []string) ([]mo.VirtualMachine, error) {
+	var vmMoList []mo.VirtualMachine
+	var vmRefs []types.ManagedObjectReference
+	if len(vmObjList) < 1 {
+		glog.Errorf("VirtualMachine Object list is empty")
+		return nil, fmt.Errorf("VirtualMachine Object list is empty")
+	}
+
+	for _, vmObj := range vmObjList {
+		vmRefs = append(vmRefs, vmObj.Reference())
+	}
+	pc := property.DefaultCollector(dc.Client())
+	err := pc.Retrieve(ctx, vmRefs, properties, &vmMoList)
+	if err != nil {
+		glog.Errorf("Failed to get VM managed objects from VM objects. vmObjList: %+v, properties: %+v, err: %v", vmObjList, properties, err)
+		return nil, err
+	}
+	return vmMoList, nil
+}
+
+// GetDatastoreMoList gets the Datastore Managed Objects with the given properties from the datastore objects
+func (dc *Datacenter) GetDatastoreMoList(ctx context.Context, dsObjList []*Datastore, properties []string) ([]mo.Datastore, error) {
+	var dsMoList []mo.Datastore
+	var dsRefs []types.ManagedObjectReference
+	if len(dsObjList) < 1 {
+		glog.Errorf("Datastore Object list is empty")
+		return nil, fmt.Errorf("Datastore Object list is empty")
+	}
+
+	for _, dsObj := range dsObjList {
+		dsRefs = append(dsRefs, dsObj.Reference())
+	}
+	pc := property.DefaultCollector(dc.Client())
+	err := pc.Retrieve(ctx, dsRefs, properties, &dsMoList)
+	if err != nil {
+		glog.Errorf("Failed to get Datastore managed objects from datastore objects. dsObjList: %+v, properties: %+v, err: %v", dsObjList, properties, err)
+		return nil, err
+	}
+	return dsMoList, nil
+}

pkg/cloudprovider/providers/vsphere/vclib/datastore.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 vclib
+
+import (
+	"github.com/golang/glog"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+	"golang.org/x/net/context"
+)
+
+// Datastore extends the govmomi Datastore object
+type Datastore struct {
+	*object.Datastore
+	Datacenter *Datacenter
+}
+
+// CreateDirectory creates the directory at location specified by directoryPath.
+// If the intermediate level folders do not exist, and the parameter createParents is true, all the non-existent folders are created.
+// directoryPath must be in the format "[vsanDatastore] kubevols"
+func (ds *Datastore) CreateDirectory(ctx context.Context, directoryPath string, createParents bool) error {
+	fileManager := object.NewFileManager(ds.Client())
+	err := fileManager.MakeDirectory(ctx, directoryPath, ds.Datacenter.Datacenter, createParents)
+	if err != nil {
+		if soap.IsSoapFault(err) {
+			soapFault := soap.ToSoapFault(err)
+			if _, ok := soapFault.VimFault().(types.FileAlreadyExists); ok {
+				return ErrFileAlreadyExist
+			}
+		}
+		return err
+	}
+	glog.V(LogLevel).Infof("Created dir with path as %+q", directoryPath)
+	return nil
+}
+
+// GetType returns the type of datastore
+func (ds *Datastore) GetType(ctx context.Context) (string, error) {
+	var dsMo mo.Datastore
+	pc := property.DefaultCollector(ds.Client())
+	err := pc.RetrieveOne(ctx, ds.Datastore.Reference(), []string{"summary"}, &dsMo)
+	if err != nil {
+		glog.Errorf("Failed to retrieve datastore summary property. err: %v", err)
+		return "", err
+	}
+	return dsMo.Summary.Type, nil
+}
+
+// IsCompatibleWithStoragePolicy returns true if datastore is compatible with given storage policy else return false
+// for not compatible datastore, fault message is also returned
+func (ds *Datastore) IsCompatibleWithStoragePolicy(ctx context.Context, storagePolicyID string) (bool, string, error) {
+	pbmClient, err := NewPbmClient(ctx, ds.Client())
+	if err != nil {
+		glog.Errorf("Failed to get new PbmClient Object. err: %v", err)
+		return false, "", err
+	}
+	return pbmClient.IsDatastoreCompatible(ctx, storagePolicyID, ds)
+}

pkg/cloudprovider/providers/vsphere/vclib/diskmanagers/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 = [
+        "vdm.go",
+        "virtualdisk.go",
+        "vmdm.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/cloudprovider/providers/vsphere/vclib:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/github.com/vmware/govmomi/object:go_default_library",
+        "//vendor/github.com/vmware/govmomi/vim25/types:go_default_library",
+        "//vendor/golang.org/x/net/context:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

pkg/cloudprovider/providers/vsphere/vclib/diskmanagers/vdm.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 diskmanagers
+
+import (
+	"time"
+
+	"golang.org/x/net/context"
+
+	"github.com/golang/glog"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25/types"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere/vclib"
+)
+
+// virtualDiskManager implements VirtualDiskProvider Interface for creating and deleting volume using VirtualDiskManager
+type virtualDiskManager struct {
+	diskPath      string
+	volumeOptions *vclib.VolumeOptions
+}
+
+// Create implements Disk's Create interface
+// Contains implementation of virtualDiskManager based Provisioning
+func (diskManager virtualDiskManager) Create(ctx context.Context, datastore *vclib.Datastore) (err error) {
+	if diskManager.volumeOptions.SCSIControllerType == "" {
+		diskManager.volumeOptions.SCSIControllerType = vclib.LSILogicControllerType
+	}
+	// Create virtual disk
+	diskFormat := vclib.DiskFormatValidType[diskManager.volumeOptions.DiskFormat]
+	// Create a virtual disk manager
+	vdm := object.NewVirtualDiskManager(datastore.Client())
+	// Create specification for new virtual disk
+	vmDiskSpec := &types.FileBackedVirtualDiskSpec{
+		VirtualDiskSpec: types.VirtualDiskSpec{
+			AdapterType: diskManager.volumeOptions.SCSIControllerType,
+			DiskType:    diskFormat,
+		},
+		CapacityKb: int64(diskManager.volumeOptions.CapacityKB),
+	}
+	requestTime := time.Now()
+	// Create virtual disk
+	task, err := vdm.CreateVirtualDisk(ctx, diskManager.diskPath, datastore.Datacenter.Datacenter, vmDiskSpec)
+	if err != nil {
+		vclib.RecordvSphereMetric(vclib.APICreateVolume, requestTime, err)
+		glog.Errorf("Failed to create virtual disk: %s. err: %+v", diskManager.diskPath, err)
+		return err
+	}
+	err = task.Wait(ctx)
+	vclib.RecordvSphereMetric(vclib.APICreateVolume, requestTime, err)
+	if err != nil {
+		glog.Errorf("Failed to create virtual disk: %s. err: %+v", diskManager.diskPath, err)
+		return err
+	}
+	return nil
+}
+
+// Delete implements Disk's Delete interface
+func (diskManager virtualDiskManager) Delete(ctx context.Context, datastore *vclib.Datastore) error {
+	// Create a virtual disk manager
+	virtualDiskManager := object.NewVirtualDiskManager(datastore.Client())
+	diskPath := vclib.RemoveClusterFromVDiskPath(diskManager.diskPath)
+	requestTime := time.Now()
+	// Delete virtual disk
+	task, err := virtualDiskManager.DeleteVirtualDisk(ctx, diskPath, datastore.Datacenter.Datacenter)
+	if err != nil {
+		glog.Errorf("Failed to delete virtual disk. err: %v", err)
+		vclib.RecordvSphereMetric(vclib.APIDeleteVolume, requestTime, err)
+		return err
+	}
+	err = task.Wait(ctx)
+	vclib.RecordvSphereMetric(vclib.APIDeleteVolume, requestTime, err)
+	if err != nil {
+		glog.Errorf("Failed to delete virtual disk. err: %v", err)
+		return err
+	}
+	return nil
+}

pkg/cloudprovider/providers/vsphere/vclib/diskmanagers/virtualdisk.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 diskmanagers
+
+import (
+	"fmt"
+
+	"github.com/golang/glog"
+	"golang.org/x/net/context"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere/vclib"
+)
+
+// VirtualDisk is for the Disk Management
+type VirtualDisk struct {
+	DiskPath      string
+	VolumeOptions *vclib.VolumeOptions
+	VMOptions     *vclib.VMOptions
+}
+
+// VirtualDisk Operations Const
+const (
+	VirtualDiskCreateOperation = "Create"
+	VirtualDiskDeleteOperation = "Delete"
+)
+
+// VirtualDiskProvider defines interfaces for creating disk
+type VirtualDiskProvider interface {
+	Create(ctx context.Context, datastore *vclib.Datastore) error
+	Delete(ctx context.Context, datastore *vclib.Datastore) error
+}
+
+// getDiskManager returns vmDiskManager or vdmDiskManager based on given volumeoptions
+func getDiskManager(disk *VirtualDisk, diskOperation string) VirtualDiskProvider {
+	var diskProvider VirtualDiskProvider
+	switch diskOperation {
+	case VirtualDiskDeleteOperation:
+		diskProvider = virtualDiskManager{disk.DiskPath, disk.VolumeOptions}
+	case VirtualDiskCreateOperation:
+		if disk.VolumeOptions.StoragePolicyName != "" || disk.VolumeOptions.VSANStorageProfileData != "" || disk.VolumeOptions.StoragePolicyID != "" {
+			diskProvider = vmDiskManager{disk.DiskPath, disk.VolumeOptions, disk.VMOptions}
+		} else {
+			diskProvider = virtualDiskManager{disk.DiskPath, disk.VolumeOptions}
+		}
+	}
+	return diskProvider
+}
+
+// Create gets appropriate disk manager and calls respective create method
+func (virtualDisk *VirtualDisk) Create(ctx context.Context, datastore *vclib.Datastore) error {
+	if virtualDisk.VolumeOptions.DiskFormat == "" {
+		virtualDisk.VolumeOptions.DiskFormat = vclib.ThinDiskType
+	}
+	if !virtualDisk.VolumeOptions.VerifyVolumeOptions() {
+		glog.Error("VolumeOptions verification failed. volumeOptions: ", virtualDisk.VolumeOptions)
+		return vclib.ErrInvalidVolumeOptions
+	}
+	if virtualDisk.VolumeOptions.StoragePolicyID != "" && virtualDisk.VolumeOptions.StoragePolicyName != "" {
+		return fmt.Errorf("Storage Policy ID and Storage Policy Name both set, Please set only one parameter")
+	}
+	return getDiskManager(virtualDisk, VirtualDiskCreateOperation).Create(ctx, datastore)
+}
+
+// Delete gets appropriate disk manager and calls respective delete method
+func (virtualDisk *VirtualDisk) Delete(ctx context.Context, datastore *vclib.Datastore) error {
+	return getDiskManager(virtualDisk, VirtualDiskDeleteOperation).Delete(ctx, datastore)
+}

pkg/cloudprovider/providers/vsphere/vclib/diskmanagers/vmdm.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 diskmanagers
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/golang/glog"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25/types"
+	"golang.org/x/net/context"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere/vclib"
+)
+
+// vmDiskManager implements VirtualDiskProvider interface for creating volume using Virtual Machine Reconfigure approach
+type vmDiskManager struct {
+	diskPath      string
+	volumeOptions *vclib.VolumeOptions
+	vmOptions     *vclib.VMOptions
+}
+
+// Create implements Disk's Create interface
+// Contains implementation of VM based Provisioning to provision disk with SPBM Policy or VSANStorageProfileData
+func (vmdisk vmDiskManager) Create(ctx context.Context, datastore *vclib.Datastore) (err error) {
+	if vmdisk.volumeOptions.SCSIControllerType == "" {
+		vmdisk.volumeOptions.SCSIControllerType = vclib.PVSCSIControllerType
+	}
+	pbmClient, err := vclib.NewPbmClient(ctx, datastore.Client())
+	if err != nil {
+		glog.Errorf("Error occurred while creating new pbmClient, err: %+v", err)
+		return err
+	}
+
+	if vmdisk.volumeOptions.StoragePolicyID == "" && vmdisk.volumeOptions.StoragePolicyName != "" {
+		vmdisk.volumeOptions.StoragePolicyID, err = pbmClient.ProfileIDByName(ctx, vmdisk.volumeOptions.StoragePolicyName)
+		if err != nil {
+			glog.Errorf("Error occurred while getting Profile Id from Profile Name: %s, err: %+v", vmdisk.volumeOptions.StoragePolicyName, err)
+			return err
+		}
+	}
+	if vmdisk.volumeOptions.StoragePolicyID != "" {
+		compatible, faultMessage, err := datastore.IsCompatibleWithStoragePolicy(ctx, vmdisk.volumeOptions.StoragePolicyID)
+		if err != nil {
+			glog.Errorf("Error occurred while checking datastore compatibility with storage policy id: %s, err: %+v", vmdisk.volumeOptions.StoragePolicyID, err)
+			return err
+		}
+
+		if !compatible {
+			glog.Errorf("Datastore: %s is not compatible with Policy: %s", datastore.Name(), vmdisk.volumeOptions.StoragePolicyName)
+			return fmt.Errorf("User specified datastore is not compatible with the storagePolicy: %q. Failed with faults: %+q", vmdisk.volumeOptions.StoragePolicyName, faultMessage)
+		}
+	}
+
+	storageProfileSpec := &types.VirtualMachineDefinedProfileSpec{}
+	// Is PBM storage policy ID is present, set the storage spec profile ID,
+	// else, set raw the VSAN policy string.
+	if vmdisk.volumeOptions.StoragePolicyID != "" {
+		storageProfileSpec.ProfileId = vmdisk.volumeOptions.StoragePolicyID
+	} else if vmdisk.volumeOptions.VSANStorageProfileData != "" {
+		// Check Datastore type - VSANStorageProfileData is only applicable to vSAN Datastore
+		dsType, err := datastore.GetType(ctx)
+		if err != nil {
+			return err
+		}
+		if dsType != vclib.VSANDatastoreType {
+			glog.Errorf("The specified datastore: %q is not a VSAN datastore", datastore.Name())
+			return fmt.Errorf("The specified datastore: %q is not a VSAN datastore."+
+				" The policy parameters will work only with VSAN Datastore."+
+				" So, please specify a valid VSAN datastore in Storage class definition.", datastore.Name())
+		}
+		storageProfileSpec.ProfileId = ""
+		storageProfileSpec.ProfileData = &types.VirtualMachineProfileRawData{
+			ExtensionKey: "com.vmware.vim.sps",
+			ObjectData:   vmdisk.volumeOptions.VSANStorageProfileData,
+		}
+	} else {
+		glog.Errorf("Both volumeOptions.StoragePolicyID and volumeOptions.VSANStorageProfileData are not set. One of them should be set")
+		return fmt.Errorf("Both volumeOptions.StoragePolicyID and volumeOptions.VSANStorageProfileData are not set. One of them should be set")
+	}
+	var dummyVM *vclib.VirtualMachine
+	// Check if VM already exist in the folder.
+	// If VM is already present, use it, else create a new dummy VM.
+	dummyVMFullName := vclib.DummyVMPrefixName + "-" + vmdisk.volumeOptions.Name
+	dummyVM, err = datastore.Datacenter.GetVMByPath(ctx, vmdisk.vmOptions.VMFolder.InventoryPath+"/"+dummyVMFullName)
+	if err != nil {
+		// Create a dummy VM
+		glog.V(1).Info("Creating Dummy VM: %q", dummyVMFullName)
+		dummyVM, err = vmdisk.createDummyVM(ctx, datastore.Datacenter, dummyVMFullName)
+		if err != nil {
+			glog.Errorf("Failed to create Dummy VM. err: %v", err)
+			return err
+		}
+	}
+
+	// Reconfigure the VM to attach the disk with the VSAN policy configured
+	virtualMachineConfigSpec := types.VirtualMachineConfigSpec{}
+	disk, _, err := dummyVM.CreateDiskSpec(ctx, vmdisk.diskPath, datastore, vmdisk.volumeOptions)
+	if err != nil {
+		glog.Errorf("Failed to create Disk Spec. err: %v", err)
+		return err
+	}
+	deviceConfigSpec := &types.VirtualDeviceConfigSpec{
+		Device:        disk,
+		Operation:     types.VirtualDeviceConfigSpecOperationAdd,
+		FileOperation: types.VirtualDeviceConfigSpecFileOperationCreate,
+	}
+
+	deviceConfigSpec.Profile = append(deviceConfigSpec.Profile, storageProfileSpec)
+	virtualMachineConfigSpec.DeviceChange = append(virtualMachineConfigSpec.DeviceChange, deviceConfigSpec)
+	fileAlreadyExist := false
+	task, err := dummyVM.Reconfigure(ctx, virtualMachineConfigSpec)
+	err = task.Wait(ctx)
+	if err != nil {
+		fileAlreadyExist = isAlreadyExists(vmdisk.diskPath, err)
+		if fileAlreadyExist {
+			//Skip error and continue to detach the disk as the disk was already created on the datastore.
+			glog.V(vclib.LogLevel).Info("File: %v already exists", vmdisk.diskPath)
+		} else {
+			glog.Errorf("Failed to attach the disk to VM: %q with err: %+v", dummyVMFullName, err)
+			return err
+		}
+	}
+	// Detach the disk from the dummy VM.
+	err = dummyVM.DetachDisk(ctx, vmdisk.diskPath)
+	if err != nil {
+		if vclib.DiskNotFoundErrMsg == err.Error() && fileAlreadyExist {
+			// Skip error if disk was already detached from the dummy VM but still present on the datastore.
+			glog.V(vclib.LogLevel).Info("File: %v is already detached", vmdisk.diskPath)
+		} else {
+			glog.Errorf("Failed to detach the disk: %q from VM: %q with err: %+v", vmdisk.diskPath, dummyVMFullName, err)
+			return err
+		}
+	}
+	//  Delete the dummy VM
+	err = dummyVM.DeleteVM(ctx)
+	if err != nil {
+		glog.Errorf("Failed to destroy the vm: %q with err: %+v", dummyVMFullName, err)
+	}
+	return nil
+}
+
+func (vmdisk vmDiskManager) Delete(ctx context.Context, datastore *vclib.Datastore) error {
+	return fmt.Errorf("vmDiskManager.Delete is not supported")
+}
+
+// CreateDummyVM create a Dummy VM at specified location with given name.
+func (vmdisk vmDiskManager) createDummyVM(ctx context.Context, datacenter *vclib.Datacenter, vmName string) (*vclib.VirtualMachine, error) {
+	// Create a virtual machine config spec with 1 SCSI adapter.
+	virtualMachineConfigSpec := types.VirtualMachineConfigSpec{
+		Name: vmName,
+		Files: &types.VirtualMachineFileInfo{
+			VmPathName: "[" + vmdisk.volumeOptions.Datastore + "]",
+		},
+		NumCPUs:  1,
+		MemoryMB: 4,
+		DeviceChange: []types.BaseVirtualDeviceConfigSpec{
+			&types.VirtualDeviceConfigSpec{
+				Operation: types.VirtualDeviceConfigSpecOperationAdd,
+				Device: &types.ParaVirtualSCSIController{
+					VirtualSCSIController: types.VirtualSCSIController{
+						SharedBus: types.VirtualSCSISharingNoSharing,
+						VirtualController: types.VirtualController{
+							BusNumber: 0,
+							VirtualDevice: types.VirtualDevice{
+								Key: 1000,
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	task, err := vmdisk.vmOptions.VMFolder.CreateVM(ctx, virtualMachineConfigSpec, vmdisk.vmOptions.VMResourcePool, nil)
+	if err != nil {
+		glog.Errorf("Failed to create VM. err: %+v", err)
+		return nil, err
+	}
+
+	dummyVMTaskInfo, err := task.WaitForResult(ctx, nil)
+	if err != nil {
+		glog.Errorf("Error occurred while waiting for create VM task result. err: %+v", err)
+		return nil, err
+	}
+
+	vmRef := dummyVMTaskInfo.Result.(object.Reference)
+	dummyVM := object.NewVirtualMachine(datacenter.Client(), vmRef.Reference())
+	return &vclib.VirtualMachine{VirtualMachine: dummyVM, Datacenter: datacenter}, nil
+}
+
+// CleanUpDummyVMs deletes stale dummyVM's
+func CleanUpDummyVMs(ctx context.Context, folder *vclib.Folder, dc *vclib.Datacenter) error {
+	vmList, err := folder.GetVirtualMachines(ctx)
+	if err != nil {
+		glog.V(4).Infof("Failed to get virtual machines in the kubernetes cluster: %s, err: %+v", folder.InventoryPath, err)
+		return err
+	}
+	if vmList == nil || len(vmList) == 0 {
+		glog.Errorf("No virtual machines found in the kubernetes cluster: %s", folder.InventoryPath)
+		return fmt.Errorf("No virtual machines found in the kubernetes cluster: %s", folder.InventoryPath)
+	}
+	var dummyVMList []*vclib.VirtualMachine
+	// Loop through VM's in the Kubernetes cluster to find dummy VM's
+	for _, vm := range vmList {
+		vmName, err := vm.ObjectName(ctx)
+		if err != nil {
+			glog.V(4).Infof("Unable to get name from VM with err: %+v", err)
+			continue
+		}
+		if strings.HasPrefix(vmName, vclib.DummyVMPrefixName) {
+			vmObj := vclib.VirtualMachine{VirtualMachine: object.NewVirtualMachine(dc.Client(), vm.Reference()), Datacenter: dc}
+			dummyVMList = append(dummyVMList, &vmObj)
+		}
+	}
+	for _, vm := range dummyVMList {
+		err = vm.DeleteVM(ctx)
+		if err != nil {
+			glog.V(4).Infof("Unable to delete dummy VM with err: %+v", err)
+			continue
+		}
+	}
+	return nil
+}
+
+func isAlreadyExists(path string, err error) bool {
+	errorMessage := fmt.Sprintf("Cannot complete the operation because the file or folder %s already exists", path)
+	if errorMessage == err.Error() {
+		return true
+	}
+	return false
+}

pkg/cloudprovider/providers/vsphere/vclib/folder.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 vclib
+
+import (
+	"github.com/golang/glog"
+	"github.com/vmware/govmomi/object"
+	"golang.org/x/net/context"
+)
+
+// Folder extends the govmomi Folder object
+type Folder struct {
+	*object.Folder
+	Datacenter *Datacenter
+}
+
+// GetVirtualMachines returns list of VirtualMachine inside a folder.
+func (folder *Folder) GetVirtualMachines(ctx context.Context) ([]*VirtualMachine, error) {
+	vmFolders, err := folder.Children(ctx)
+	if err != nil {
+		glog.Errorf("Failed to get children from Folder: %s. err: %+v", folder.InventoryPath, err)
+		return nil, err
+	}
+	var vmObjList []*VirtualMachine
+	for _, vmFolder := range vmFolders {
+		if vmFolder.Reference().Type == VirtualMachineType {
+			vmObj := VirtualMachine{object.NewVirtualMachine(folder.Client(), vmFolder.Reference()), folder.Datacenter}
+			vmObjList = append(vmObjList, &vmObj)
+		}
+	}
+	return vmObjList, nil
+}

pkg/cloudprovider/providers/vsphere/vclib/pbm.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 vclib
+
+import (
+	"fmt"
+
+	"github.com/golang/glog"
+	"github.com/vmware/govmomi/pbm"
+	"golang.org/x/net/context"
+
+	pbmtypes "github.com/vmware/govmomi/pbm/types"
+	"github.com/vmware/govmomi/vim25"
+)
+
+// PbmClient is extending govmomi pbm, and provides functions to get compatible list of datastore for given policy
+type PbmClient struct {
+	*pbm.Client
+}
+
+// NewPbmClient returns a new PBM Client object
+func NewPbmClient(ctx context.Context, client *vim25.Client) (*PbmClient, error) {
+	pbmClient, err := pbm.NewClient(ctx, client)
+	if err != nil {
+		glog.Errorf("Failed to create new Pbm Client. err: %+v", err)
+		return nil, err
+	}
+	return &PbmClient{pbmClient}, nil
+}
+
+// IsDatastoreCompatible check if the datastores is compatible for given storage policy id
+// if datastore is not compatible with policy, fault message with the Datastore Name is returned
+func (pbmClient *PbmClient) IsDatastoreCompatible(ctx context.Context, storagePolicyID string, datastore *Datastore) (bool, string, error) {
+	faultMessage := ""
+	placementHub := pbmtypes.PbmPlacementHub{
+		HubType: datastore.Reference().Type,
+		HubId:   datastore.Reference().Value,
+	}
+	hubs := []pbmtypes.PbmPlacementHub{placementHub}
+	req := []pbmtypes.BasePbmPlacementRequirement{
+		&pbmtypes.PbmPlacementCapabilityProfileRequirement{
+			ProfileId: pbmtypes.PbmProfileId{
+				UniqueId: storagePolicyID,
+			},
+		},
+	}
+	compatibilityResult, err := pbmClient.CheckRequirements(ctx, hubs, nil, req)
+	if err != nil {
+		glog.Errorf("Error occurred for CheckRequirements call. err %+v", err)
+		return false, "", err
+	}
+	if compatibilityResult != nil && len(compatibilityResult) > 0 {
+		compatibleHubs := compatibilityResult.CompatibleDatastores()
+		if compatibleHubs != nil && len(compatibleHubs) > 0 {
+			return true, "", nil
+		}
+		dsName, err := datastore.ObjectName(ctx)
+		if err != nil {
+			glog.Errorf("Failed to get datastore ObjectName")
+			return false, "", err
+		}
+		if compatibilityResult[0].Error[0].LocalizedMessage == "" {
+			faultMessage = "Datastore: " + dsName + " is not compatible with the storage policy."
+		} else {
+			faultMessage = "Datastore: " + dsName + " is not compatible with the storage policy. LocalizedMessage: " + compatibilityResult[0].Error[0].LocalizedMessage + "\n"
+		}
+		return false, faultMessage, nil
+	}
+	return false, "", fmt.Errorf("compatibilityResult is nil or empty")
+}
+
+// GetCompatibleDatastores filters and returns compatible list of datastores for given storage policy id
+// For Non Compatible Datastores, fault message with the Datastore Name is also returned
+func (pbmClient *PbmClient) GetCompatibleDatastores(ctx context.Context, storagePolicyID string, datastores []*Datastore) ([]*Datastore, string, error) {
+	var (
+		dsMorNameMap                                = getDsMorNameMap(ctx, datastores)
+		localizedMessagesForNotCompatibleDatastores = ""
+	)
+	compatibilityResult, err := pbmClient.GetPlacementCompatibilityResult(ctx, storagePolicyID, datastores)
+	if err != nil {
+		glog.Errorf("Error occurred while retrieving placement compatibility result for datastores: %+v with storagePolicyID: %s. err: %+v", datastores, storagePolicyID, err)
+		return nil, "", err
+	}
+	compatibleHubs := compatibilityResult.CompatibleDatastores()
+	var compatibleDatastoreList []*Datastore
+	for _, hub := range compatibleHubs {
+		compatibleDatastoreList = append(compatibleDatastoreList, getDatastoreFromPlacementHub(datastores, hub))
+	}
+	for _, res := range compatibilityResult {
+		for _, err := range res.Error {
+			dsName := dsMorNameMap[res.Hub.HubId]
+			localizedMessage := ""
+			if err.LocalizedMessage != "" {
+				localizedMessage = "Datastore: " + dsName + " not compatible with the storage policy. LocalizedMessage: " + err.LocalizedMessage + "\n"
+			} else {
+				localizedMessage = "Datastore: " + dsName + " not compatible with the storage policy. \n"
+			}
+			localizedMessagesForNotCompatibleDatastores += localizedMessage
+		}
+	}
+	// Return an error if there are no compatible datastores.
+	if len(compatibleHubs) < 1 {
+		glog.Errorf("No compatible datastores found that satisfy the storage policy requirements: %s", storagePolicyID)
+		return nil, localizedMessagesForNotCompatibleDatastores, fmt.Errorf("No compatible datastores found that satisfy the storage policy requirements")
+	}
+	return compatibleDatastoreList, localizedMessagesForNotCompatibleDatastores, nil
+}
+
+// GetPlacementCompatibilityResult gets placement compatibility result based on storage policy requirements.
+func (pbmClient *PbmClient) GetPlacementCompatibilityResult(ctx context.Context, storagePolicyID string, datastore []*Datastore) (pbm.PlacementCompatibilityResult, error) {
+	var hubs []pbmtypes.PbmPlacementHub
+	for _, ds := range datastore {
+		hubs = append(hubs, pbmtypes.PbmPlacementHub{
+			HubType: ds.Reference().Type,
+			HubId:   ds.Reference().Value,
+		})
+	}
+	req := []pbmtypes.BasePbmPlacementRequirement{
+		&pbmtypes.PbmPlacementCapabilityProfileRequirement{
+			ProfileId: pbmtypes.PbmProfileId{
+				UniqueId: storagePolicyID,
+			},
+		},
+	}
+	res, err := pbmClient.CheckRequirements(ctx, hubs, nil, req)
+	if err != nil {
+		glog.Errorf("Error occurred for CheckRequirements call. err: %+v", err)
+		return nil, err
+	}
+	return res, nil
+}
+
+// getDataStoreForPlacementHub returns matching datastore associated with given pbmPlacementHub
+func getDatastoreFromPlacementHub(datastore []*Datastore, pbmPlacementHub pbmtypes.PbmPlacementHub) *Datastore {
+	for _, ds := range datastore {
+		if ds.Reference().Type == pbmPlacementHub.HubType && ds.Reference().Value == pbmPlacementHub.HubId {
+			return ds
+		}
+	}
+	return nil
+}
+
+// getDsMorNameMap returns map of ds Mor and Datastore Object Name
+func getDsMorNameMap(ctx context.Context, datastores []*Datastore) map[string]string {
+	dsMorNameMap := make(map[string]string)
+	for _, ds := range datastores {
+		dsObjectName, err := ds.ObjectName(ctx)
+		if err == nil {
+			dsMorNameMap[ds.Reference().Value] = dsObjectName
+		} else {
+			glog.Errorf("Error occurred while getting datastore object name. err: %+v", err)
+		}
+	}
+	return dsMorNameMap
+}

pkg/cloudprovider/providers/vsphere/vclib/utils.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 vclib
+
+import (
+	"fmt"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/vmware/govmomi/find"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+func getFinder(dc *Datacenter) *find.Finder {
+	finder := find.NewFinder(dc.Client(), true)
+	finder.SetDatacenter(dc.Datacenter)
+	return finder
+}
+
+// formatVirtualDiskUUID removes any spaces and hyphens in UUID
+// Example UUID input is 42375390-71f9-43a3-a770-56803bcd7baa and output after format is 4237539071f943a3a77056803bcd7baa
+func formatVirtualDiskUUID(uuid string) string {
+	uuidwithNoSpace := strings.Replace(uuid, " ", "", -1)
+	uuidWithNoHypens := strings.Replace(uuidwithNoSpace, "-", "", -1)
+	return strings.ToLower(uuidWithNoHypens)
+}
+
+// getSCSIControllersOfType filters specific type of Controller device from given list of Virtual Machine Devices
+func getSCSIControllersOfType(vmDevices object.VirtualDeviceList, scsiType string) []*types.VirtualController {
+	// get virtual scsi controllers of passed argument type
+	var scsiControllers []*types.VirtualController
+	for _, device := range vmDevices {
+		devType := vmDevices.Type(device)
+		if devType == scsiType {
+			if c, ok := device.(types.BaseVirtualController); ok {
+				scsiControllers = append(scsiControllers, c.GetVirtualController())
+			}
+		}
+	}
+	return scsiControllers
+}
+
+// getAvailableSCSIController gets available SCSI Controller from list of given controllers, which has less than 15 disk devices.
+func getAvailableSCSIController(scsiControllers []*types.VirtualController) *types.VirtualController {
+	// get SCSI controller which has space for adding more devices
+	for _, controller := range scsiControllers {
+		if len(controller.Device) < SCSIControllerDeviceLimit {
+			return controller
+		}
+	}
+	return nil
+}
+
+// getNextUnitNumber gets the next available SCSI controller unit number from given list of Controller Device List
+func getNextUnitNumber(devices object.VirtualDeviceList, c types.BaseVirtualController) (int32, error) {
+	var takenUnitNumbers [SCSIDeviceSlots]bool
+	takenUnitNumbers[SCSIReservedSlot] = true
+	key := c.GetVirtualController().Key
+
+	for _, device := range devices {
+		d := device.GetVirtualDevice()
+		if d.ControllerKey == key {
+			if d.UnitNumber != nil {
+				takenUnitNumbers[*d.UnitNumber] = true
+			}
+		}
+	}
+	for unitNumber, takenUnitNumber := range takenUnitNumbers {
+		if !takenUnitNumber {
+			return int32(unitNumber), nil
+		}
+	}
+	return -1, fmt.Errorf("SCSI Controller with key=%d does not have any available slots", key)
+}
+
+// getSCSIControllers filters and return list of Controller Devices from given list of Virtual Machine Devices.
+func getSCSIControllers(vmDevices object.VirtualDeviceList) []*types.VirtualController {
+	// get all virtual scsi controllers
+	var scsiControllers []*types.VirtualController
+	for _, device := range vmDevices {
+		devType := vmDevices.Type(device)
+		switch devType {
+		case SCSIControllerType, strings.ToLower(LSILogicControllerType), strings.ToLower(BusLogicControllerType), PVSCSIControllerType, strings.ToLower(LSILogicSASControllerType):
+			if c, ok := device.(types.BaseVirtualController); ok {
+				scsiControllers = append(scsiControllers, c.GetVirtualController())
+			}
+		}
+	}
+	return scsiControllers
+}
+
+// RemoveClusterFromVDiskPath removes the cluster or folder path from the vDiskPath
+// for vDiskPath [DatastoreCluster/sharedVmfs-0] kubevols/e2e-vmdk-1234.vmdk, return value is [sharedVmfs-0] kubevols/e2e-vmdk-1234.vmdk
+// for vDiskPath [sharedVmfs-0] kubevols/e2e-vmdk-1234.vmdk, return value remains same [sharedVmfs-0] kubevols/e2e-vmdk-1234.vmdk
+func RemoveClusterFromVDiskPath(vDiskPath string) string {
+	datastore := regexp.MustCompile("\\[(.*?)\\]").FindStringSubmatch(vDiskPath)[1]
+	if filepath.Base(datastore) != datastore {
+		vDiskPath = strings.Replace(vDiskPath, datastore, filepath.Base(datastore), 1)
+	}
+	return vDiskPath
+}

pkg/cloudprovider/providers/vsphere/vclib/vmoptions.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 vclib
+
+import (
+	"github.com/vmware/govmomi/object"
+)
+
+// VMOptions provides helper objects for provisioning volume with SPBM Policy
+type VMOptions struct {
+	VMFolder       *Folder
+	VMResourcePool *object.ResourcePool
+}

pkg/cloudprovider/providers/vsphere/vclib/volumeoptions.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 vclib
+
+import (
+	"strings"
+
+	"github.com/golang/glog"
+)
+
+// VolumeOptions specifies various options for a volume.
+type VolumeOptions struct {
+	CapacityKB             int
+	Tags                   map[string]string
+	Name                   string
+	DiskFormat             string
+	Datastore              string
+	VSANStorageProfileData string
+	StoragePolicyName      string
+	StoragePolicyID        string
+	SCSIControllerType     string
+}
+
+var (
+	// DiskFormatValidType specifies the valid disk formats
+	DiskFormatValidType = map[string]string{
+		ThinDiskType:                              ThinDiskType,
+		strings.ToLower(EagerZeroedThickDiskType): EagerZeroedThickDiskType,
+		strings.ToLower(ZeroedThickDiskType):      PreallocatedDiskType,
+	}
+	// SCSIControllerValidType specifies the supported SCSI controllers
+	SCSIControllerValidType = []string{LSILogicControllerType, LSILogicSASControllerType, PVSCSIControllerType}
+)
+
+// DiskformatValidOptions generates Valid Options for Diskformat
+func DiskformatValidOptions() string {
+	validopts := ""
+	for diskformat := range DiskFormatValidType {
+		validopts += diskformat + ", "
+	}
+	validopts = strings.TrimSuffix(validopts, ", ")
+	return validopts
+}
+
+// CheckDiskFormatSupported checks if the diskFormat is valid
+func CheckDiskFormatSupported(diskFormat string) bool {
+	if DiskFormatValidType[diskFormat] == "" {
+		glog.Errorf("Not a valid Disk Format. Valid options are %+q", DiskformatValidOptions())
+		return false
+	}
+	return true
+}
+
+// SCSIControllerTypeValidOptions generates valid options for SCSIControllerType
+func SCSIControllerTypeValidOptions() string {
+	validopts := ""
+	for _, controllerType := range SCSIControllerValidType {
+		validopts += (controllerType + ", ")
+	}
+	validopts = strings.TrimSuffix(validopts, ", ")
+	return validopts
+}
+
+// CheckControllerSupported checks if the given controller type is valid
+func CheckControllerSupported(ctrlType string) bool {
+	for _, c := range SCSIControllerValidType {
+		if ctrlType == c {
+			return true
+		}
+	}
+	glog.Errorf("Not a valid SCSI Controller Type. Valid options are %q", SCSIControllerTypeValidOptions())
+	return false
+}
+
+// VerifyVolumeOptions checks if volumeOptions.SCIControllerType is valid controller type
+func (volumeOptions VolumeOptions) VerifyVolumeOptions() bool {
+	// Validate only if SCSIControllerType is set by user.
+	// Default value is set later in virtualDiskManager.Create and vmDiskManager.Create
+	if volumeOptions.SCSIControllerType != "" {
+		isValid := CheckControllerSupported(volumeOptions.SCSIControllerType)
+		if !isValid {
+			return false
+		}
+	}
+	// ThinDiskType is the default, so skip the validation.
+	if volumeOptions.DiskFormat != ThinDiskType {
+		isValid := CheckDiskFormatSupported(volumeOptions.DiskFormat)
+		if !isValid {
+			return false
+		}
+	}
+	return true
+}

pkg/cloudprovider/providers/vsphere/vsphere_metrics.go → pkg/cloudprovider/providers/vsphere/vclib/vsphere_metrics.go

@@ -14,33 +14,36 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package vsphere
+package vclib
 
 import (
-	"github.com/prometheus/client_golang/prometheus"
 	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
 )
 
+// Cloud Provider API constants
 const (
-	api_createvolume = "CreateVolume"
-	api_deletevolume = "DeleteVolume"
-	api_attachvolume = "AttachVolume"
-	api_detachvolume = "DetachVolume"
+	APICreateVolume = "CreateVolume"
+	APIDeleteVolume = "DeleteVolume"
+	APIAttachVolume = "AttachVolume"
+	APIDetachVolume = "DetachVolume"
 )
 
+// Cloud Provider Operation constants
 const (
-	operation_deletevolume                      = "DeleteVolumeOperation"
-	operation_attachvolume                      = "AttachVolumeOperation"
-	operation_detachvolume                      = "DetachVolumeOperation"
-	operation_diskIsAttached                    = "DiskIsAttachedOperation"
-	operation_disksAreAttached                  = "DisksAreAttachedOperation"
-	operation_createvolume                      = "CreateVolumeOperation"
-	operation_createvolume_with_policy          = "CreateVolumeWithPolicyOperation"
-	operation_createvolume_with_raw_vsan_policy = "CreateVolumeWithRawVSANPolicyOperation"
+	OperationDeleteVolume                  = "DeleteVolumeOperation"
+	OperationAttachVolume                  = "AttachVolumeOperation"
+	OperationDetachVolume                  = "DetachVolumeOperation"
+	OperationDiskIsAttached                = "DiskIsAttachedOperation"
+	OperationDisksAreAttached              = "DisksAreAttachedOperation"
+	OperationCreateVolume                  = "CreateVolumeOperation"
+	OperationCreateVolumeWithPolicy        = "CreateVolumeWithPolicyOperation"
+	OperationCreateVolumeWithRawVSANPolicy = "CreateVolumeWithRawVSANPolicyOperation"
 )
 
-// vsphereApiMetric is for recording latency of Single API Call.
-var vsphereApiMetric = prometheus.NewHistogramVec(
+// vsphereAPIMetric is for recording latency of Single API Call.
+var vsphereAPIMetric = prometheus.NewHistogramVec(
 	prometheus.HistogramOpts{
 		Name: "cloudprovider_vsphere_api_request_duration_seconds",
 		Help: "Latency of vsphere api call",
@@ -48,7 +51,7 @@ var vsphereApiMetric = prometheus.NewHistogramVec(
 	[]string{"request"},
 )
 
-var vsphereApiErrorMetric = prometheus.NewCounterVec(
+var vsphereAPIErrorMetric = prometheus.NewCounterVec(
 	prometheus.CounterOpts{
 		Name: "cloudprovider_vsphere_api_request_errors",
 		Help: "vsphere Api errors",
@@ -73,16 +76,18 @@ var vsphereOperationErrorMetric = prometheus.NewCounterVec(
 	[]string{"operation"},
 )
 
-func registerMetrics() {
-	prometheus.MustRegister(vsphereApiMetric)
-	prometheus.MustRegister(vsphereApiErrorMetric)
+// RegisterMetrics registers all the API and Operation metrics
+func RegisterMetrics() {
+	prometheus.MustRegister(vsphereAPIMetric)
+	prometheus.MustRegister(vsphereAPIErrorMetric)
 	prometheus.MustRegister(vsphereOperationMetric)
 	prometheus.MustRegister(vsphereOperationErrorMetric)
 }
 
-func recordvSphereMetric(actionName string, requestTime time.Time, err error) {
+// RecordvSphereMetric records the vSphere API and Operation metrics
+func RecordvSphereMetric(actionName string, requestTime time.Time, err error) {
 	switch actionName {
-	case api_createvolume, api_deletevolume, api_attachvolume, api_detachvolume:
+	case APICreateVolume, APIDeleteVolume, APIAttachVolume, APIDetachVolume:
 		recordvSphereAPIMetric(actionName, requestTime, err)
 	default:
 		recordvSphereOperationMetric(actionName, requestTime, err)
@@ -91,9 +96,9 @@ func recordvSphereMetric(actionName string, requestTime time.Time, err error) {
 
 func recordvSphereAPIMetric(actionName string, requestTime time.Time, err error) {
 	if err != nil {
-		vsphereApiErrorMetric.With(prometheus.Labels{"request": actionName}).Inc()
+		vsphereAPIErrorMetric.With(prometheus.Labels{"request": actionName}).Inc()
 	} else {
-		vsphereApiMetric.With(prometheus.Labels{"request": actionName}).Observe(calculateTimeTaken(requestTime))
+		vsphereAPIMetric.With(prometheus.Labels{"request": actionName}).Observe(calculateTimeTaken(requestTime))
 	}
 }
 
@@ -105,16 +110,17 @@ func recordvSphereOperationMetric(actionName string, requestTime time.Time, err
 	}
 }
 
-func recordCreateVolumeMetric(volumeOptions *VolumeOptions, requestTime time.Time, err error) {
+// RecordCreateVolumeMetric records the Create Volume metric
+func RecordCreateVolumeMetric(volumeOptions *VolumeOptions, requestTime time.Time, err error) {
 	var actionName string
 	if volumeOptions.StoragePolicyName != "" {
-		actionName = operation_createvolume_with_policy
+		actionName = OperationCreateVolumeWithPolicy
 	} else if volumeOptions.VSANStorageProfileData != "" {
-		actionName = operation_createvolume_with_raw_vsan_policy
+		actionName = OperationCreateVolumeWithRawVSANPolicy
 	} else {
-		actionName = operation_createvolume
+		actionName = OperationCreateVolume
 	}
-	recordvSphereMetric(actionName, requestTime, err)
+	RecordvSphereMetric(actionName, requestTime, err)
 }
 
 func calculateTimeTaken(requestBeginTime time.Time) (timeTaken float64) {

pkg/cloudprovider/providers/vsphere/vsphere_test.go

@@ -27,6 +27,7 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/rand"
 	"k8s.io/kubernetes/pkg/cloudprovider"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere/vclib"
 )
 
 func configFromEnv() (cfg VSphereConfig, ok bool) {
@@ -125,11 +126,11 @@ func TestVSphereLogin(t *testing.T) {
 	defer cancel()
 
 	// Create vSphere client
-	err = vSphereLogin(ctx, vs)
+	err = vs.conn.Connect(ctx)
 	if err != nil {
-		t.Errorf("Failed to create vSpere client: %s", err)
+		t.Errorf("Failed to connect to vSphere: %s", err)
 	}
-	defer vs.client.Logout(ctx)
+	defer vs.conn.GoVmomiClient.Logout(ctx)
 }
 
 func TestZones(t *testing.T) {
@@ -168,14 +169,14 @@ func TestInstances(t *testing.T) {
 		t.Fatalf("CurrentNodeName() failed: %s", err)
 	}
 
-	externalId, err := i.ExternalID(nodeName)
+	externalID, err := i.ExternalID(nodeName)
 	if err != nil {
 		t.Fatalf("Instances.ExternalID(%s) failed: %s", nodeName, err)
 	}
-	t.Logf("Found ExternalID(%s) = %s\n", nodeName, externalId)
+	t.Logf("Found ExternalID(%s) = %s\n", nodeName, externalID)
 
 	nonExistingVM := types.NodeName(rand.String(15))
-	externalId, err = i.ExternalID(nonExistingVM)
+	externalID, err = i.ExternalID(nonExistingVM)
 	if err == cloudprovider.InstanceNotFound {
 		t.Logf("VM %s was not found as expected\n", nonExistingVM)
 	} else if err == nil {
@@ -184,13 +185,13 @@ func TestInstances(t *testing.T) {
 		t.Fatalf("Instances.ExternalID did not fail as expected, err: %v", err)
 	}
 
-	instanceId, err := i.InstanceID(nodeName)
+	instanceID, err := i.InstanceID(nodeName)
 	if err != nil {
 		t.Fatalf("Instances.InstanceID(%s) failed: %s", nodeName, err)
 	}
-	t.Logf("Found InstanceID(%s) = %s\n", nodeName, instanceId)
+	t.Logf("Found InstanceID(%s) = %s\n", nodeName, instanceID)
 
-	instanceId, err = i.InstanceID(nonExistingVM)
+	instanceID, err = i.InstanceID(nonExistingVM)
 	if err == cloudprovider.InstanceNotFound {
 		t.Logf("VM %s was not found as expected\n", nonExistingVM)
 	} else if err == nil {
@@ -222,7 +223,7 @@ func TestVolumes(t *testing.T) {
 		t.Fatalf("CurrentNodeName() failed: %s", err)
 	}
 
-	volumeOptions := &VolumeOptions{
+	volumeOptions := &vclib.VolumeOptions{
 		CapacityKB: 1 * 1024 * 1024,
 		Tags:       nil,
 		Name:       "kubernetes-test-volume-" + rand.String(10),
@@ -233,7 +234,7 @@ func TestVolumes(t *testing.T) {
 		t.Fatalf("Cannot create a new VMDK volume: %v", err)
 	}
 
-	_, _, err = vs.AttachDisk(volPath, "", "")
+	_, err = vs.AttachDisk(volPath, "", "")
 	if err != nil {
 		t.Fatalf("Cannot attach volume(%s) to VM(%s): %v", volPath, nodeName, err)
 	}
@@ -249,36 +250,3 @@ func TestVolumes(t *testing.T) {
 	// 	t.Fatalf("Cannot delete VMDK volume %s: %v", volPath, err)
 	// }
 }
-
-func TestGetVMName(t *testing.T) {
-	cfg, ok := configFromEnv()
-	if !ok {
-		t.Skipf("No config found in environment")
-	}
-
-	// Create vSphere configuration object
-	vs, err := newVSphere(cfg)
-	if err != nil {
-		t.Fatalf("Failed to construct/authenticate vSphere: %s", err)
-	}
-
-	// Create context
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// Create vSphere client
-	err = vSphereLogin(ctx, vs)
-	if err != nil {
-		t.Errorf("Failed to create vSpere client: %s", err)
-	}
-	defer vs.client.Logout(ctx)
-
-	// Get VM name
-	vmName, err := getVMName(vs.client, &cfg)
-	if err != nil {
-		t.Fatalf("Failed to get VM name: %s", err)
-	}
-	if vmName != "vmname" {
-		t.Errorf("Expect VM name 'vmname', got: %s", vmName)
-	}
-}

pkg/volume/vsphere_volume/BUILD

@@ -19,6 +19,7 @@ go_library(
     deps = [
         "//pkg/cloudprovider:go_default_library",
         "//pkg/cloudprovider/providers/vsphere:go_default_library",
+        "//pkg/cloudprovider/providers/vsphere/vclib:go_default_library",
         "//pkg/util/keymutex:go_default_library",
         "//pkg/util/mount:go_default_library",
         "//pkg/util/strings:go_default_library",
@@ -43,7 +44,7 @@ go_test(
     library = ":go_default_library",
     tags = ["automanaged"],
     deps = [
-        "//pkg/cloudprovider/providers/vsphere:go_default_library",
+        "//pkg/cloudprovider/providers/vsphere/vclib:go_default_library",
         "//pkg/util/mount:go_default_library",
         "//pkg/volume:go_default_library",
         "//pkg/volume/testing:go_default_library",

pkg/volume/vsphere_volume/attacher.go

@@ -75,7 +75,7 @@ func (attacher *vsphereVMDKAttacher) Attach(spec *volume.Spec, nodeName types.No
 
 	// vsphereCloud.AttachDisk checks if disk is already attached to host and
 	// succeeds in that case, so no need to do that separately.
-	_, diskUUID, err := attacher.vsphereVolumes.AttachDisk(volumeSource.VolumePath, volumeSource.StoragePolicyID, nodeName)
+	diskUUID, err := attacher.vsphereVolumes.AttachDisk(volumeSource.VolumePath, volumeSource.StoragePolicyID, nodeName)
 	if err != nil {
 		glog.Errorf("Error attaching volume %q to node %q: %+v", volumeSource.VolumePath, nodeName, err)
 		return "", err

pkg/volume/vsphere_volume/attacher_test.go

@@ -21,7 +21,7 @@ import (
 	"testing"
 
 	"k8s.io/api/core/v1"
-	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere/vclib"
 	"k8s.io/kubernetes/pkg/volume"
 	volumetest "k8s.io/kubernetes/pkg/volume/testing"
 
@@ -233,29 +233,29 @@ type diskIsAttachedCall struct {
 	ret        error
 }
 
-func (testcase *testcase) AttachDisk(diskName string, storagePolicyName string, nodeName types.NodeName) (string, string, error) {
+func (testcase *testcase) AttachDisk(diskName string, storagePolicyName string, nodeName types.NodeName) (string, error) {
 	expected := &testcase.attach
 
 	if expected.diskName == "" && expected.nodeName == "" {
 		// testcase.attach looks uninitialized, test did not expect to call
 		// AttachDisk
 		testcase.t.Errorf("Unexpected AttachDisk call!")
-		return "", "", errors.New("Unexpected AttachDisk call!")
+		return "", errors.New("Unexpected AttachDisk call!")
 	}
 
 	if expected.diskName != diskName {
 		testcase.t.Errorf("Unexpected AttachDisk call: expected diskName %s, got %s", expected.diskName, diskName)
-		return "", "", errors.New("Unexpected AttachDisk call: wrong diskName")
+		return "", errors.New("Unexpected AttachDisk call: wrong diskName")
 	}
 
 	if expected.nodeName != nodeName {
 		testcase.t.Errorf("Unexpected AttachDisk call: expected nodeName %s, got %s", expected.nodeName, nodeName)
-		return "", "", errors.New("Unexpected AttachDisk call: wrong nodeName")
+		return "", errors.New("Unexpected AttachDisk call: wrong nodeName")
 	}
 
 	glog.V(4).Infof("AttachDisk call: %s, %s, returning %q, %v", diskName, nodeName, expected.retDeviceUUID, expected.ret)
 
-	return "", expected.retDeviceUUID, expected.ret
+	return expected.retDeviceUUID, expected.ret
 }
 
 func (testcase *testcase) DetachDisk(diskName string, nodeName types.NodeName) error {
@@ -312,7 +312,7 @@ func (testcase *testcase) DisksAreAttached(diskNames []string, nodeName types.No
 	return nil, errors.New("Not implemented")
 }
 
-func (testcase *testcase) CreateVolume(volumeOptions *vsphere.VolumeOptions) (volumePath string, err error) {
+func (testcase *testcase) CreateVolume(volumeOptions *vclib.VolumeOptions) (volumePath string, err error) {
 	return "", errors.New("Not implemented")
 }
 

pkg/volume/vsphere_volume/vsphere_volume_util.go

@@ -27,6 +27,7 @@ import (
 	"k8s.io/api/core/v1"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere/vclib"
 	"k8s.io/kubernetes/pkg/volume"
 	volumeutil "k8s.io/kubernetes/pkg/volume/util"
 )
@@ -94,7 +95,7 @@ func (util *VsphereDiskUtil) CreateVolume(v *vsphereVolumeProvisioner) (volSpec
 	// vSphere works with kilobytes, convert to KiB with rounding up
 	volSizeKB := int(volume.RoundUpSize(volSizeBytes, 1024))
 	name := volume.GenerateVolumeName(v.options.ClusterName, v.options.PVName, 255)
-	volumeOptions := &vsphere.VolumeOptions{
+	volumeOptions := &vclib.VolumeOptions{
 		CapacityKB: volSizeKB,
 		Tags:       *v.options.CloudTags,
 		Name:       name,
@@ -129,7 +130,7 @@ func (util *VsphereDiskUtil) CreateVolume(v *vsphereVolumeProvisioner) (volSpec
 
 	if volumeOptions.VSANStorageProfileData != "" {
 		if volumeOptions.StoragePolicyName != "" {
-			return nil, fmt.Errorf("Cannot specify storage policy capabilities along with storage policy name. Please specify only one.")
+			return nil, fmt.Errorf("Cannot specify storage policy capabilities along with storage policy name. Please specify only one")
 		}
 		volumeOptions.VSANStorageProfileData = "(" + volumeOptions.VSANStorageProfileData + ")"
 	}
@@ -141,7 +142,6 @@ func (util *VsphereDiskUtil) CreateVolume(v *vsphereVolumeProvisioner) (volSpec
 
 	vmDiskPath, err := cloud.CreateVolume(volumeOptions)
 	if err != nil {
-		glog.V(2).Infof("Error creating vsphere volume: %v", err)
 		return nil, err
 	}
 	volSpec = &VolumeSpec{

test/e2e/storage/BUILD

@@ -37,6 +37,7 @@ go_library(
         "//pkg/api/v1/helper:go_default_library",
         "//pkg/apis/storage/v1/util:go_default_library",
         "//pkg/cloudprovider/providers/vsphere:go_default_library",
+        "//pkg/cloudprovider/providers/vsphere/vclib:go_default_library",
         "//pkg/kubelet/apis:go_default_library",
         "//pkg/volume/util/volumehelper:go_default_library",
         "//test/e2e/framework:go_default_library",

test/e2e/storage/persistent_volumes-vsphere.go

@@ -102,7 +102,7 @@ var _ = SIGDescribe("PersistentVolumes:vsphere", func() {
 		By("Creating the Client Pod")
 		clientPod, err = framework.CreateClientPod(c, ns, pvc)
 		Expect(err).NotTo(HaveOccurred())
-		node := types.NodeName(clientPod.Spec.NodeName)
+		node = types.NodeName(clientPod.Spec.NodeName)
 
 		By("Verify disk should be attached to the node")
 		isAttached, err := verifyVSphereDiskAttached(vsp, volumePath, node)

test/e2e/storage/vsphere_utils.go

@@ -33,6 +33,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/wait"
 	clientset "k8s.io/client-go/kubernetes"
 	vsphere "k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere/vclib"
 	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
 	"k8s.io/kubernetes/test/e2e/framework"
 )
@@ -160,13 +161,13 @@ func getVSpherePersistentVolumeClaimSpec(namespace string, labels map[string]str
 }
 
 // function to create vmdk volume
-func createVSphereVolume(vsp *vsphere.VSphere, volumeOptions *vsphere.VolumeOptions) (string, error) {
+func createVSphereVolume(vsp *vsphere.VSphere, volumeOptions *vclib.VolumeOptions) (string, error) {
 	var (
 		volumePath string
 		err        error
 	)
 	if volumeOptions == nil {
-		volumeOptions = new(vsphere.VolumeOptions)
+		volumeOptions = new(vclib.VolumeOptions)
 		volumeOptions.CapacityKB = 2097152
 		volumeOptions.Name = "e2e-vmdk-" + strconv.FormatInt(time.Now().UnixNano(), 10)
 	}

test/e2e/storage/vsphere_volume_fstype.go

@@ -22,8 +22,6 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"k8s.io/api/core/v1"
-	storage "k8s.io/api/storage/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	k8stype "k8s.io/apimachinery/pkg/types"
 	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere"
@@ -48,10 +46,8 @@ import (
 var _ = SIGDescribe("vsphere Volume fstype", func() {
 	f := framework.NewDefaultFramework("volume-fstype")
 	var (
-		client       clientset.Interface
-		namespace    string
-		storageclass *storage.StorageClass
-		pvclaim      *v1.PersistentVolumeClaim
+		client    clientset.Interface
+		namespace string
 	)
 	BeforeEach(func() {
 		framework.SkipUnlessProviderIs("vsphere")
@@ -60,87 +56,56 @@ var _ = SIGDescribe("vsphere Volume fstype", func() {
 		nodeList := framework.GetReadySchedulableNodesOrDie(f.ClientSet)
 		Expect(len(nodeList.Items)).NotTo(BeZero(), "Unable to find ready and schedulable Node")
 	})
-	AfterEach(func() {
-		var scDeleteError error
-		var pvDeleteError error
-		if storageclass != nil {
-			scDeleteError = client.StorageV1beta1().StorageClasses().Delete(storageclass.Name, nil)
-		}
-		if pvclaim != nil {
-			pvDeleteError = client.CoreV1().PersistentVolumeClaims(namespace).Delete(pvclaim.Name, nil)
-		}
-		framework.ExpectNoError(scDeleteError)
-		framework.ExpectNoError(pvDeleteError)
-		storageclass = nil
-		pvclaim = nil
-	})
 
 	It("verify fstype - ext3 formatted volume", func() {
 		By("Invoking Test for fstype: ext3")
-		storageclass, pvclaim = invokeTestForFstype(f, client, namespace, "ext3", "ext3")
+		invokeTestForFstype(f, client, namespace, "ext3", "ext3")
 	})
 
 	It("verify disk format type - default value should be ext4", func() {
 		By("Invoking Test for fstype: Default Value")
-		storageclass, pvclaim = invokeTestForFstype(f, client, namespace, "", "ext4")
+		invokeTestForFstype(f, client, namespace, "", "ext4")
 	})
 })
 
-func invokeTestForFstype(f *framework.Framework, client clientset.Interface, namespace string, fstype string, expectedContent string) (*storage.StorageClass, *v1.PersistentVolumeClaim) {
-
+func invokeTestForFstype(f *framework.Framework, client clientset.Interface, namespace string, fstype string, expectedContent string) {
 	framework.Logf("Invoking Test for fstype: %s", fstype)
 	scParameters := make(map[string]string)
 	scParameters["fstype"] = fstype
 
 	By("Creating Storage Class With Fstype")
-	storageClassSpec := getVSphereStorageClassSpec("fstype", scParameters)
-	storageclass, err := client.StorageV1().StorageClasses().Create(storageClassSpec)
+	storageclass, err := client.StorageV1().StorageClasses().Create(getVSphereStorageClassSpec("fstype", scParameters))
 	Expect(err).NotTo(HaveOccurred())
+	defer client.StorageV1().StorageClasses().Delete(storageclass.Name, nil)
 
 	By("Creating PVC using the Storage Class")
-	pvclaimSpec := getVSphereClaimSpecWithStorageClassAnnotation(namespace, storageclass)
-	pvclaim, err := client.CoreV1().PersistentVolumeClaims(namespace).Create(pvclaimSpec)
+	pvclaim, err := client.CoreV1().PersistentVolumeClaims(namespace).Create(getVSphereClaimSpecWithStorageClassAnnotation(namespace, storageclass))
 	Expect(err).NotTo(HaveOccurred())
+	defer framework.DeletePersistentVolumeClaim(client, pvclaim.Name, namespace)
 
+	var pvclaims []*v1.PersistentVolumeClaim
+	pvclaims = append(pvclaims, pvclaim)
 	By("Waiting for claim to be in bound phase")
-	err = framework.WaitForPersistentVolumeClaimPhase(v1.ClaimBound, client, pvclaim.Namespace, pvclaim.Name, framework.Poll, framework.ClaimProvisionTimeout)
-	Expect(err).NotTo(HaveOccurred())
-
-	// Get new copy of the claim
-	pvclaim, err = client.CoreV1().PersistentVolumeClaims(pvclaim.Namespace).Get(pvclaim.Name, metav1.GetOptions{})
-	Expect(err).NotTo(HaveOccurred())
-
-	// Get the bound PV
-	pv, err := client.CoreV1().PersistentVolumes().Get(pvclaim.Spec.VolumeName, metav1.GetOptions{})
+	persistentvolumes, err := framework.WaitForPVClaimBoundPhase(client, pvclaims)
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Creating pod to attach PV to the node")
 	// Create pod to attach Volume to Node
-	podSpec := getVSpherePodSpecWithClaim(pvclaim.Name, nil, "/bin/df -T /mnt/test | /bin/awk 'FNR == 2 {print $2}' > /mnt/test/fstype && while true ; do sleep 2 ; done")
-	pod, err := client.CoreV1().Pods(namespace).Create(podSpec)
-	Expect(err).NotTo(HaveOccurred())
-
-	By("Waiting for pod to be running")
-	Expect(framework.WaitForPodNameRunningInNamespace(client, pod.Name, namespace)).To(Succeed())
-
-	pod, err = client.CoreV1().Pods(namespace).Get(pod.Name, metav1.GetOptions{})
+	pod, err := framework.CreatePod(client, namespace, pvclaims, false, "")
 	Expect(err).NotTo(HaveOccurred())
 
 	// Asserts: Right disk is attached to the pod
 	vsp, err := vsphere.GetVSphere()
 	Expect(err).NotTo(HaveOccurred())
-	isAttached, err := verifyVSphereDiskAttached(vsp, pv.Spec.VsphereVolume.VolumePath, k8stype.NodeName(pod.Spec.NodeName))
-	Expect(err).NotTo(HaveOccurred())
-	Expect(isAttached).To(BeTrue(), "disk is not attached with the node")
+	By("Verify the volume is accessible and available in the pod")
+	verifyVSphereVolumesAccessible(pod, persistentvolumes, vsp)
 
 	_, err = framework.LookForStringInPodExec(namespace, pod.Name, []string{"/bin/cat", "/mnt/test/fstype"}, expectedContent, time.Minute)
 	Expect(err).NotTo(HaveOccurred())
 
-	var volumePaths []string
-	volumePaths = append(volumePaths, pv.Spec.VsphereVolume.VolumePath)
-
-	By("Delete pod and wait for volume to be detached from node")
-	deletePodAndWaitForVolumeToDetach(f, client, pod, vsp, pod.Spec.NodeName, volumePaths)
+	By("Deleting pod")
+	framework.DeletePodWithWait(f, client, pod)
 
-	return storageclass, pvclaim
+	By("Waiting for volumes to be detached from the node")
+	waitForVSphereDiskToDetach(vsp, persistentvolumes[0].Spec.VsphereVolume.VolumePath, k8stype.NodeName(pod.Spec.NodeName))
 }

test/e2e/storage/vsphere_volume_placement.go

@@ -29,6 +29,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/uuid"
 	clientset "k8s.io/client-go/kubernetes"
 	vsphere "k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/vsphere/vclib"
 	"k8s.io/kubernetes/test/e2e/framework"
 )
 
@@ -216,8 +217,8 @@ var _ = SIGDescribe("Volume Placement", func() {
 	*/
 	It("should create and delete pod with multiple volumes from different datastore", func() {
 		By("creating another vmdk on non default shared datastore")
-		var volumeOptions *vsphere.VolumeOptions
-		volumeOptions = new(vsphere.VolumeOptions)
+		var volumeOptions *vclib.VolumeOptions
+		volumeOptions = new(vclib.VolumeOptions)
 		volumeOptions.CapacityKB = 2097152
 		volumeOptions.Name = "e2e-vmdk-" + strconv.FormatInt(time.Now().UnixNano(), 10)
 		volumeOptions.Datastore = os.Getenv("VSPHERE_SECOND_SHARED_DATASTORE")

test/e2e/storage/vsphere_volume_vsan_policy.go

@@ -218,7 +218,7 @@ var _ = SIGDescribe("vSphere Storage policy support for dynamic provisioning", f
 		framework.Logf("Invoking Test for SPBM storage policy on a non-compatible datastore: %+v", scParameters)
 		err := invokeInvalidPolicyTestNeg(client, namespace, scParameters)
 		Expect(err).To(HaveOccurred())
-		errorMsg := "User specified datastore: \\\"" + VsanDatastore + "\\\" is not compatible with the storagePolicy: \\\"" + os.Getenv("VSPHERE_SPBM_TAG_POLICY") + "\\\""
+		errorMsg := "User specified datastore is not compatible with the storagePolicy: \\\"" + os.Getenv("VSPHERE_SPBM_TAG_POLICY") + "\\\""
 		if !strings.Contains(err.Error(), errorMsg) {
 			Expect(err).NotTo(HaveOccurred(), errorMsg)
 		}
@@ -248,7 +248,7 @@ var _ = SIGDescribe("vSphere Storage policy support for dynamic provisioning", f
 		framework.Logf("Invoking Test for SPBM storage policy and VSAN capabilities together: %+v", scParameters)
 		err := invokeInvalidPolicyTestNeg(client, namespace, scParameters)
 		Expect(err).To(HaveOccurred())
-		errorMsg := "Cannot specify storage policy capabilities along with storage policy name. Please specify only one."
+		errorMsg := "Cannot specify storage policy capabilities along with storage policy name. Please specify only one"
 		if !strings.Contains(err.Error(), errorMsg) {
 			Expect(err).NotTo(HaveOccurred(), errorMsg)
 		}