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