Add initial support for Volumes to AWS

cmd/e2e/e2e.go

@@ -17,10 +17,13 @@ limitations under the License.
 package main
 
 import (
+	"fmt"
 	"os"
 	goruntime "runtime"
+	"strings"
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/client/clientcmd"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 	"github.com/GoogleCloudPlatform/kubernetes/test/e2e"
 	"github.com/golang/glog"
@@ -47,6 +50,7 @@ func init() {
 	flag.StringVar(&context.Host, "host", "", "The host, or apiserver, to connect to")
 	flag.StringVar(&context.RepoRoot, "repo_root", "./", "Root directory of kubernetes repository, for finding test files. Default assumes working directory is repository root")
 	flag.StringVar(&context.Provider, "provider", "", "The name of the Kubernetes provider (gce, gke, local, vagrant, etc.)")
+
 	flag.StringVar(&gceConfig.MasterName, "kube_master", "", "Name of the kubernetes master. Only required if provider is gce or gke")
 	flag.StringVar(&gceConfig.ProjectID, "gce_project", "", "The GCE project being used, if applicable")
 	flag.StringVar(&gceConfig.Zone, "gce_zone", "", "GCE zone being used, if applicable")
@@ -63,5 +67,23 @@ func main() {
 		glog.Error("Invalid --times (negative or no testing requested)!")
 		os.Exit(1)
 	}
+	cloudConfig := &e2e.CloudConfig{
+		ProjectID:  *gceProject,
+		Zone:       *gceZone,
+		MasterName: *masterName,
+	}
+
+	if *provider == "aws" {
+		awsConfig := "[Global]\n"
+		awsConfig += fmt.Sprintf("Region=%s\n", *gceZone)
+
+		var err error
+		cloudConfig.Provider, err = cloudprovider.GetCloudProvider(*provider, strings.NewReader(awsConfig))
+		if err != nil {
+			glog.Error("Error building AWS provider: %v", err)
+			os.Exit(1)
+		}
+	}
+
 	e2e.RunE2ETests(context, *orderseed, *times, *reportDir, testList)
 }

cmd/kubelet/app/plugins.go

@@ -25,6 +25,7 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet/network/exec"
 	// Volume plugins
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/volume"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/volume/aws_pd"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/volume/empty_dir"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/volume/gce_pd"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/volume/git_repo"
@@ -49,6 +50,7 @@ func ProbeVolumePlugins() []volume.VolumePlugin {
 	// The list of plugins to probe is decided by the kubelet binary, not
 	// by dynamic linking or other "magic".  Plugins will be analyzed and
 	// initialized later.
+	allPlugins = append(allPlugins, aws_pd.ProbeVolumePlugins()...)
 	allPlugins = append(allPlugins, empty_dir.ProbeVolumePlugins()...)
 	allPlugins = append(allPlugins, gce_pd.ProbeVolumePlugins()...)
 	allPlugins = append(allPlugins, git_repo.ProbeVolumePlugins()...)

pkg/api/types.go

@@ -189,6 +189,9 @@ type VolumeSource struct {
 	// GCEPersistentDisk represents a GCE Disk resource that is attached to a
 	// kubelet's host machine and then exposed to the pod.
 	GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"gcePersistentDisk"`
+	// AWSPersistentDisk represents a AWS EBS disk that is attached to a
+	// kubelet's host machine and then exposed to the pod.
+	AWSPersistentDisk *AWSPersistentDiskVolumeSource `json:"awsPersistentDisk"`
 	// GitRepo represents a git repository at a particular revision.
 	GitRepo *GitRepoVolumeSource `json:"gitRepo"`
 	// Secret represents a secret that should populate this volume.
@@ -208,6 +211,9 @@ type PersistentVolumeSource struct {
 	// GCEPersistentDisk represents a GCE Disk resource that is attached to a
 	// kubelet's host machine and then exposed to the pod.
 	GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"gcePersistentDisk"`
+	// AWSPersistentDisk represents a AWS EBS disk that is attached to a
+	// kubelet's host machine and then exposed to the pod.
+	AWSPersistentDisk *AWSPersistentDiskVolumeSource `json:"awsPersistentDisk"`
 	// HostPath represents a directory on the host.
 	// This is useful for development and testing only.
 	// on-host storage is not supported in any way
@@ -384,11 +390,31 @@ type ISCSIVolumeSource struct {
 	IQN string `json:"iqn,omitempty"`
 	// Required: iSCSI target lun number
 	Lun int `json:"lun,omitempty"`
+	// Optional: Defaults to false (read/write). ReadOnly here will force
+	// the ReadOnly setting in VolumeMounts.
+	ReadOnly bool `json:"readOnly,omitempty"`
+}
+
+// AWSPersistentDiskVolumeSource represents a Persistent Disk resource in AWS.
+//
+// An AWS EBS disk must exist and be formatted before mounting to a container.
+// The disk must also be in the same AWS zone as the kubelet.
+// A AWS EBS disk can only be mounted as read/write once.
+type AWSPersistentDiskVolumeSource struct {
+	// Unique name of the PD resource. Used to identify the disk in AWS
+	PDName string `json:"pdName"`
+
 	// Required: Filesystem type to mount.
 	// Must be a filesystem type supported by the host operating system.
 	// Ex. "ext4", "xfs", "ntfs"
 	// TODO: how do we prevent errors in the filesystem from compromising the machine
 	FSType string `json:"fsType,omitempty"`
+
+	// Optional: Partition on the disk to mount.
+	// If omitted, kubelet will attempt to mount the device name.
+	// Ex. For /dev/sda1, this field is "1", for /dev/sda, this field is 0 or empty.
+	Partition int `json:"partition,omitempty"`
+
 	// Optional: Defaults to false (read/write). ReadOnly here will force
 	// the ReadOnly setting in VolumeMounts.
 	ReadOnly bool `json:"readOnly,omitempty"`

pkg/api/v1beta1/conversion.go

@@ -1170,6 +1170,9 @@ func init() {
 			if err := s.Convert(&in.ISCSI, &out.ISCSI, 0); err != nil {
 				return err
 			}
+			if err := s.Convert(&in.AWSPersistentDisk, &out.AWSPersistentDisk, 0); err != nil {
+				return err
+			}
 			if err := s.Convert(&in.HostPath, &out.HostDir, 0); err != nil {
 				return err
 			}
@@ -1194,7 +1197,11 @@ func init() {
 			if err := s.Convert(&in.GCEPersistentDisk, &out.GCEPersistentDisk, 0); err != nil {
 				return err
 			}
+<<<<<<< HEAD
 			if err := s.Convert(&in.ISCSI, &out.ISCSI, 0); err != nil {
+=======
+			if err := s.Convert(&in.AWSPersistentDisk, &out.AWSPersistentDisk, 0); err != nil {
+>>>>>>> Add initial support for Volumes to AWS
 				return err
 			}
 			if err := s.Convert(&in.HostDir, &out.HostPath, 0); err != nil {

pkg/api/v1beta1/types.go

@@ -88,7 +88,7 @@ type Volume struct {
 	// Source represents the location and type of a volume to mount.
 	// This is optional for now. If not specified, the Volume is implied to be an EmptyDir.
 	// This implied behavior is deprecated and will be removed in a future version.
-	Source VolumeSource `json:"source,omitempty" description:"location and type of volume to mount; at most one of HostDir, EmptyDir, GCEPersistentDisk, or GitRepo; default is EmptyDir"`
+	Source VolumeSource `json:"source,omitempty" description:"location and type of volume to mount; at most one of HostDir, EmptyDir, GCEPersistentDisk, AWSPersistentDisk, or GitRepo; default is EmptyDir"`
 }
 
 // VolumeSource represents the source location of a volume to mount.
@@ -105,6 +105,9 @@ type VolumeSource struct {
 	// GCEPersistentDisk represents a GCE Disk resource that is attached to a
 	// kubelet's host machine and then exposed to the pod.
 	GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"persistentDisk" description:"GCE disk resource attached to the host machine on demand"`
+	// AWSPersistentDisk represents a AWS Disk resource that is attached to a
+	// kubelet's host machine and then exposed to the pod.
+	AWSPersistentDisk *AWSPersistentDiskVolumeSource `json:"awsPersistentDisk" description:"AWS disk resource attached to the host machine on demand"`
 	// GitRepo represents a git repository at a particular revision.
 	GitRepo *GitRepoVolumeSource `json:"gitRepo" description:"git repository at a particular revision"`
 	// Secret represents a secret to populate the volume with
@@ -124,6 +127,9 @@ type PersistentVolumeSource struct {
 	// GCEPersistentDisk represents a GCE Disk resource that is attached to a
 	// kubelet's host machine and then exposed to the pod.
 	GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"persistentDisk" description:"GCE disk resource provisioned by an admin"`
+	// AWSPersistentDisk represents a AWS EBS volume that is attached to a
+	// kubelet's host machine and then exposed to the pod.
+	AWSPersistentDisk *AWSPersistentDiskVolumeSource `json:"awsPersistentDisk" description:"AWS disk resource provisioned by an admin"`
 	// HostPath represents a directory on the host.
 	// This is useful for development and testing only.
 	// on-host storage is not supported in any way.
@@ -302,6 +308,29 @@ type ISCSIVolumeSource struct {
 	ReadOnly bool `json:"readOnly,omitempty" description:"read-only if true, read-write otherwise (false or unspecified)"`
 }
 
+// AWSPersistentDiskVolumeSource represents a Persistent Disk resource in AWS.
+//
+// An AWS PD must exist and be formatted before mounting to a container.
+// The disk must also be in the same AWS zone as the kubelet.
+// A AWS PD can only be mounted on a single machine.
+type AWSPersistentDiskVolumeSource struct {
+	// Unique name of the PD resource. Used to identify the disk in AWS
+	PDName string `json:"pdName" description:"unique id of the PD resource in AWS"`
+	// Required: Filesystem type to mount.
+	// Must be a filesystem type supported by the host operating system.
+	// Ex. "ext4", "xfs", "ntfs"
+	// TODO: how do we prevent errors in the filesystem from compromising the machine
+	// TODO: why omitempty if required?
+	FSType string `json:"fsType,omitempty" description:"file system type to mount, such as ext4, xfs, ntfs"`
+	// Optional: Partition on the disk to mount.
+	// If omitted, kubelet will attempt to mount the device name.
+	// Ex. For /dev/sda1, this field is "1", for /dev/sda, this field 0 or empty.
+	Partition int `json:"partition,omitempty" description:"partition on the disk to mount (e.g., '1' for /dev/sda1); if omitted the plain device name (e.g., /dev/sda) will be mounted"`
+	// Optional: Defaults to false (read/write). ReadOnly here will force
+	// the ReadOnly setting in VolumeMounts.
+	ReadOnly bool `json:"readOnly,omitempty" description:"read-only if true, read-write otherwise (false or unspecified)"`
+}
+
 // GitRepoVolumeSource represents a volume that is pulled from git when the pod is created.
 type GitRepoVolumeSource struct {
 	// Repository URL

pkg/api/v1beta2/conversion.go

@@ -1097,6 +1097,9 @@ func init() {
 			if err := s.Convert(&in.GCEPersistentDisk, &out.GCEPersistentDisk, 0); err != nil {
 				return err
 			}
+			if err := s.Convert(&in.AWSPersistentDisk, &out.AWSPersistentDisk, 0); err != nil {
+				return err
+			}
 			if err := s.Convert(&in.HostPath, &out.HostDir, 0); err != nil {
 				return err
 			}

pkg/api/v1beta2/types.go

@@ -55,7 +55,7 @@ type Volume struct {
 	// Source represents the location and type of a volume to mount.
 	// This is optional for now. If not specified, the Volume is implied to be an EmptyDir.
 	// This implied behavior is deprecated and will be removed in a future version.
-	Source VolumeSource `json:"source,omitempty" description:"location and type of volume to mount; at most one of HostDir, EmptyDir, GCEPersistentDisk, or GitRepo; default is EmptyDir"`
+	Source VolumeSource `json:"source,omitempty" description:"location and type of volume to mount; at most one of HostDir, EmptyDir, GCEPersistentDisk, AWSPersistentDisk, or GitRepo; default is EmptyDir"`
 }
 
 // VolumeSource represents the source location of a volume to mount.
@@ -74,6 +74,9 @@ type VolumeSource struct {
 	// A persistent disk that is mounted to the
 	// kubelet's host machine and then exposed to the pod.
 	GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"persistentDisk" description:"GCE disk resource attached to the host machine on demand"`
+	// An AWS persistent disk that is mounted to the
+	// kubelet's host machine and then exposed to the pod.
+	AWSPersistentDisk *AWSPersistentDiskVolumeSource `json:"awsPersistentDisk" description:"AWS disk resource attached to the host machine on demand"`
 	// GitRepo represents a git repository at a particular revision.
 	GitRepo *GitRepoVolumeSource `json:"gitRepo" description:"git repository at a particular revision"`
 	// Secret is a secret to populate the volume with
@@ -93,6 +96,9 @@ type PersistentVolumeSource struct {
 	// GCEPersistentDisk represents a GCE Disk resource that is attached to a
 	// kubelet's host machine and then exposed to the pod.
 	GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"persistentDisk" description:"GCE disk resource provisioned by an admin"`
+	// AWSPersistentDisk represents a AWS Disk resource that is attached to a
+	// kubelet's host machine and then exposed to the pod.
+	AWSPersistentDisk *AWSPersistentDiskVolumeSource `json:"awsPersistentDisk" description:"AWS disk resource provisioned by an admin"`
 	// HostPath represents a directory on the host.
 	// This is useful for development and testing only.
 	// on-host storage is not supported in any way.
@@ -284,6 +290,29 @@ type GCEPersistentDiskVolumeSource struct {
 	ReadOnly bool `json:"readOnly,omitempty" description:"read-only if true, read-write otherwise (false or unspecified)"`
 }
 
+// AWSPersistentDiskVolumeSource represents a Persistent Disk resource in AWS.
+//
+// An AWS PD must exist and be formatted before mounting to a container.
+// The disk must also be in the same AWS zone as the kubelet.
+// A AWS PD can only be mounted on a single machine.
+type AWSPersistentDiskVolumeSource struct {
+	// Unique name of the PD resource. Used to identify the disk in AWS
+	PDName string `json:"pdName" description:"unique id of the PD resource in AWS"`
+	// Required: Filesystem type to mount.
+	// Must be a filesystem type supported by the host operating system.
+	// Ex. "ext4", "xfs", "ntfs"
+	// TODO: how do we prevent errors in the filesystem from compromising the machine
+	// TODO: why omitempty if required?
+	FSType string `json:"fsType,omitempty" description:"file system type to mount, such as ext4, xfs, ntfs"`
+	// Optional: Partition on the disk to mount.
+	// If omitted, kubelet will attempt to mount the device name.
+	// Ex. For /dev/sda1, this field is "1", for /dev/sda, this field 0 or empty.
+	Partition int `json:"partition,omitempty" description:"partition on the disk to mount (e.g., '1' for /dev/sda1); if omitted the plain device name (e.g., /dev/sda) will be mounted"`
+	// Optional: Defaults to false (read/write). ReadOnly here will force
+	// the ReadOnly setting in VolumeMounts.
+	ReadOnly bool `json:"readOnly,omitempty" description:"read-only if true, read-write otherwise (false or unspecified)"`
+}
+
 // GitRepoVolumeSource represents a volume that is pulled from git when the pod is created.
 type GitRepoVolumeSource struct {
 	// Repository URL

pkg/api/v1beta3/types.go

@@ -206,6 +206,9 @@ type VolumeSource struct {
 	// GCEPersistentDisk represents a GCE Disk resource that is attached to a
 	// kubelet's host machine and then exposed to the pod.
 	GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"gcePersistentDisk" description:"GCE disk resource attached to the host machine on demand"`
+	// AWSPersistentDisk represents a AWS Disk resource that is attached to a
+	// kubelet's host machine and then exposed to the pod.
+	AWSPersistentDisk *AWSPersistentDiskVolumeSource `json:"awsPersistentDisk" description:"AWS disk resource attached to the host machine on demand"`
 	// GitRepo represents a git repository at a particular revision.
 	GitRepo *GitRepoVolumeSource `json:"gitRepo" description:"git repository at a particular revision"`
 	// Secret represents a secret that should populate this volume.
@@ -225,6 +228,9 @@ type PersistentVolumeSource struct {
 	// GCEPersistentDisk represents a GCE Disk resource that is attached to a
 	// kubelet's host machine and then exposed to the pod.
 	GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"gcePersistentDisk" description:"GCE disk resource provisioned by an admin"`
+	// AWSPersistentDisk represents a AWS Disk resource that is attached to a
+	// kubelet's host machine and then exposed to the pod.
+	AWSPersistentDisk *AWSPersistentDiskVolumeSource `json:"awsPersistentDisk" description:"AWS disk resource provisioned by an admin"`
 	// HostPath represents a directory on the host.
 	// This is useful for development and testing only.
 	// on-host storage is not supported in any way.
@@ -400,6 +406,29 @@ type GCEPersistentDiskVolumeSource struct {
 	ReadOnly bool `json:"readOnly,omitempty" description:"read-only if true, read-write otherwise (false or unspecified)"`
 }
 
+// AWSPersistentDiskVolumeSource represents a Persistent Disk resource in AWS.
+//
+// An AWS PD must exist and be formatted before mounting to a container.
+// The disk must also be in the same AWS zone as the kubelet.
+// A AWS PD can only be mounted on a single machine.
+type AWSPersistentDiskVolumeSource struct {
+	// Unique name of the PD resource. Used to identify the disk in AWS
+	PDName string `json:"pdName" description:"unique id of the PD resource in AWS"`
+	// Required: Filesystem type to mount.
+	// Must be a filesystem type supported by the host operating system.
+	// Ex. "ext4", "xfs", "ntfs"
+	// TODO: how do we prevent errors in the filesystem from compromising the machine
+	// TODO: why omitempty if required?
+	FSType string `json:"fsType,omitempty" description:"file system type to mount, such as ext4, xfs, ntfs"`
+	// Optional: Partition on the disk to mount.
+	// If omitted, kubelet will attempt to mount the device name.
+	// Ex. For /dev/sda1, this field is "1", for /dev/sda, this field 0 or empty.
+	Partition int `json:"partition,omitempty" description:"partition on the disk to mount (e.g., '1' for /dev/sda1); if omitted the plain device name (e.g., /dev/sda) will be mounted"`
+	// Optional: Defaults to false (read/write). ReadOnly here will force
+	// the ReadOnly setting in VolumeMounts.
+	ReadOnly bool `json:"readOnly,omitempty" description:"read-only if true, read-write otherwise (false or unspecified)"`
+}
+
 // GitRepoVolumeSource represents a volume that is pulled from git when the pod is created.
 type GitRepoVolumeSource struct {
 	// Repository URL

pkg/api/validation/validation.go

@@ -299,6 +299,10 @@ func validateSource(source *api.VolumeSource) errs.ValidationErrorList {
 		numVolumes++
 		allErrs = append(allErrs, validateGCEPersistentDiskVolumeSource(source.GCEPersistentDisk).Prefix("persistentDisk")...)
 	}
+	if source.AWSPersistentDisk != nil {
+		numVolumes++
+		allErrs = append(allErrs, validateAWSPersistentDiskVolumeSource(source.AWSPersistentDisk).Prefix("awsPersistentDisk")...)
+	}
 	if source.Secret != nil {
 		numVolumes++
 		allErrs = append(allErrs, validateSecretVolumeSource(source.Secret).Prefix("secret")...)
@@ -368,6 +372,20 @@ func validateGCEPersistentDiskVolumeSource(PD *api.GCEPersistentDiskVolumeSource
 	return allErrs
 }
 
+func validateAWSPersistentDiskVolumeSource(PD *api.AWSPersistentDiskVolumeSource) errs.ValidationErrorList {
+	allErrs := errs.ValidationErrorList{}
+	if PD.PDName == "" {
+		allErrs = append(allErrs, errs.NewFieldRequired("pdName"))
+	}
+	if PD.FSType == "" {
+		allErrs = append(allErrs, errs.NewFieldRequired("fsType"))
+	}
+	if PD.Partition < 0 || PD.Partition > 255 {
+		allErrs = append(allErrs, errs.NewFieldInvalid("partition", PD.Partition, pdPartitionErrorMsg))
+	}
+	return allErrs
+}
+
 func validateSecretVolumeSource(secretSource *api.SecretVolumeSource) errs.ValidationErrorList {
 	allErrs := errs.ValidationErrorList{}
 	if secretSource.SecretName == "" {
@@ -426,6 +444,10 @@ func ValidatePersistentVolume(pv *api.PersistentVolume) errs.ValidationErrorList
 		numVolumes++
 		allErrs = append(allErrs, validateGCEPersistentDiskVolumeSource(pv.Spec.GCEPersistentDisk).Prefix("persistentDisk")...)
 	}
+	if pv.Spec.AWSPersistentDisk != nil {
+		numVolumes++
+		allErrs = append(allErrs, validateAWSPersistentDiskVolumeSource(pv.Spec.AWSPersistentDisk).Prefix("awsPersistentDisk")...)
+	}
 	if numVolumes != 1 {
 		allErrs = append(allErrs, errs.NewFieldInvalid("", pv.Spec.PersistentVolumeSource, "exactly 1 volume type is required"))
 	}
@@ -1021,6 +1043,7 @@ func ValidateReadOnlyPersistentDisks(volumes []api.Volume) errs.ValidationErrorL
 				allErrs = append(allErrs, errs.NewFieldInvalid("GCEPersistentDisk.ReadOnly", false, "ReadOnly must be true for replicated pods > 1, as GCE PD can only be mounted on multiple machines if it is read-only."))
 			}
 		}
+		// TODO: What to do for AWS?  It doesn't support replicas
 	}
 	return allErrs
 }

pkg/api/validation/validation_test.go

@@ -516,6 +516,7 @@ func TestValidateVolumes(t *testing.T) {
 		{Name: "abc-123", VolumeSource: api.VolumeSource{HostPath: &api.HostPathVolumeSource{"/mnt/path3"}}},
 		{Name: "empty", VolumeSource: api.VolumeSource{EmptyDir: &api.EmptyDirVolumeSource{}}},
 		{Name: "gcepd", VolumeSource: api.VolumeSource{GCEPersistentDisk: &api.GCEPersistentDiskVolumeSource{"my-PD", "ext4", 1, false}}},
+		{Name: "awspd", VolumeSource: api.VolumeSource{AWSPersistentDisk: &api.AWSPersistentDiskVolumeSource{"my-PD", "ext4", 1, false}}},
 		{Name: "gitrepo", VolumeSource: api.VolumeSource{GitRepo: &api.GitRepoVolumeSource{"my-repo", "hashstring"}}},
 		{Name: "iscsidisk", VolumeSource: api.VolumeSource{ISCSI: &api.ISCSIVolumeSource{"127.0.0.1", "iqn.2015-02.example.com:test", 1, "ext4", false}}},
 		{Name: "secret", VolumeSource: api.VolumeSource{Secret: &api.SecretVolumeSource{"my-secret"}}},

pkg/scheduler/predicates.go

@@ -50,16 +50,26 @@ func (nodes ClientNodeInfo) GetNodeInfo(nodeID string) (*api.Node, error) {
 }
 
 func isVolumeConflict(volume api.Volume, pod *api.Pod) bool {
-	if volume.GCEPersistentDisk == nil {
-		return false
+	if volume.GCEPersistentDisk != nil {
+		pdName := volume.GCEPersistentDisk.PDName
+
+		manifest := &(pod.Spec)
+		for ix := range manifest.Volumes {
+			if manifest.Volumes[ix].GCEPersistentDisk != nil &&
+				manifest.Volumes[ix].GCEPersistentDisk.PDName == pdName {
+				return true
+			}
+		}
 	}
-	pdName := volume.GCEPersistentDisk.PDName
-
-	manifest := &(pod.Spec)
-	for ix := range manifest.Volumes {
-		if manifest.Volumes[ix].GCEPersistentDisk != nil &&
-			manifest.Volumes[ix].GCEPersistentDisk.PDName == pdName {
-			return true
+	if volume.AWSPersistentDisk != nil {
+		pdName := volume.AWSPersistentDisk.PDName
+
+		manifest := &(pod.Spec)
+		for ix := range manifest.Volumes {
+			if manifest.Volumes[ix].AWSPersistentDisk != nil &&
+				manifest.Volumes[ix].AWSPersistentDisk.PDName == pdName {
+				return true
+			}
 		}
 	}
 	return false

pkg/scheduler/predicates_test.go

@@ -321,6 +321,55 @@ func TestDiskConflicts(t *testing.T) {
 	}
 }
 
+func TestAWSDiskConflicts(t *testing.T) {
+	volState := api.PodSpec{
+		Volumes: []api.Volume{
+			{
+				VolumeSource: api.VolumeSource{
+					AWSPersistentDisk: &api.AWSPersistentDiskVolumeSource{
+						PDName: "foo",
+					},
+				},
+			},
+		},
+	}
+	volState2 := api.PodSpec{
+		Volumes: []api.Volume{
+			{
+				VolumeSource: api.VolumeSource{
+					AWSPersistentDisk: &api.AWSPersistentDiskVolumeSource{
+						PDName: "bar",
+					},
+				},
+			},
+		},
+	}
+	tests := []struct {
+		pod          api.Pod
+		existingPods []api.Pod
+		isOk         bool
+		test         string
+	}{
+		{api.Pod{}, []api.Pod{}, true, "nothing"},
+		{api.Pod{}, []api.Pod{{Spec: volState}}, true, "one state"},
+		{api.Pod{Spec: volState}, []api.Pod{{Spec: volState}}, false, "same state"},
+		{api.Pod{Spec: volState2}, []api.Pod{{Spec: volState}}, true, "different state"},
+	}
+
+	for _, test := range tests {
+		ok, err := NoDiskConflict(test.pod, test.existingPods, "machine")
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if test.isOk && !ok {
+			t.Errorf("expected ok, got none.  %v %v %s", test.pod, test.existingPods, test.test)
+		}
+		if !test.isOk && ok {
+			t.Errorf("expected no ok, got one.  %v %v %s", test.pod, test.existingPods, test.test)
+		}
+	}
+}
+
 func TestPodFitsSelector(t *testing.T) {
 	tests := []struct {
 		pod    api.Pod

pkg/volume/aws_pd/aws_pd.go

+/*
+Copyright 2014 Google Inc. 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.
+*/
+
+package aws_pd
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"strconv"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider/aws"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/types"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/exec"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/mount"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/volume"
+	"github.com/golang/glog"
+)
+
+// This is the primary entrypoint for volume plugins.
+func ProbeVolumePlugins() []volume.VolumePlugin {
+	return []volume.VolumePlugin{&awsPersistentDiskPlugin{nil}}
+}
+
+type awsPersistentDiskPlugin struct {
+	host volume.VolumeHost
+}
+
+var _ volume.VolumePlugin = &awsPersistentDiskPlugin{}
+
+const (
+	awsPersistentDiskPluginName = "kubernetes.io/aws-pd"
+)
+
+func (plugin *awsPersistentDiskPlugin) Init(host volume.VolumeHost) {
+	plugin.host = host
+}
+
+func (plugin *awsPersistentDiskPlugin) Name() string {
+	return awsPersistentDiskPluginName
+}
+
+func (plugin *awsPersistentDiskPlugin) CanSupport(spec *api.Volume) bool {
+	if spec.AWSPersistentDisk != nil {
+		return true
+	}
+	return false
+}
+
+func (plugin *awsPersistentDiskPlugin) GetAccessModes() []api.AccessModeType {
+	return []api.AccessModeType{
+		api.ReadWriteOnce,
+	}
+}
+
+func (plugin *awsPersistentDiskPlugin) NewBuilder(spec *api.Volume, podRef *api.ObjectReference) (volume.Builder, error) {
+	// Inject real implementations here, test through the internal function.
+	return plugin.newBuilderInternal(spec, podRef.UID, &AWSDiskUtil{}, mount.New())
+}
+
+func (plugin *awsPersistentDiskPlugin) newBuilderInternal(spec *api.Volume, podUID types.UID, manager pdManager, mounter mount.Interface) (volume.Builder, error) {
+	pdName := spec.AWSPersistentDisk.PDName
+	fsType := spec.AWSPersistentDisk.FSType
+	partition := ""
+	if spec.AWSPersistentDisk.Partition != 0 {
+		partition = strconv.Itoa(spec.AWSPersistentDisk.Partition)
+	}
+	readOnly := spec.AWSPersistentDisk.ReadOnly
+
+	return &awsPersistentDisk{
+		podUID:      podUID,
+		volName:     spec.Name,
+		pdName:      pdName,
+		fsType:      fsType,
+		partition:   partition,
+		readOnly:    readOnly,
+		manager:     manager,
+		mounter:     mounter,
+		diskMounter: &awsSafeFormatAndMount{mounter, exec.New()},
+		plugin:      plugin,
+	}, nil
+}
+
+func (plugin *awsPersistentDiskPlugin) NewCleaner(volName string, podUID types.UID) (volume.Cleaner, error) {
+	// Inject real implementations here, test through the internal function.
+	return plugin.newCleanerInternal(volName, podUID, &AWSDiskUtil{}, mount.New())
+}
+
+func (plugin *awsPersistentDiskPlugin) newCleanerInternal(volName string, podUID types.UID, manager pdManager, mounter mount.Interface) (volume.Cleaner, error) {
+	return &awsPersistentDisk{
+		podUID:      podUID,
+		volName:     volName,
+		manager:     manager,
+		mounter:     mounter,
+		diskMounter: &awsSafeFormatAndMount{mounter, exec.New()},
+		plugin:      plugin,
+	}, nil
+}
+
+// Abstract interface to PD operations.
+type pdManager interface {
+	// Attaches the disk to the kubelet's host machine.
+	AttachAndMountDisk(pd *awsPersistentDisk, globalPDPath string) error
+	// Detaches the disk from the kubelet's host machine.
+	DetachDisk(pd *awsPersistentDisk) error
+}
+
+// awsPersistentDisk volumes are disk resources provided by Google Compute Engine
+// that are attached to the kubelet's host machine and exposed to the pod.
+type awsPersistentDisk struct {
+	volName string
+	podUID  types.UID
+	// Unique name of the PD, used to find the disk resource in the provider.
+	pdName string
+	// Filesystem type, optional.
+	fsType string
+	// Specifies the partition to mount
+	partition string
+	// Specifies whether the disk will be attached as read-only.
+	readOnly bool
+	// Utility interface that provides API calls to the provider to attach/detach disks.
+	manager pdManager
+	// Mounter interface that provides system calls to mount the global path to the pod local path.
+	mounter mount.Interface
+	// diskMounter provides the interface that is used to mount the actual block device.
+	diskMounter mount.Interface
+	plugin      *awsPersistentDiskPlugin
+}
+
+func detachDiskLogError(pd *awsPersistentDisk) {
+	err := pd.manager.DetachDisk(pd)
+	if err != nil {
+		glog.Warningf("Failed to detach disk: %v (%v)", pd, err)
+	}
+}
+
+// getVolumeProvider returns the AWS Volumes interface
+func (pd *awsPersistentDisk) getVolumeProvider() (aws_cloud.Volumes, error) {
+	name := "aws"
+	cloud, err := cloudprovider.GetCloudProvider(name, nil)
+	if err != nil {
+		return nil, err
+	}
+	volumes, ok := cloud.(aws_cloud.Volumes)
+	if !ok {
+		return nil, fmt.Errorf("Cloud provider does not support volumes")
+	}
+	return volumes, nil
+}
+
+// SetUp attaches the disk and bind mounts to the volume path.
+func (pd *awsPersistentDisk) SetUp() error {
+	return pd.SetUpAt(pd.GetPath())
+}
+
+// SetUpAt attaches the disk and bind mounts to the volume path.
+func (pd *awsPersistentDisk) SetUpAt(dir string) error {
+	// TODO: handle failed mounts here.
+	mountpoint, err := mount.IsMountPoint(dir)
+	glog.V(4).Infof("PersistentDisk set up: %s %v %v", dir, mountpoint, err)
+	if err != nil && !os.IsNotExist(err) {
+		return err
+	}
+	if mountpoint {
+		return nil
+	}
+
+	globalPDPath := makeGlobalPDName(pd.plugin.host, pd.pdName)
+	if err := pd.manager.AttachAndMountDisk(pd, globalPDPath); err != nil {
+		return err
+	}
+
+	flags := uintptr(0)
+	if pd.readOnly {
+		flags = mount.FlagReadOnly
+	}
+
+	if err := os.MkdirAll(dir, 0750); err != nil {
+		// TODO: we should really eject the attach/detach out into its own control loop.
+		detachDiskLogError(pd)
+		return err
+	}
+
+	// Perform a bind mount to the full path to allow duplicate mounts of the same PD.
+	err = pd.mounter.Mount(globalPDPath, dir, "", mount.FlagBind|flags, "")
+	if err != nil {
+		mountpoint, mntErr := mount.IsMountPoint(dir)
+		if mntErr != nil {
+			glog.Errorf("isMountpoint check failed: %v", mntErr)
+			return err
+		}
+		if mountpoint {
+			if mntErr = pd.mounter.Unmount(dir, 0); mntErr != nil {
+				glog.Errorf("Failed to unmount: %v", mntErr)
+				return err
+			}
+			mountpoint, mntErr := mount.IsMountPoint(dir)
+			if mntErr != nil {
+				glog.Errorf("isMountpoint check failed: %v", mntErr)
+				return err
+			}
+			if mountpoint {
+				// This is very odd, we don't expect it.  We'll try again next sync loop.
+				glog.Errorf("%s is still mounted, despite call to unmount().  Will try again next sync loop.", dir)
+				return err
+			}
+		}
+		os.Remove(dir)
+		// TODO: we should really eject the attach/detach out into its own control loop.
+		detachDiskLogError(pd)
+		return err
+	}
+
+	return nil
+}
+
+func makeGlobalPDName(host volume.VolumeHost, devName string) string {
+	return path.Join(host.GetPluginDir(awsPersistentDiskPluginName), "mounts", devName)
+}
+
+func (pd *awsPersistentDisk) GetPath() string {
+	name := awsPersistentDiskPluginName
+	return pd.plugin.host.GetPodVolumeDir(pd.podUID, util.EscapeQualifiedNameForDisk(name), pd.volName)
+}
+
+// Unmounts the bind mount, and detaches the disk only if the PD
+// resource was the last reference to that disk on the kubelet.
+func (pd *awsPersistentDisk) TearDown() error {
+	return pd.TearDownAt(pd.GetPath())
+}
+
+// Unmounts the bind mount, and detaches the disk only if the PD
+// resource was the last reference to that disk on the kubelet.
+func (pd *awsPersistentDisk) TearDownAt(dir string) error {
+	mountpoint, err := mount.IsMountPoint(dir)
+	if err != nil {
+		return err
+	}
+	if !mountpoint {
+		return os.Remove(dir)
+	}
+
+	refs, err := mount.GetMountRefs(pd.mounter, dir)
+	if err != nil {
+		return err
+	}
+	// Unmount the bind-mount inside this pod
+	if err := pd.mounter.Unmount(dir, 0); err != nil {
+		return err
+	}
+	// If len(refs) is 1, then all bind mounts have been removed, and the
+	// remaining reference is the global mount. It is safe to detach.
+	if len(refs) == 1 {
+		// pd.pdName is not initially set for volume-cleaners, so set it here.
+		pd.pdName = path.Base(refs[0])
+		if err := pd.manager.DetachDisk(pd); err != nil {
+			return err
+		}
+	}
+	mountpoint, mntErr := mount.IsMountPoint(dir)
+	if mntErr != nil {
+		glog.Errorf("isMountpoint check failed: %v", mntErr)
+		return err
+	}
+	if !mountpoint {
+		if err := os.Remove(dir); err != nil {
+			return err
+		}
+	}
+	return nil
+}

pkg/volume/aws_pd/aws_pd_test.go

+/*
+Copyright 2014 Google Inc. 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.
+*/
+
+package aws_pd
+
+import (
+	"os"
+	"testing"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/types"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/mount"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/volume"
+)
+
+func TestCanSupport(t *testing.T) {
+	plugMgr := volume.VolumePluginMgr{}
+	plugMgr.InitPlugins(ProbeVolumePlugins(), volume.NewFakeVolumeHost("/tmp/fake", nil, nil))
+
+	plug, err := plugMgr.FindPluginByName("kubernetes.io/aws-pd")
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	if plug.Name() != "kubernetes.io/aws-pd" {
+		t.Errorf("Wrong name: %s", plug.Name())
+	}
+	if !plug.CanSupport(&api.Volume{VolumeSource: api.VolumeSource{AWSPersistentDisk: &api.AWSPersistentDiskVolumeSource{}}}) {
+		t.Errorf("Expected true")
+	}
+}
+
+func TestGetAccessModes(t *testing.T) {
+	plugMgr := volume.VolumePluginMgr{}
+	plugMgr.InitPlugins(ProbeVolumePlugins(), volume.NewFakeVolumeHost("/tmp/fake", nil, nil))
+
+	plug, err := plugMgr.FindPersistentPluginByName("kubernetes.io/aws-pd")
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	if !contains(plug.GetAccessModes(), api.ReadWriteOnce) || !contains(plug.GetAccessModes(), api.ReadOnlyMany) {
+		t.Errorf("Expected two AccessModeTypes:  %s and %s", api.ReadWriteOnce, api.ReadOnlyMany)
+	}
+}
+
+func contains(modes []api.AccessModeType, mode api.AccessModeType) bool {
+	for _, m := range modes {
+		if m == mode {
+			return true
+		}
+	}
+	return false
+}
+
+type fakePDManager struct{}
+
+// TODO(jonesdl) To fully test this, we could create a loopback device
+// and mount that instead.
+func (fake *fakePDManager) AttachAndMountDisk(pd *awsPersistentDisk, globalPDPath string) error {
+	globalPath := makeGlobalPDName(pd.plugin.host, pd.pdName)
+	err := os.MkdirAll(globalPath, 0750)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (fake *fakePDManager) DetachDisk(pd *awsPersistentDisk) error {
+	globalPath := makeGlobalPDName(pd.plugin.host, pd.pdName)
+	err := os.RemoveAll(globalPath)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func TestPlugin(t *testing.T) {
+	plugMgr := volume.VolumePluginMgr{}
+	plugMgr.InitPlugins(ProbeVolumePlugins(), volume.NewFakeVolumeHost("/tmp/fake", nil, nil))
+
+	plug, err := plugMgr.FindPluginByName("kubernetes.io/aws-pd")
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	spec := &api.Volume{
+		Name: "vol1",
+		VolumeSource: api.VolumeSource{
+			AWSPersistentDisk: &api.AWSPersistentDiskVolumeSource{
+				PDName: "pd",
+				FSType: "ext4",
+			},
+		},
+	}
+	builder, err := plug.(*awsPersistentDiskPlugin).newBuilderInternal(spec, types.UID("poduid"), &fakePDManager{}, &mount.FakeMounter{})
+	if err != nil {
+		t.Errorf("Failed to make a new Builder: %v", err)
+	}
+	if builder == nil {
+		t.Errorf("Got a nil Builder: %v")
+	}
+
+	path := builder.GetPath()
+	if path != "/tmp/fake/pods/poduid/volumes/kubernetes.io~aws-pd/vol1" {
+		t.Errorf("Got unexpected path: %s", path)
+	}
+
+	if err := builder.SetUp(); 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)
+		}
+	}
+
+	cleaner, err := plug.(*awsPersistentDiskPlugin).newCleanerInternal("vol1", types.UID("poduid"), &fakePDManager{}, &mount.FakeMounter{})
+	if err != nil {
+		t.Errorf("Failed to make a new Cleaner: %v", err)
+	}
+	if cleaner == nil {
+		t.Errorf("Got a nil Cleaner: %v")
+	}
+
+	if err := cleaner.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)
+	}
+}

pkg/volume/aws_pd/aws_util.go

+/*
+Copyright 2014 Google Inc. 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.
+*/
+
+package aws_pd
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"time"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/exec"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/mount"
+	"github.com/golang/glog"
+)
+
+type AWSDiskUtil struct{}
+
+// Attaches a disk specified by a volume.AWSPersistentDisk to the current kubelet.
+// Mounts the disk to it's global path.
+func (util *AWSDiskUtil) AttachAndMountDisk(pd *awsPersistentDisk, globalPDPath string) error {
+	volumes, err := pd.getVolumeProvider()
+	if err != nil {
+		return err
+	}
+	flags := uintptr(0)
+	if pd.readOnly {
+		flags = mount.FlagReadOnly
+	}
+	if err := volumes.AttachDisk("", pd.pdName, pd.readOnly); err != nil {
+		return err
+	}
+	devicePath := path.Join("/dev/disk/by-id/", "aws-"+pd.pdName)
+	if pd.partition != "" {
+		devicePath = devicePath + "-part" + pd.partition
+	}
+	//TODO(jonesdl) There should probably be better method than busy-waiting here.
+	numTries := 0
+	for {
+		_, err := os.Stat(devicePath)
+		if err == nil {
+			break
+		}
+		if err != nil && !os.IsNotExist(err) {
+			return err
+		}
+		numTries++
+		if numTries == 10 {
+			return errors.New("Could not attach disk: Timeout after 10s")
+		}
+		time.Sleep(time.Second)
+	}
+
+	// Only mount the PD globally once.
+	mountpoint, err := mount.IsMountPoint(globalPDPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			if err := os.MkdirAll(globalPDPath, 0750); err != nil {
+				return err
+			}
+			mountpoint = false
+		} else {
+			return err
+		}
+	}
+	if !mountpoint {
+		err = pd.diskMounter.Mount(devicePath, globalPDPath, pd.fsType, flags, "")
+		if err != nil {
+			os.Remove(globalPDPath)
+			return err
+		}
+	}
+	return nil
+}
+
+// Unmounts the device and detaches the disk from the kubelet's host machine.
+func (util *AWSDiskUtil) DetachDisk(pd *awsPersistentDisk) error {
+	// Unmount the global PD mount, which should be the only one.
+	globalPDPath := makeGlobalPDName(pd.plugin.host, pd.pdName)
+	if err := pd.mounter.Unmount(globalPDPath, 0); err != nil {
+		return err
+	}
+	if err := os.Remove(globalPDPath); err != nil {
+		return err
+	}
+	// Detach the disk
+	volumes, err := pd.getVolumeProvider()
+	if err != nil {
+		return err
+	}
+	if err := volumes.DetachDisk("", pd.pdName); err != nil {
+		return err
+	}
+	return nil
+}
+
+// safe_format_and_mount is a utility script on AWS VMs that probes a persistent disk, and if
+// necessary formats it before mounting it.
+// This eliminates the necesisty to format a PD before it is used with a Pod on AWS.
+// TODO: port this script into Go and use it for all Linux platforms
+type awsSafeFormatAndMount struct {
+	mount.Interface
+	runner exec.Interface
+}
+
+// uses /usr/share/google/safe_format_and_mount to optionally mount, and format a disk
+func (mounter *awsSafeFormatAndMount) Mount(source string, target string, fstype string, flags uintptr, data string) error {
+	// Don't attempt to format if mounting as readonly. Go straight to mounting.
+	if (flags & mount.FlagReadOnly) != 0 {
+		return mounter.Interface.Mount(source, target, fstype, flags, data)
+	}
+	args := []string{}
+	// ext4 is the default for safe_format_and_mount
+	if len(fstype) > 0 && fstype != "ext4" {
+		args = append(args, "-m", fmt.Sprintf("mkfs.%s", fstype))
+	}
+	args = append(args, source, target)
+	// TODO: Accept other options here?
+	glog.V(5).Infof("exec-ing: /usr/share/google/safe_format_and_mount %v", args)
+	cmd := mounter.runner.Command("/usr/share/google/safe_format_and_mount", args...)
+	dataOut, err := cmd.CombinedOutput()
+	if err != nil {
+		glog.V(5).Infof("error running /usr/share/google/safe_format_and_mount\n%s", string(dataOut))
+	}
+	return err
+}

pkg/volume/aws_pd/aws_util_test.go

+/*
+Copyright 2014 Google Inc. 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.
+*/
+
+package aws_pd
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/exec"
+)
+
+func TestSafeFormatAndMount(t *testing.T) {
+	tests := []struct {
+		fstype       string
+		expectedArgs []string
+		err          error
+	}{
+		{
+			fstype:       "ext4",
+			expectedArgs: []string{"/dev/foo", "/mnt/bar"},
+		},
+		{
+			fstype:       "vfat",
+			expectedArgs: []string{"-m", "mkfs.vfat", "/dev/foo", "/mnt/bar"},
+		},
+		{
+			err: fmt.Errorf("test error"),
+		},
+	}
+	for _, test := range tests {
+
+		var cmdOut string
+		var argsOut []string
+		fake := exec.FakeExec{
+			CommandScript: []exec.FakeCommandAction{
+				func(cmd string, args ...string) exec.Cmd {
+					cmdOut = cmd
+					argsOut = args
+					fake := exec.FakeCmd{
+						CombinedOutputScript: []exec.FakeCombinedOutputAction{
+							func() ([]byte, error) { return []byte{}, test.err },
+						},
+					}
+					return exec.InitFakeCmd(&fake, cmd, args...)
+				},
+			},
+		}
+
+		mounter := awsSafeFormatAndMount{
+			runner: &fake,
+		}
+
+		err := mounter.Mount("/dev/foo", "/mnt/bar", test.fstype, 0, "")
+		if test.err == nil && err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if test.err != nil {
+			if err == nil {
+				t.Errorf("unexpected non-error")
+			}
+			return
+		}
+		if cmdOut != "/usr/share/google/safe_format_and_mount" {
+			t.Errorf("unexpected command: %s", cmdOut)
+		}
+		if len(argsOut) != len(test.expectedArgs) {
+			t.Errorf("unexpected args: %v, expected: %v", argsOut, test.expectedArgs)
+		}
+	}
+}

test/e2e/driver.go

@@ -25,6 +25,7 @@ import (
 	"strings"
 	"syscall"
 
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 	"github.com/golang/glog"
 	"github.com/onsi/ginkgo"
@@ -35,10 +36,12 @@ import (
 
 type testResult bool
 
-type GCEConfig struct {
+type CloudConfig struct {
 	ProjectID  string
 	Zone       string
 	MasterName string
+
+	Provider cloudprovider.Interface
 }
 
 func init() {

test/e2e/pd.go

@@ -24,6 +24,7 @@ import (
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/client"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider/aws"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/fields"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
@@ -35,7 +36,6 @@ var _ = Describe("PD", func() {
 	var (
 		c         *client.Client
 		podClient client.PodInterface
-		diskName  string
 		host0Name string
 		host1Name string
 	)
@@ -51,37 +51,37 @@ var _ = Describe("PD", func() {
 		expectNoError(err, "Failed to list nodes for e2e cluster.")
 		Expect(len(nodes.Items) >= 2).To(BeTrue())
 
-		diskName = fmt.Sprintf("e2e-%s", string(util.NewUUID()))
 		host0Name = nodes.Items[0].ObjectMeta.Name
 		host1Name = nodes.Items[1].ObjectMeta.Name
 	})
 
 	It("should schedule a pod w/ a RW PD, remove it, then schedule it on another host", func() {
-		if testContext.Provider != "gce" {
-			By(fmt.Sprintf("Skipping PD test, which is only supported for provider gce (not %s)",
-				testContext.Provider))
+		if testContext.provider != "gce" && testContext.provider != "aws" {
+			By(fmt.Sprintf("Skipping PD test, which is only supported for providers gce & aws (not %s)",
+				testContext.provider))
 			return
 		}
 
+		By("creating PD")
+		diskName, err := createPD()
+		expectNoError(err, "Error creating PD")
+
 		host0Pod := testPDPod(diskName, host0Name, false)
 		host1Pod := testPDPod(diskName, host1Name, false)
 
-		By(fmt.Sprintf("creating PD %q", diskName))
-		expectNoError(createPD(diskName, testContext.GCEConfig.Zone), "Error creating PD")
-
 		defer func() {
 			By("cleaning up PD-RW test environment")
 			// Teardown pods, PD. Ignore errors.
 			// Teardown should do nothing unless test failed.
 			podClient.Delete(host0Pod.Name)
 			podClient.Delete(host1Pod.Name)
-			detachPD(host0Name, diskName, testContext.GCEConfig.Zone)
-			detachPD(host1Name, diskName, testContext.GCEConfig.Zone)
-			deletePD(diskName, testContext.GCEConfig.Zone)
+			detachPD(host0Name, diskName)
+			detachPD(host1Name, diskName)
+			deletePD(diskName)
 		}()
 
 		By("submitting host0Pod to kubernetes")
-		_, err := podClient.Create(host0Pod)
+		_, err = podClient.Create(host0Pod)
 		expectNoError(err, fmt.Sprintf("Failed to create host0Pod: %v", err))
 
 		expectNoError(waitForPodRunning(c, host0Pod.Name))
@@ -100,7 +100,7 @@ var _ = Describe("PD", func() {
 
 		By(fmt.Sprintf("deleting PD %q", diskName))
 		for start := time.Now(); time.Since(start) < 180*time.Second; time.Sleep(5 * time.Second) {
-			if err = deletePD(diskName, testContext.GCEConfig.Zone); err != nil {
+			if err = deletePD(diskName); err != nil {
 				Logf("Couldn't delete PD. Sleeping 5 seconds")
 				continue
 			}
@@ -118,6 +118,10 @@ var _ = Describe("PD", func() {
 			return
 		}
 
+		By("creating PD")
+		diskName, err := createPD()
+		expectNoError(err, "Error creating PD")
+
 		rwPod := testPDPod(diskName, host0Name, false)
 		host0ROPod := testPDPod(diskName, host0Name, true)
 		host1ROPod := testPDPod(diskName, host1Name, true)
@@ -129,16 +133,14 @@ var _ = Describe("PD", func() {
 			podClient.Delete(rwPod.Name)
 			podClient.Delete(host0ROPod.Name)
 			podClient.Delete(host1ROPod.Name)
-			detachPD(host0Name, diskName, testContext.GCEConfig.Zone)
-			detachPD(host1Name, diskName, testContext.GCEConfig.Zone)
-			deletePD(diskName, testContext.GCEConfig.Zone)
-		}()
 
-		By(fmt.Sprintf("creating PD %q", diskName))
-		expectNoError(createPD(diskName, testContext.GCEConfig.Zone), "Error creating PD")
+			detachPD(host0Name, diskName)
+			detachPD(host1Name, diskName)
+			deletePD(diskName)
+		}()
 
 		By("submitting rwPod to ensure PD is formatted")
-		_, err := podClient.Create(rwPod)
+		_, err = podClient.Create(rwPod)
 		expectNoError(err, "Failed to create rwPod")
 		expectNoError(waitForPodRunning(c, rwPod.Name))
 		expectNoError(podClient.Delete(rwPod.Name), "Failed to delete host0Pod")
@@ -163,7 +165,7 @@ var _ = Describe("PD", func() {
 
 		By(fmt.Sprintf("deleting PD %q", diskName))
 		for start := time.Now(); time.Since(start) < 180*time.Second; time.Sleep(5 * time.Second) {
-			if err = deletePD(diskName, testContext.GCEConfig.Zone); err != nil {
+			if err = deletePD(diskName); err != nil {
 				Logf("Couldn't delete PD. Sleeping 5 seconds")
 				continue
 			}
@@ -173,24 +175,70 @@ var _ = Describe("PD", func() {
 	})
 })
 
-func createPD(pdName, zone string) error {
-	// TODO: make this hit the compute API directly instread of shelling out to gcloud.
-	return exec.Command("gcloud", "compute", "disks", "create", "--zone="+zone, "--size=10GB", pdName).Run()
+func createPD() (string, error) {
+	if testContext.provider == "gce" {
+		pdName := fmt.Sprintf("e2e-%s", string(util.NewUUID()))
+
+		zone := testContext.cloudConfig.Zone
+		// TODO: make this hit the compute API directly instread of shelling out to gcloud.
+		err := exec.Command("gcloud", "compute", "disks", "create", "--zone="+zone, "--size=10GB", pdName).Run()
+		if err != nil {
+			return "", err
+		}
+		return pdName, nil
+	} else if testContext.provider == "aws" {
+		volumes, ok := testContext.cloudConfig.Provider.(aws_cloud.Volumes)
+		if !ok {
+			return "", fmt.Errorf("Provider does not implement volumes interface")
+		}
+		volumeOptions := &aws_cloud.VolumeOptions{}
+		volumeOptions.CapacityMB = 10 * 1024
+		volumeOptions.Zone = testContext.cloudConfig.Zone
+		return volumes.CreateVolume(volumeOptions)
+	} else {
+		return "", fmt.Errorf("Unsupported provider type")
+	}
 }
 
-func deletePD(pdName, zone string) error {
-	// TODO: make this hit the compute API directly.
-	return exec.Command("gcloud", "compute", "disks", "delete", "--zone="+zone, pdName).Run()
+func deletePD(pdName string) error {
+	if testContext.provider == "gce" {
+		zone := testContext.cloudConfig.Zone
+
+		// TODO: make this hit the compute API directly.
+		return exec.Command("gcloud", "compute", "disks", "delete", "--zone="+zone, pdName).Run()
+	} else if testContext.provider == "aws" {
+		volumes, ok := testContext.cloudConfig.Provider.(aws_cloud.Volumes)
+		if !ok {
+			return fmt.Errorf("Provider does not implement volumes interface")
+		}
+		return volumes.DeleteVolume(pdName)
+	} else {
+		return fmt.Errorf("Unsupported provider type")
+	}
 }
 
-func detachPD(hostName, pdName, zone string) error {
-	instanceName := strings.Split(hostName, ".")[0]
-	// TODO: make this hit the compute API directly.
-	return exec.Command("gcloud", "compute", "instances", "detach-disk", "--zone="+zone, "--disk="+pdName, instanceName).Run()
+func detachPD(hostName, pdName string) error {
+	if testContext.provider == "gce" {
+		instanceName := strings.Split(hostName, ".")[0]
+
+		zone := testContext.cloudConfig.Zone
+
+		// TODO: make this hit the compute API directly.
+		return exec.Command("gcloud", "compute", "instances", "detach-disk", "--zone="+zone, "--disk="+pdName, instanceName).Run()
+	} else if testContext.provider == "aws" {
+		volumes, ok := testContext.cloudConfig.Provider.(aws_cloud.Volumes)
+		if !ok {
+			return fmt.Errorf("Provider does not implement volumes interface")
+		}
+		return volumes.DetachDisk(hostName, pdName)
+	} else {
+		return fmt.Errorf("Unsupported provider type")
+	}
+
 }
 
 func testPDPod(diskName, targetHost string, readOnly bool) *api.Pod {
-	return &api.Pod{
+	pod := &api.Pod{
 		TypeMeta: api.TypeMeta{
 			Kind:       "Pod",
 			APIVersion: "v1beta1",
@@ -199,18 +247,6 @@ func testPDPod(diskName, targetHost string, readOnly bool) *api.Pod {
 			Name: "pd-test-" + string(util.NewUUID()),
 		},
 		Spec: api.PodSpec{
-			Volumes: []api.Volume{
-				{
-					Name: "testpd",
-					VolumeSource: api.VolumeSource{
-						GCEPersistentDisk: &api.GCEPersistentDiskVolumeSource{
-							PDName:   diskName,
-							FSType:   "ext4",
-							ReadOnly: readOnly,
-						},
-					},
-				},
-			},
 			Containers: []api.Container{
 				{
 					Name:  "testpd",
@@ -226,4 +262,36 @@ func testPDPod(diskName, targetHost string, readOnly bool) *api.Pod {
 			Host: targetHost,
 		},
 	}
+
+	if testContext.provider == "gce" {
+		pod.Spec.Volumes = []api.Volume{
+			{
+				Name: "testpd",
+				VolumeSource: api.VolumeSource{
+					GCEPersistentDisk: &api.GCEPersistentDiskVolumeSource{
+						PDName:   diskName,
+						FSType:   "ext4",
+						ReadOnly: readOnly,
+					},
+				},
+			},
+		}
+	} else if testContext.provider == "aws" {
+		pod.Spec.Volumes = []api.Volume{
+			{
+				Name: "testpd",
+				VolumeSource: api.VolumeSource{
+					AWSPersistentDisk: &api.AWSPersistentDiskVolumeSource{
+						PDName:   diskName,
+						FSType:   "ext4",
+						ReadOnly: readOnly,
+					},
+				},
+			},
+		}
+	} else {
+		panic("Unknown provider: " + testContext.provider)
+	}
+
+	return pod
 }