github.com/bendemaree/terraform@v0.5.4-0.20150613200311-f50d97d6eee6/builtin/providers/google/resource_compute_address.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"time"
     7  
     8  	"github.com/hashicorp/terraform/helper/schema"
     9  	"google.golang.org/api/compute/v1"
    10  	"google.golang.org/api/googleapi"
    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  func resourceComputeAddressCreate(d *schema.ResourceData, meta interface{}) error {
    40  	config := meta.(*Config)
    41  
    42  	// Build the address parameter
    43  	addr := &compute.Address{Name: d.Get("name").(string)}
    44  	log.Printf("[DEBUG] Address insert request: %#v", addr)
    45  	op, err := config.clientCompute.Addresses.Insert(
    46  		config.Project, config.Region, addr).Do()
    47  	if err != nil {
    48  		return fmt.Errorf("Error creating address: %s", err)
    49  	}
    50  
    51  	// It probably maybe worked, so store the ID now
    52  	d.SetId(addr.Name)
    53  
    54  	// Wait for the operation to complete
    55  	w := &OperationWaiter{
    56  		Service: config.clientCompute,
    57  		Op:      op,
    58  		Project: config.Project,
    59  		Region:  config.Region,
    60  		Type:    OperationWaitRegion,
    61  	}
    62  	state := w.Conf()
    63  	state.Timeout = 2 * time.Minute
    64  	state.MinTimeout = 1 * time.Second
    65  	opRaw, err := state.WaitForState()
    66  	if err != nil {
    67  		return fmt.Errorf("Error waiting for address to create: %s", err)
    68  	}
    69  	op = opRaw.(*compute.Operation)
    70  	if op.Error != nil {
    71  		// The resource didn't actually create
    72  		d.SetId("")
    73  
    74  		// Return the error
    75  		return OperationError(*op.Error)
    76  	}
    77  
    78  	return resourceComputeAddressRead(d, meta)
    79  }
    80  
    81  func resourceComputeAddressRead(d *schema.ResourceData, meta interface{}) error {
    82  	config := meta.(*Config)
    83  
    84  	addr, err := config.clientCompute.Addresses.Get(
    85  		config.Project, config.Region, d.Id()).Do()
    86  	if err != nil {
    87  		if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
    88  			// The resource doesn't exist anymore
    89  			d.SetId("")
    90  
    91  			return nil
    92  		}
    93  
    94  		return fmt.Errorf("Error reading address: %s", err)
    95  	}
    96  
    97  	d.Set("address", addr.Address)
    98  	d.Set("self_link", addr.SelfLink)
    99  
   100  	return nil
   101  }
   102  
   103  func resourceComputeAddressDelete(d *schema.ResourceData, meta interface{}) error {
   104  	config := meta.(*Config)
   105  
   106  	// Delete the address
   107  	log.Printf("[DEBUG] address delete request")
   108  	op, err := config.clientCompute.Addresses.Delete(
   109  		config.Project, config.Region, d.Id()).Do()
   110  	if err != nil {
   111  		return fmt.Errorf("Error deleting address: %s", err)
   112  	}
   113  
   114  	// Wait for the operation to complete
   115  	w := &OperationWaiter{
   116  		Service: config.clientCompute,
   117  		Op:      op,
   118  		Project: config.Project,
   119  		Region:  config.Region,
   120  		Type:    OperationWaitRegion,
   121  	}
   122  	state := w.Conf()
   123  	state.Timeout = 2 * time.Minute
   124  	state.MinTimeout = 1 * time.Second
   125  	opRaw, err := state.WaitForState()
   126  	if err != nil {
   127  		return fmt.Errorf("Error waiting for address to delete: %s", err)
   128  	}
   129  	op = opRaw.(*compute.Operation)
   130  	if op.Error != nil {
   131  		// Return the error
   132  		return OperationError(*op.Error)
   133  	}
   134  
   135  	d.SetId("")
   136  	return nil
   137  }