github.com/arvindram03/terraform@v0.3.7-0.20150212015210-408f838db36d/builtin/providers/google/resource_compute_address.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 resourceComputeAddress() *schema.Resource {
    14  	return &schema.Resource{
    15  		Create: resourceComputeAddressCreate,
    16  		Read:   resourceComputeAddressRead,
    17  		Delete: resourceComputeAddressDelete,
    18  
    19  		Schema: map[string]*schema.Schema{
    20  			"name": &schema.Schema{
    21  				Type:     schema.TypeString,
    22  				Required: true,
    23  				ForceNew: true,
    24  			},
    25  
    26  			"address": &schema.Schema{
    27  				Type:     schema.TypeString,
    28  				Computed: true,
    29  			},
    30  
    31  			"self_link": &schema.Schema{
    32  				Type:     schema.TypeString,
    33  				Computed: true,
    34  			},
    35  
    36  		},
    37  	}
    38  }
    39  
    40  func resourceComputeAddressCreate(d *schema.ResourceData, meta interface{}) error {
    41  	config := meta.(*Config)
    42  
    43  	// Build the address parameter
    44  	addr := &compute.Address{Name: d.Get("name").(string)}
    45  	log.Printf("[DEBUG] Address insert request: %#v", addr)
    46  	op, err := config.clientCompute.Addresses.Insert(
    47  		config.Project, config.Region, addr).Do()
    48  	if err != nil {
    49  		return fmt.Errorf("Error creating address: %s", err)
    50  	}
    51  
    52  	// It probably maybe worked, so store the ID now
    53  	d.SetId(addr.Name)
    54  
    55  	// Wait for the operation to complete
    56  	w := &OperationWaiter{
    57  		Service: config.clientCompute,
    58  		Op:      op,
    59  		Project: config.Project,
    60  		Region:  config.Region,
    61  		Type:    OperationWaitRegion,
    62  	}
    63  	state := w.Conf()
    64  	state.Timeout = 2 * time.Minute
    65  	state.MinTimeout = 1 * time.Second
    66  	opRaw, err := state.WaitForState()
    67  	if err != nil {
    68  		return fmt.Errorf("Error waiting for address to create: %s", err)
    69  	}
    70  	op = opRaw.(*compute.Operation)
    71  	if op.Error != nil {
    72  		// The resource didn't actually create
    73  		d.SetId("")
    74  
    75  		// Return the error
    76  		return OperationError(*op.Error)
    77  	}
    78  
    79  	return resourceComputeAddressRead(d, meta)
    80  }
    81  
    82  func resourceComputeAddressRead(d *schema.ResourceData, meta interface{}) error {
    83  	config := meta.(*Config)
    84  
    85  	addr, err := config.clientCompute.Addresses.Get(
    86  		config.Project, config.Region, d.Id()).Do()
    87  	if err != nil {
    88  		if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
    89  			// The resource doesn't exist anymore
    90  			d.SetId("")
    91  
    92  			return nil
    93  		}
    94  
    95  		return fmt.Errorf("Error reading address: %s", err)
    96  	}
    97  
    98  	d.Set("address", addr.Address)
    99  	d.Set("self_link", addr.SelfLink)
   100  
   101  	return nil
   102  }
   103  
   104  func resourceComputeAddressDelete(d *schema.ResourceData, meta interface{}) error {
   105  	config := meta.(*Config)
   106  
   107  	// Delete the address
   108  	log.Printf("[DEBUG] address delete request")
   109  	op, err := config.clientCompute.Addresses.Delete(
   110  		config.Project, config.Region, d.Id()).Do()
   111  	if err != nil {
   112  		return fmt.Errorf("Error deleting address: %s", err)
   113  	}
   114  
   115  	// Wait for the operation to complete
   116  	w := &OperationWaiter{
   117  		Service: config.clientCompute,
   118  		Op:      op,
   119  		Project: config.Project,
   120  		Region:  config.Region,
   121  		Type:    OperationWaitRegion,
   122  	}
   123  	state := w.Conf()
   124  	state.Timeout = 2 * time.Minute
   125  	state.MinTimeout = 1 * time.Second
   126  	opRaw, err := state.WaitForState()
   127  	if err != nil {
   128  		return fmt.Errorf("Error waiting for address to delete: %s", err)
   129  	}
   130  	op = opRaw.(*compute.Operation)
   131  	if op.Error != nil {
   132  		// Return the error
   133  		return OperationError(*op.Error)
   134  	}
   135  
   136  	d.SetId("")
   137  	return nil
   138  }