github.com/ndarilek/terraform@v0.3.8-0.20150320140257-d3135c1b2bac/builtin/providers/google/resource_compute_disk.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"time"
     7  
     8  	"code.google.com/p/google-api-go-client/compute/v1"
     9  	"code.google.com/p/google-api-go-client/googleapi"
    10  	"github.com/hashicorp/terraform/helper/schema"
    11  )
    12  
    13  func resourceComputeDisk() *schema.Resource {
    14  	return &schema.Resource{
    15  		Create: resourceComputeDiskCreate,
    16  		Read:   resourceComputeDiskRead,
    17  		Delete: resourceComputeDiskDelete,
    18  
    19  		Schema: map[string]*schema.Schema{
    20  			"name": &schema.Schema{
    21  				Type:     schema.TypeString,
    22  				Required: true,
    23  				ForceNew: true,
    24  			},
    25  
    26  			"zone": &schema.Schema{
    27  				Type:     schema.TypeString,
    28  				Required: true,
    29  				ForceNew: true,
    30  			},
    31  
    32  			"image": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Optional: true,
    35  				ForceNew: true,
    36  			},
    37  
    38  			"size": &schema.Schema{
    39  				Type:     schema.TypeInt,
    40  				Optional: true,
    41  				ForceNew: true,
    42  			},
    43  
    44  			"type": &schema.Schema{
    45  				Type:     schema.TypeString,
    46  				Optional: true,
    47  				ForceNew: true,
    48  			},
    49  
    50  			"self_link": &schema.Schema{
    51  				Type:     schema.TypeString,
    52  				Computed: true,
    53  			},
    54  		},
    55  	}
    56  }
    57  
    58  func resourceComputeDiskCreate(d *schema.ResourceData, meta interface{}) error {
    59  	config := meta.(*Config)
    60  
    61  	// Get the zone
    62  	log.Printf("[DEBUG] Loading zone: %s", d.Get("zone").(string))
    63  	zone, err := config.clientCompute.Zones.Get(
    64  		config.Project, d.Get("zone").(string)).Do()
    65  	if err != nil {
    66  		return fmt.Errorf(
    67  			"Error loading zone '%s': %s", d.Get("zone").(string), err)
    68  	}
    69  
    70  	// Build the disk parameter
    71  	disk := &compute.Disk{
    72  		Name:   d.Get("name").(string),
    73  		SizeGb: int64(d.Get("size").(int)),
    74  	}
    75  
    76  	// If we were given a source image, load that.
    77  	if v, ok := d.GetOk("image"); ok {
    78  		log.Printf("[DEBUG] Resolving image name: %s", v.(string))
    79  		imageUrl, err := resolveImage(config, v.(string))
    80  		if err != nil {
    81  			return fmt.Errorf(
    82  				"Error resolving image name '%s': %s",
    83  				v.(string), err)
    84  		}
    85  
    86  		disk.SourceImage = imageUrl
    87  	}
    88  
    89  	if v, ok := d.GetOk("type"); ok {
    90  		log.Printf("[DEBUG] Loading disk type: %s", v.(string))
    91  		diskType, err := readDiskType(config, zone, v.(string))
    92  		if err != nil {
    93  			return fmt.Errorf(
    94  				"Error loading disk type '%s': %s",
    95  				v.(string), err)
    96  		}
    97  
    98  		disk.Type = diskType.SelfLink
    99  	}
   100  
   101  	op, err := config.clientCompute.Disks.Insert(
   102  		config.Project, d.Get("zone").(string), disk).Do()
   103  	if err != nil {
   104  		return fmt.Errorf("Error creating disk: %s", err)
   105  	}
   106  
   107  	// It probably maybe worked, so store the ID now
   108  	d.SetId(disk.Name)
   109  
   110  	// Wait for the operation to complete
   111  	w := &OperationWaiter{
   112  		Service: config.clientCompute,
   113  		Op:      op,
   114  		Project: config.Project,
   115  		Zone:    d.Get("zone").(string),
   116  		Type:    OperationWaitZone,
   117  	}
   118  	state := w.Conf()
   119  	state.Timeout = 2 * time.Minute
   120  	state.MinTimeout = 1 * time.Second
   121  	opRaw, err := state.WaitForState()
   122  	if err != nil {
   123  		return fmt.Errorf("Error waiting for disk to create: %s", err)
   124  	}
   125  	op = opRaw.(*compute.Operation)
   126  	if op.Error != nil {
   127  		// The resource didn't actually create
   128  		d.SetId("")
   129  
   130  		// Return the error
   131  		return OperationError(*op.Error)
   132  	}
   133  
   134  	return resourceComputeDiskRead(d, meta)
   135  }
   136  
   137  func resourceComputeDiskRead(d *schema.ResourceData, meta interface{}) error {
   138  	config := meta.(*Config)
   139  
   140  	disk, err := config.clientCompute.Disks.Get(
   141  		config.Project, d.Get("zone").(string), d.Id()).Do()
   142  	if err != nil {
   143  		if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
   144  			// The resource doesn't exist anymore
   145  			d.SetId("")
   146  
   147  			return nil
   148  		}
   149  
   150  		return fmt.Errorf("Error reading disk: %s", err)
   151  	}
   152  
   153  	d.Set("self_link", disk.SelfLink)
   154  
   155  	return nil
   156  }
   157  
   158  func resourceComputeDiskDelete(d *schema.ResourceData, meta interface{}) error {
   159  	config := meta.(*Config)
   160  
   161  	// Delete the disk
   162  	op, err := config.clientCompute.Disks.Delete(
   163  		config.Project, d.Get("zone").(string), d.Id()).Do()
   164  	if err != nil {
   165  		return fmt.Errorf("Error deleting disk: %s", err)
   166  	}
   167  
   168  	// Wait for the operation to complete
   169  	w := &OperationWaiter{
   170  		Service: config.clientCompute,
   171  		Op:      op,
   172  		Project: config.Project,
   173  		Zone:    d.Get("zone").(string),
   174  		Type:    OperationWaitZone,
   175  	}
   176  	state := w.Conf()
   177  	state.Timeout = 2 * time.Minute
   178  	state.MinTimeout = 1 * time.Second
   179  	opRaw, err := state.WaitForState()
   180  	if err != nil {
   181  		return fmt.Errorf("Error waiting for disk to delete: %s", err)
   182  	}
   183  	op = opRaw.(*compute.Operation)
   184  	if op.Error != nil {
   185  		// Return the error
   186  		return OperationError(*op.Error)
   187  	}
   188  
   189  	d.SetId("")
   190  	return nil
   191  }