add volumes

glide.yaml

@@ -3,4 +3,4 @@ import:
 - package: github.com/hashicorp/terraform
   version: 0.10.0
 - package: github.com/sandwichcloud/deli-cli
-  version: 0.0.16
+  version: 0.0.17

sandwich/provider.go

@@ -45,6 +45,7 @@ func Provider() *schema.Provider {
 			"sandwich_keypair":      resourceKeypair(),
 			"sandwich_flavor":       resourceFlavor(),
 			"sandwich_instance":     resourceInstance(),
+			"sandwich_volume":       resourceVolume(),
 		},
 		ConfigureFunc: configureProvider,
 	}

sandwich/resource_sandwich_volume.go

@@ -0,0 +1,304 @@
+package sandwich
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/sandwichcloud/deli-cli/api"
+	"github.com/sandwichcloud/deli-cli/api/client"
+	"github.com/satori/go.uuid"
+)
+
+func resourceVolume() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceVolumeCreate,
+		Read:   resourceVolumeRead,
+		Update: resourceVolumeUpdate,
+		Delete: resourceVolumeDelete,
+
+		Timeouts: &schema.ResourceTimeout{
+			Create: schema.DefaultTimeout(10 * time.Minute),
+			Read:   schema.DefaultTimeout(10 * time.Minute),
+			Update: schema.DefaultTimeout(10 * time.Minute),
+			Delete: schema.DefaultTimeout(10 * time.Minute),
+		},
+
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"zone_id": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"size": {
+				Type:     schema.TypeInt,
+				Required: true,
+				ForceNew: false,
+			},
+			"cloned_from": {
+				Type:     schema.TypeString,
+				Required: false,
+				Optional: true,
+				ForceNew: false,
+			},
+			"attached_to": {
+				Type:     schema.TypeString,
+				Required: false,
+				Optional: true,
+				ForceNew: false,
+				Default:  uuid.UUID{}.String(),
+			},
+		},
+	}
+}
+
+func resourceVolumeCreate(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*Config)
+	volumeClient := config.SandwichClient.Volume()
+	name := d.Get("name").(string)
+	zoneID := d.Get("zone_id").(string)
+	size := d.Get("size").(int)
+	clonedFrom := d.Get("cloned_from").(string)
+
+	if len(clonedFrom) == 0 {
+		volume, err := volumeClient.Create(name, zoneID, size)
+		if err != nil {
+			return err
+		}
+		d.Partial(true)
+		d.SetId(volume.ID.String())
+		stateConf := &resource.StateChangeConf{
+			Pending:    []string{"ToCreate", "Creating"},
+			Target:     []string{"Created"},
+			Refresh:    VolumeStateRefreshFunc(volumeClient, volume.ID.String()),
+			Timeout:    d.Timeout(schema.TimeoutCreate),
+			Delay:      10 * time.Second,
+			MinTimeout: 3 * time.Second,
+		}
+		_, err = stateConf.WaitForState()
+		if err != nil {
+			return fmt.Errorf("Error waiting for volume (%s) to become ready: %s", volume.ID.String(), err)
+		}
+		d.Partial(false)
+	} else {
+		volume, err := volumeClient.Get(clonedFrom)
+		if err != nil {
+			return err
+		}
+		volume, err = volumeClient.ActionClone(volume.ID.String(), name)
+		if err != nil {
+			return err
+		}
+		d.Partial(true)
+		d.SetId(volume.ID.String())
+		stateConf := &resource.StateChangeConf{
+			Pending:    []string{"ToCreate", "Creating"},
+			Target:     []string{"Created"},
+			Refresh:    VolumeStateRefreshFunc(volumeClient, volume.ID.String()),
+			Timeout:    d.Timeout(schema.TimeoutCreate),
+			Delay:      10 * time.Second,
+			MinTimeout: 3 * time.Second,
+		}
+		_, err = stateConf.WaitForState()
+		if err != nil {
+			return fmt.Errorf("Error waiting for volume (%s) to become ready: %s", volume.ID.String(), err)
+		}
+		d.Partial(false)
+	}
+
+	return resourceVolumeUpdate(d, meta)
+}
+
+func resourceVolumeRead(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*Config)
+	volumeClient := config.SandwichClient.Volume()
+
+	volume, err := volumeClient.Get(d.Id())
+	if err != nil {
+		if apiError, ok := err.(api.APIErrorInterface); ok {
+			if apiError.IsNotFound() {
+				d.SetId("")
+				return nil
+			}
+		}
+		return err
+	}
+
+	d.Set("name", volume.Name)
+	d.Set("zone_id", volume.ZoneID)
+	d.Set("size", volume.Size)
+	d.Set("attached_to", volume.AttachedTo)
+
+	return nil
+}
+
+func resourceVolumeUpdate(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*Config)
+	volumeClient := config.SandwichClient.Volume()
+
+	size := d.Get("size").(int)
+	attachedToStr := d.Get("attached_to").(string)
+	attachedTo, err := uuid.FromString(attachedToStr)
+	if err != nil {
+		return err
+	}
+
+	volume, err := volumeClient.Get(d.Id())
+	if err != nil {
+		if apiError, ok := err.(api.APIErrorInterface); ok {
+			if apiError.IsNotFound() {
+				d.SetId("")
+				return nil
+			}
+		}
+		return err
+	}
+
+	if volume.AttachedTo != attachedTo {
+		err := volumeClient.ActionDetach(volume.ID.String())
+		if err != nil {
+			if apiError, ok := err.(api.APIError); ok {
+				if apiError.StatusCode != 409 {
+					return err
+				}
+			}
+		}
+
+		stateConf := &resource.StateChangeConf{
+			Pending:    []string{"DETACHING"},
+			Target:     []string{""},
+			Refresh:    VolumeTaskRefreshFunc(volumeClient, volume.ID.String()),
+			Timeout:    d.Timeout(schema.TimeoutCreate),
+			Delay:      10 * time.Second,
+			MinTimeout: 3 * time.Second,
+		}
+		_, err = stateConf.WaitForState()
+		if err != nil {
+			return fmt.Errorf("Error waiting for volume (%s) to detach: %s", volume.ID.String(), err)
+		}
+	}
+
+	if volume.Size != size {
+		err := volumeClient.ActionGrow(d.Id(), size)
+		if err != nil {
+			return err
+		}
+		stateConf := &resource.StateChangeConf{
+			Pending:    []string{"GROWING"},
+			Target:     []string{""},
+			Refresh:    VolumeTaskRefreshFunc(volumeClient, volume.ID.String()),
+			Timeout:    d.Timeout(schema.TimeoutCreate),
+			Delay:      10 * time.Second,
+			MinTimeout: 3 * time.Second,
+		}
+		_, err = stateConf.WaitForState()
+		if err != nil {
+			return fmt.Errorf("Error waiting for volume (%s) to grow: %s", volume.ID.String(), err)
+		}
+	}
+
+	if attachedTo != (uuid.UUID{}) {
+		err := volumeClient.ActionAttach(volume.ID.String(), attachedTo.String())
+		if err != nil {
+			return err
+		}
+		stateConf := &resource.StateChangeConf{
+			Pending:    []string{"ATTACHING"},
+			Target:     []string{""},
+			Refresh:    VolumeTaskRefreshFunc(volumeClient, volume.ID.String()),
+			Timeout:    d.Timeout(schema.TimeoutCreate),
+			Delay:      10 * time.Second,
+			MinTimeout: 3 * time.Second,
+		}
+		_, err = stateConf.WaitForState()
+		if err != nil {
+			return fmt.Errorf("Error waiting for volume (%s) to attach: %s", volume.ID.String(), err)
+		}
+	}
+
+	return resourceVolumeRead(d, meta)
+}
+
+func resourceVolumeDelete(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*Config)
+	volumeClient := config.SandwichClient.Volume()
+
+	err := volumeClient.ActionDetach(d.Id())
+	if err != nil {
+		if apiError, ok := err.(api.APIError); ok {
+			if apiError.StatusCode != 409 {
+				return err
+			}
+		}
+	}
+	stateConf := &resource.StateChangeConf{
+		Pending:    []string{"DETACHING"},
+		Target:     []string{""},
+		Refresh:    VolumeTaskRefreshFunc(volumeClient, d.Id()),
+		Timeout:    d.Timeout(schema.TimeoutCreate),
+		Delay:      10 * time.Second,
+		MinTimeout: 3 * time.Second,
+	}
+	_, err = stateConf.WaitForState()
+	if err != nil {
+		return fmt.Errorf("Error waiting for volume (%s) to detach: %s", d.Id(), err)
+	}
+
+	err = volumeClient.Delete(d.Id())
+	if err != nil {
+		return err
+	}
+
+	stateConf = &resource.StateChangeConf{
+		Pending:    []string{"ToDelete", "Deleting"},
+		Target:     []string{"Deleted"},
+		Refresh:    VolumeStateRefreshFunc(volumeClient, d.Id()),
+		Timeout:    d.Timeout(schema.TimeoutCreate),
+		Delay:      10 * time.Second,
+		MinTimeout: 3 * time.Second,
+	}
+	_, err = stateConf.WaitForState()
+	if err != nil {
+		return fmt.Errorf("Error waiting for volume (%s) to delete: %s", d.Id(), err)
+	}
+
+	d.SetId("")
+
+	return nil
+}
+
+func VolumeStateRefreshFunc(volumeClient client.VolumeClientInterface, volumeID string) func() (result interface{}, state string, err error) {
+	return func() (result interface{}, state string, err error) {
+		volume, err := volumeClient.Get(volumeID)
+		if err != nil {
+			if apiError, ok := err.(api.APIErrorInterface); ok {
+				if apiError.IsNotFound() {
+					return volume, "Deleted", nil
+				}
+			}
+			return nil, "", err
+		}
+		return volume, volume.State, nil
+	}
+}
+
+func VolumeTaskRefreshFunc(volumeClient client.VolumeClientInterface, volumeID string) func() (result interface{}, state string, err error) {
+	return func() (result interface{}, state string, err error) {
+		volume, err := volumeClient.Get(volumeID)
+		if err != nil {
+			if apiError, ok := err.(api.APIErrorInterface); ok {
+				if apiError.IsNotFound() {
+					return volume, "Deleted", nil
+				}
+			}
+			return nil, "", err
+		}
+		return volume, volume.Task, nil
+	}
+}