github.com/danp/terraform@v0.9.5-0.20170426144147-39d740081351/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": {
    25  				Type:     schema.TypeString,
    26  				Required: true,
    27  			},
    28  			"size_in_gb": {
    29  				Type:         schema.TypeInt,
    30  				Required:     true,
    31  				ValidateFunc: validateVolumeSize,
    32  			},
    33  			"type": {
    34  				Type:         schema.TypeString,
    35  				Required:     true,
    36  				ValidateFunc: validateVolumeType,
    37  			},
    38  			"server": {
    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  
    49  	mu.Lock()
    50  	defer mu.Unlock()
    51  
    52  	size := uint64(d.Get("size_in_gb").(int)) * gb
    53  	req := api.ScalewayVolumeDefinition{
    54  		Name:         d.Get("name").(string),
    55  		Size:         size,
    56  		Type:         d.Get("type").(string),
    57  		Organization: scaleway.Organization,
    58  	}
    59  	volumeID, err := scaleway.PostVolume(req)
    60  	if err != nil {
    61  		return fmt.Errorf("Error Creating volume: %q", err)
    62  	}
    63  	d.SetId(volumeID)
    64  	return resourceScalewayVolumeRead(d, m)
    65  }
    66  
    67  func resourceScalewayVolumeRead(d *schema.ResourceData, m interface{}) error {
    68  	scaleway := m.(*Client).scaleway
    69  	volume, err := scaleway.GetVolume(d.Id())
    70  	if err != nil {
    71  		if serr, ok := err.(api.ScalewayAPIError); ok {
    72  			log.Printf("[DEBUG] Error reading volume: %q\n", serr.APIMessage)
    73  
    74  			if serr.StatusCode == 404 {
    75  				d.SetId("")
    76  				return nil
    77  			}
    78  		}
    79  
    80  		return err
    81  	}
    82  	d.Set("name", volume.Name)
    83  	d.Set("size_in_gb", uint64(volume.Size)/gb)
    84  	d.Set("type", volume.VolumeType)
    85  	d.Set("server", "")
    86  	if volume.Server != nil {
    87  		d.Set("server", volume.Server.Identifier)
    88  	}
    89  	return nil
    90  }
    91  
    92  func resourceScalewayVolumeUpdate(d *schema.ResourceData, m interface{}) error {
    93  	scaleway := m.(*Client).scaleway
    94  
    95  	mu.Lock()
    96  	defer mu.Unlock()
    97  
    98  	var req api.ScalewayVolumePutDefinition
    99  	if d.HasChange("name") {
   100  		req.Name = String(d.Get("name").(string))
   101  	}
   102  
   103  	if d.HasChange("size_in_gb") {
   104  		size := uint64(d.Get("size_in_gb").(int)) * gb
   105  		req.Size = &size
   106  	}
   107  
   108  	scaleway.PutVolume(d.Id(), req)
   109  	return resourceScalewayVolumeRead(d, m)
   110  }
   111  
   112  func resourceScalewayVolumeDelete(d *schema.ResourceData, m interface{}) error {
   113  	scaleway := m.(*Client).scaleway
   114  
   115  	mu.Lock()
   116  	defer mu.Unlock()
   117  
   118  	err := scaleway.DeleteVolume(d.Id())
   119  	if err != nil {
   120  		if serr, ok := err.(api.ScalewayAPIError); ok {
   121  			if serr.StatusCode == 404 {
   122  				d.SetId("")
   123  				return nil
   124  			}
   125  		}
   126  		return err
   127  	}
   128  	d.SetId("")
   129  	return nil
   130  }