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 }