github.com/atsaki/terraform@v0.4.3-0.20150919165407-25bba5967654/builtin/providers/google/resource_compute_forwarding_rule.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 resourceComputeForwardingRule() *schema.Resource {
    14  	return &schema.Resource{
    15  		Create: resourceComputeForwardingRuleCreate,
    16  		Read:   resourceComputeForwardingRuleRead,
    17  		Delete: resourceComputeForwardingRuleDelete,
    18  		Update: resourceComputeForwardingRuleUpdate,
    19  
    20  		Schema: map[string]*schema.Schema{
    21  			"ip_address": &schema.Schema{
    22  				Type:     schema.TypeString,
    23  				Optional: true,
    24  				ForceNew: true,
    25  				Computed: true,
    26  			},
    27  
    28  			"ip_protocol": &schema.Schema{
    29  				Type:     schema.TypeString,
    30  				Optional: true,
    31  				ForceNew: true,
    32  				Computed: true,
    33  			},
    34  
    35  			"description": &schema.Schema{
    36  				Type:     schema.TypeString,
    37  				Optional: true,
    38  				ForceNew: true,
    39  			},
    40  
    41  			"name": &schema.Schema{
    42  				Type:     schema.TypeString,
    43  				Required: true,
    44  				ForceNew: true,
    45  			},
    46  
    47  			"port_range": &schema.Schema{
    48  				Type:     schema.TypeString,
    49  				Optional: true,
    50  				ForceNew: true,
    51  			},
    52  
    53  			"region": &schema.Schema{
    54  				Type:     schema.TypeString,
    55  				Optional: true,
    56  				ForceNew: true,
    57  			},
    58  
    59  			"self_link": &schema.Schema{
    60  				Type:     schema.TypeString,
    61  				Computed: true,
    62  			},
    63  
    64  			"target": &schema.Schema{
    65  				Type:     schema.TypeString,
    66  				Required: true,
    67  				ForceNew: false,
    68  			},
    69  		},
    70  	}
    71  }
    72  
    73  func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{}) error {
    74  	config := meta.(*Config)
    75  
    76  	region := getOptionalRegion(d, config)
    77  
    78  	frule := &compute.ForwardingRule{
    79  		IPAddress:   d.Get("ip_address").(string),
    80  		IPProtocol:  d.Get("ip_protocol").(string),
    81  		Description: d.Get("description").(string),
    82  		Name:        d.Get("name").(string),
    83  		PortRange:   d.Get("port_range").(string),
    84  		Target:      d.Get("target").(string),
    85  	}
    86  
    87  	log.Printf("[DEBUG] ForwardingRule insert request: %#v", frule)
    88  	op, err := config.clientCompute.ForwardingRules.Insert(
    89  		config.Project, region, frule).Do()
    90  	if err != nil {
    91  		return fmt.Errorf("Error creating ForwardingRule: %s", err)
    92  	}
    93  
    94  	// It probably maybe worked, so store the ID now
    95  	d.SetId(frule.Name)
    96  
    97  	// Wait for the operation to complete
    98  	w := &OperationWaiter{
    99  		Service: config.clientCompute,
   100  		Op:      op,
   101  		Region:  region,
   102  		Project: config.Project,
   103  		Type:    OperationWaitRegion,
   104  	}
   105  	state := w.Conf()
   106  	state.Timeout = 2 * time.Minute
   107  	state.MinTimeout = 1 * time.Second
   108  	opRaw, err := state.WaitForState()
   109  	if err != nil {
   110  		return fmt.Errorf("Error waiting for ForwardingRule to create: %s", err)
   111  	}
   112  	op = opRaw.(*compute.Operation)
   113  	if op.Error != nil {
   114  		// The resource didn't actually create
   115  		d.SetId("")
   116  
   117  		// Return the error
   118  		return OperationError(*op.Error)
   119  	}
   120  
   121  	return resourceComputeForwardingRuleRead(d, meta)
   122  }
   123  
   124  func resourceComputeForwardingRuleUpdate(d *schema.ResourceData, meta interface{}) error {
   125  	config := meta.(*Config)
   126  
   127  	region := getOptionalRegion(d, config)
   128  
   129  	d.Partial(true)
   130  
   131  	if d.HasChange("target") {
   132  		target_name := d.Get("target").(string)
   133  		target_ref := &compute.TargetReference{Target: target_name}
   134  		op, err := config.clientCompute.ForwardingRules.SetTarget(
   135  			config.Project, region, d.Id(), target_ref).Do()
   136  		if err != nil {
   137  			return fmt.Errorf("Error updating target: %s", err)
   138  		}
   139  
   140  		// Wait for the operation to complete
   141  		w := &OperationWaiter{
   142  			Service: config.clientCompute,
   143  			Op:      op,
   144  			Region:  region,
   145  			Project: config.Project,
   146  			Type:    OperationWaitRegion,
   147  		}
   148  		state := w.Conf()
   149  		state.Timeout = 2 * time.Minute
   150  		state.MinTimeout = 1 * time.Second
   151  		opRaw, err := state.WaitForState()
   152  		if err != nil {
   153  			return fmt.Errorf("Error waiting for ForwardingRule to update target: %s", err)
   154  		}
   155  		op = opRaw.(*compute.Operation)
   156  		if op.Error != nil {
   157  			// The resource didn't actually create
   158  			d.SetId("")
   159  
   160  			// Return the error
   161  			return OperationError(*op.Error)
   162  		}
   163  		d.SetPartial("target")
   164  	}
   165  
   166  	d.Partial(false)
   167  
   168  	return resourceComputeForwardingRuleRead(d, meta)
   169  }
   170  
   171  func resourceComputeForwardingRuleRead(d *schema.ResourceData, meta interface{}) error {
   172  	config := meta.(*Config)
   173  
   174  	region := getOptionalRegion(d, config)
   175  
   176  	frule, err := config.clientCompute.ForwardingRules.Get(
   177  		config.Project, region, d.Id()).Do()
   178  	if err != nil {
   179  		if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
   180  			// The resource doesn't exist anymore
   181  			d.SetId("")
   182  
   183  			return nil
   184  		}
   185  
   186  		return fmt.Errorf("Error reading ForwardingRule: %s", err)
   187  	}
   188  
   189  	d.Set("ip_address", frule.IPAddress)
   190  	d.Set("ip_protocol", frule.IPProtocol)
   191  	d.Set("self_link", frule.SelfLink)
   192  
   193  	return nil
   194  }
   195  
   196  func resourceComputeForwardingRuleDelete(d *schema.ResourceData, meta interface{}) error {
   197  	config := meta.(*Config)
   198  
   199  	region := getOptionalRegion(d, config)
   200  
   201  	// Delete the ForwardingRule
   202  	log.Printf("[DEBUG] ForwardingRule delete request")
   203  	op, err := config.clientCompute.ForwardingRules.Delete(
   204  		config.Project, region, d.Id()).Do()
   205  	if err != nil {
   206  		return fmt.Errorf("Error deleting ForwardingRule: %s", err)
   207  	}
   208  
   209  	// Wait for the operation to complete
   210  	w := &OperationWaiter{
   211  		Service: config.clientCompute,
   212  		Op:      op,
   213  		Region:  region,
   214  		Project: config.Project,
   215  		Type:    OperationWaitRegion,
   216  	}
   217  	state := w.Conf()
   218  	state.Timeout = 2 * time.Minute
   219  	state.MinTimeout = 1 * time.Second
   220  	opRaw, err := state.WaitForState()
   221  	if err != nil {
   222  		return fmt.Errorf("Error waiting for ForwardingRule to delete: %s", err)
   223  	}
   224  	op = opRaw.(*compute.Operation)
   225  	if op.Error != nil {
   226  		// Return the error
   227  		return OperationError(*op.Error)
   228  	}
   229  
   230  	d.SetId("")
   231  	return nil
   232  }