github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/builtin/providers/google/resource_compute_global_forwarding_rule.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/hashicorp/terraform/helper/schema"
     8  	"google.golang.org/api/compute/v1"
     9  )
    10  
    11  func resourceComputeGlobalForwardingRule() *schema.Resource {
    12  	return &schema.Resource{
    13  		Create: resourceComputeGlobalForwardingRuleCreate,
    14  		Read:   resourceComputeGlobalForwardingRuleRead,
    15  		Update: resourceComputeGlobalForwardingRuleUpdate,
    16  		Delete: resourceComputeGlobalForwardingRuleDelete,
    17  
    18  		Schema: map[string]*schema.Schema{
    19  			"name": &schema.Schema{
    20  				Type:     schema.TypeString,
    21  				Required: true,
    22  				ForceNew: true,
    23  			},
    24  
    25  			"target": &schema.Schema{
    26  				Type:     schema.TypeString,
    27  				Required: true,
    28  			},
    29  
    30  			"description": &schema.Schema{
    31  				Type:     schema.TypeString,
    32  				Optional: true,
    33  				ForceNew: true,
    34  			},
    35  
    36  			"ip_address": &schema.Schema{
    37  				Type:     schema.TypeString,
    38  				Optional: true,
    39  				ForceNew: true,
    40  				Computed: true,
    41  			},
    42  
    43  			"ip_protocol": &schema.Schema{
    44  				Type:     schema.TypeString,
    45  				Optional: true,
    46  				ForceNew: true,
    47  				Computed: true,
    48  			},
    49  
    50  			"port_range": &schema.Schema{
    51  				Type:     schema.TypeString,
    52  				Optional: true,
    53  				ForceNew: true,
    54  			},
    55  
    56  			"project": &schema.Schema{
    57  				Type:     schema.TypeString,
    58  				Optional: true,
    59  				ForceNew: true,
    60  			},
    61  
    62  			"region": &schema.Schema{
    63  				Type:       schema.TypeString,
    64  				Optional:   true,
    65  				ForceNew:   true,
    66  				Deprecated: "Please remove this attribute (it was never used)",
    67  			},
    68  
    69  			"self_link": &schema.Schema{
    70  				Type:     schema.TypeString,
    71  				Computed: true,
    72  			},
    73  		},
    74  	}
    75  }
    76  
    77  func resourceComputeGlobalForwardingRuleCreate(d *schema.ResourceData, meta interface{}) error {
    78  	config := meta.(*Config)
    79  
    80  	project, err := getProject(d, config)
    81  	if err != nil {
    82  		return err
    83  	}
    84  
    85  	frule := &compute.ForwardingRule{
    86  		IPAddress:   d.Get("ip_address").(string),
    87  		IPProtocol:  d.Get("ip_protocol").(string),
    88  		Description: d.Get("description").(string),
    89  		Name:        d.Get("name").(string),
    90  		PortRange:   d.Get("port_range").(string),
    91  		Target:      d.Get("target").(string),
    92  	}
    93  
    94  	op, err := config.clientCompute.GlobalForwardingRules.Insert(
    95  		project, frule).Do()
    96  	if err != nil {
    97  		return fmt.Errorf("Error creating Global Forwarding Rule: %s", err)
    98  	}
    99  
   100  	// It probably maybe worked, so store the ID now
   101  	d.SetId(frule.Name)
   102  
   103  	err = computeOperationWaitGlobal(config, op, project, "Creating Global Fowarding Rule")
   104  	if err != nil {
   105  		return err
   106  	}
   107  
   108  	return resourceComputeGlobalForwardingRuleRead(d, meta)
   109  }
   110  
   111  func resourceComputeGlobalForwardingRuleUpdate(d *schema.ResourceData, meta interface{}) error {
   112  	config := meta.(*Config)
   113  
   114  	project, err := getProject(d, config)
   115  	if err != nil {
   116  		return err
   117  	}
   118  
   119  	d.Partial(true)
   120  
   121  	if d.HasChange("target") {
   122  		target_name := d.Get("target").(string)
   123  		target_ref := &compute.TargetReference{Target: target_name}
   124  		op, err := config.clientCompute.GlobalForwardingRules.SetTarget(
   125  			project, d.Id(), target_ref).Do()
   126  		if err != nil {
   127  			return fmt.Errorf("Error updating target: %s", err)
   128  		}
   129  
   130  		err = computeOperationWaitGlobal(config, op, project, "Updating Global Forwarding Rule")
   131  		if err != nil {
   132  			return err
   133  		}
   134  
   135  		d.SetPartial("target")
   136  	}
   137  
   138  	d.Partial(false)
   139  
   140  	return resourceComputeGlobalForwardingRuleRead(d, meta)
   141  }
   142  
   143  func resourceComputeGlobalForwardingRuleRead(d *schema.ResourceData, meta interface{}) error {
   144  	config := meta.(*Config)
   145  
   146  	project, err := getProject(d, config)
   147  	if err != nil {
   148  		return err
   149  	}
   150  
   151  	frule, err := config.clientCompute.GlobalForwardingRules.Get(
   152  		project, d.Id()).Do()
   153  	if err != nil {
   154  		return handleNotFoundError(err, d, fmt.Sprintf("Global Forwarding Rule %q", d.Get("name").(string)))
   155  	}
   156  
   157  	d.Set("ip_address", frule.IPAddress)
   158  	d.Set("ip_protocol", frule.IPProtocol)
   159  	d.Set("self_link", frule.SelfLink)
   160  
   161  	return nil
   162  }
   163  
   164  func resourceComputeGlobalForwardingRuleDelete(d *schema.ResourceData, meta interface{}) error {
   165  	config := meta.(*Config)
   166  
   167  	project, err := getProject(d, config)
   168  	if err != nil {
   169  		return err
   170  	}
   171  
   172  	// Delete the GlobalForwardingRule
   173  	log.Printf("[DEBUG] GlobalForwardingRule delete request")
   174  	op, err := config.clientCompute.GlobalForwardingRules.Delete(
   175  		project, d.Id()).Do()
   176  	if err != nil {
   177  		return fmt.Errorf("Error deleting GlobalForwardingRule: %s", err)
   178  	}
   179  
   180  	err = computeOperationWaitGlobal(config, op, project, "Deleting GlobalForwarding Rule")
   181  	if err != nil {
   182  		return err
   183  	}
   184  
   185  	d.SetId("")
   186  	return nil
   187  }