github.com/nov1n/terraform@v0.7.9-0.20161103151050-bf6852f38e28/builtin/providers/scaleway/resource_scaleway_volume.go (about)

     1  package scaleway
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/hashicorp/terraform/helper/schema"
     8  	"github.com/scaleway/scaleway-cli/pkg/api"
     9  )
    10  
    11  const gb uint64 = 1000 * 1000 * 1000
    12  
    13  func resourceScalewayVolume() *schema.Resource {
    14  	return &schema.Resource{
    15  		Create: resourceScalewayVolumeCreate,
    16  		Read:   resourceScalewayVolumeRead,
    17  		Update: resourceScalewayVolumeUpdate,
    18  		Delete: resourceScalewayVolumeDelete,
    19  		Importer: &schema.ResourceImporter{
    20  			State: schema.ImportStatePassthrough,
    21  		},
    22  
    23  		Schema: map[string]*schema.Schema{
    24  			"name": &schema.Schema{
    25  				Type:     schema.TypeString,
    26  				Required: true,
    27  			},
    28  			"size_in_gb": &schema.Schema{
    29  				Type:         schema.TypeInt,
    30  				Required:     true,
    31  				ValidateFunc: validateVolumeSize,
    32  			},
    33  			"type": &schema.Schema{
    34  				Type:         schema.TypeString,
    35  				Required:     true,
    36  				ValidateFunc: validateVolumeType,
    37  			},
    38  			"server": &schema.Schema{
    39  				Type:     schema.TypeString,
    40  				Computed: true,
    41  			},
    42  		},
    43  	}
    44  }
    45  
    46  func resourceScalewayVolumeCreate(d *schema.ResourceData, m interface{}) error {
    47  	scaleway := m.(*Client).scaleway
    48  	size := uint64(d.Get("size_in_gb").(int)) * gb
    49  	req := api.ScalewayVolumeDefinition{
    50  		Name:         d.Get("name").(string),
    51  		Size:         size,
    52  		Type:         d.Get("type").(string),
    53  		Organization: scaleway.Organization,
    54  	}
    55  	volumeID, err := scaleway.PostVolume(req)
    56  	if err != nil {
    57  		return fmt.Errorf("Error Creating volume: %q", err)
    58  	}
    59  	d.SetId(volumeID)
    60  	return resourceScalewayVolumeRead(d, m)
    61  }
    62  
    63  func resourceScalewayVolumeRead(d *schema.ResourceData, m interface{}) error {
    64  	scaleway := m.(*Client).scaleway
    65  	volume, err := scaleway.GetVolume(d.Id())
    66  	if err != nil {
    67  		if serr, ok := err.(api.ScalewayAPIError); ok {
    68  			log.Printf("[DEBUG] Error reading volume: %q\n", serr.APIMessage)
    69  
    70  			if serr.StatusCode == 404 {
    71  				d.SetId("")
    72  				return nil
    73  			}
    74  		}
    75  
    76  		return err
    77  	}
    78  	d.Set("name", volume.Name)
    79  	if size, ok := volume.Size.(float64); ok {
    80  		d.Set("size_in_gb", uint64(size)/gb)
    81  	}
    82  	d.Set("type", volume.VolumeType)
    83  	d.Set("server", "")
    84  	if volume.Server != nil {
    85  		d.Set("server", volume.Server.Identifier)
    86  	}
    87  	return nil
    88  }
    89  
    90  func resourceScalewayVolumeUpdate(d *schema.ResourceData, m interface{}) error {
    91  	scaleway := m.(*Client).scaleway
    92  
    93  	var req api.ScalewayVolumePutDefinition
    94  	if d.HasChange("name") {
    95  		req.Name = String(d.Get("name").(string))
    96  	}
    97  
    98  	if d.HasChange("size_in_gb") {
    99  		size := uint64(d.Get("size_in_gb").(int)) * gb
   100  		req.Size = &size
   101  	}
   102  
   103  	scaleway.PutVolume(d.Id(), req)
   104  	return resourceScalewayVolumeRead(d, m)
   105  }
   106  
   107  func resourceScalewayVolumeDelete(d *schema.ResourceData, m interface{}) error {
   108  	scaleway := m.(*Client).scaleway
   109  	err := scaleway.DeleteVolume(d.Id())
   110  	if err != nil {
   111  		if serr, ok := err.(api.ScalewayAPIError); ok {
   112  			if serr.StatusCode == 404 {
   113  				d.SetId("")
   114  				return nil
   115  			}
   116  		}
   117  		return err
   118  	}
   119  	d.SetId("")
   120  	return nil
   121  }