github.com/peterbale/terraform@v0.9.0-beta2.0.20170315142748-5723acd55547/builtin/providers/google/resource_compute_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 "google.golang.org/api/googleapi" 10 ) 11 12 func resourceComputeForwardingRule() *schema.Resource { 13 return &schema.Resource{ 14 Create: resourceComputeForwardingRuleCreate, 15 Read: resourceComputeForwardingRuleRead, 16 Delete: resourceComputeForwardingRuleDelete, 17 Update: resourceComputeForwardingRuleUpdate, 18 Importer: &schema.ResourceImporter{ 19 State: schema.ImportStatePassthrough, 20 }, 21 22 Schema: map[string]*schema.Schema{ 23 "name": &schema.Schema{ 24 Type: schema.TypeString, 25 Required: true, 26 ForceNew: true, 27 }, 28 29 "target": &schema.Schema{ 30 Type: schema.TypeString, 31 Optional: true, 32 ForceNew: false, 33 }, 34 35 "backend_service": &schema.Schema{ 36 Type: schema.TypeString, 37 Optional: true, 38 ForceNew: true, 39 }, 40 41 "description": &schema.Schema{ 42 Type: schema.TypeString, 43 Optional: true, 44 ForceNew: true, 45 }, 46 47 "ip_address": &schema.Schema{ 48 Type: schema.TypeString, 49 Optional: true, 50 ForceNew: true, 51 Computed: true, 52 }, 53 54 "ip_protocol": &schema.Schema{ 55 Type: schema.TypeString, 56 Optional: true, 57 ForceNew: true, 58 Computed: true, 59 }, 60 61 "load_balancing_scheme": &schema.Schema{ 62 Type: schema.TypeString, 63 Optional: true, 64 ForceNew: true, 65 Default: "EXTERNAL", 66 }, 67 68 "network": &schema.Schema{ 69 Type: schema.TypeString, 70 Optional: true, 71 ForceNew: true, 72 Computed: true, 73 }, 74 75 "port_range": &schema.Schema{ 76 Type: schema.TypeString, 77 Optional: true, 78 ForceNew: true, 79 DiffSuppressFunc: func(k, old, new string, d *schema.ResourceData) bool { 80 if old == new+"-"+new { 81 return true 82 } 83 return false 84 }, 85 }, 86 87 "ports": &schema.Schema{ 88 Type: schema.TypeSet, 89 Elem: &schema.Schema{Type: schema.TypeString}, 90 Optional: true, 91 Set: schema.HashString, 92 }, 93 94 "project": &schema.Schema{ 95 Type: schema.TypeString, 96 Optional: true, 97 ForceNew: true, 98 Computed: true, 99 }, 100 101 "region": &schema.Schema{ 102 Type: schema.TypeString, 103 Optional: true, 104 ForceNew: true, 105 Computed: true, 106 }, 107 108 "self_link": &schema.Schema{ 109 Type: schema.TypeString, 110 Computed: true, 111 }, 112 113 "subnetwork": &schema.Schema{ 114 Type: schema.TypeString, 115 Optional: true, 116 ForceNew: true, 117 Computed: true, 118 }, 119 }, 120 } 121 } 122 123 func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{}) error { 124 config := meta.(*Config) 125 126 region, err := getRegion(d, config) 127 if err != nil { 128 return err 129 } 130 131 project, err := getProject(d, config) 132 if err != nil { 133 return err 134 } 135 136 ps := d.Get("ports").(*schema.Set).List() 137 ports := make([]string, 0, len(ps)) 138 for _, v := range ps { 139 ports = append(ports, v.(string)) 140 } 141 142 frule := &compute.ForwardingRule{ 143 BackendService: d.Get("backend_service").(string), 144 IPAddress: d.Get("ip_address").(string), 145 IPProtocol: d.Get("ip_protocol").(string), 146 Description: d.Get("description").(string), 147 LoadBalancingScheme: d.Get("load_balancing_scheme").(string), 148 Name: d.Get("name").(string), 149 Network: d.Get("network").(string), 150 PortRange: d.Get("port_range").(string), 151 Ports: ports, 152 Subnetwork: d.Get("subnetwork").(string), 153 Target: d.Get("target").(string), 154 } 155 156 log.Printf("[DEBUG] ForwardingRule insert request: %#v", frule) 157 op, err := config.clientCompute.ForwardingRules.Insert( 158 project, region, frule).Do() 159 if err != nil { 160 return fmt.Errorf("Error creating ForwardingRule: %s", err) 161 } 162 163 // It probably maybe worked, so store the ID now 164 d.SetId(frule.Name) 165 166 err = computeOperationWaitRegion(config, op, project, region, "Creating Fowarding Rule") 167 if err != nil { 168 return err 169 } 170 171 return resourceComputeForwardingRuleRead(d, meta) 172 } 173 174 func resourceComputeForwardingRuleUpdate(d *schema.ResourceData, meta interface{}) error { 175 config := meta.(*Config) 176 177 region, err := getRegion(d, config) 178 if err != nil { 179 return err 180 } 181 182 project, err := getProject(d, config) 183 if err != nil { 184 return err 185 } 186 187 d.Partial(true) 188 189 if d.HasChange("target") { 190 target_name := d.Get("target").(string) 191 target_ref := &compute.TargetReference{Target: target_name} 192 op, err := config.clientCompute.ForwardingRules.SetTarget( 193 project, region, d.Id(), target_ref).Do() 194 if err != nil { 195 return fmt.Errorf("Error updating target: %s", err) 196 } 197 198 err = computeOperationWaitRegion(config, op, project, region, "Updating Forwarding Rule") 199 if err != nil { 200 return err 201 } 202 203 d.SetPartial("target") 204 } 205 206 d.Partial(false) 207 208 return resourceComputeForwardingRuleRead(d, meta) 209 } 210 211 func resourceComputeForwardingRuleRead(d *schema.ResourceData, meta interface{}) error { 212 config := meta.(*Config) 213 214 region, err := getRegion(d, config) 215 if err != nil { 216 return err 217 } 218 219 project, err := getProject(d, config) 220 if err != nil { 221 return err 222 } 223 224 frule, err := config.clientCompute.ForwardingRules.Get( 225 project, region, d.Id()).Do() 226 if err != nil { 227 if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 { 228 log.Printf("[WARN] Removing Forwarding Rule %q because it's gone", d.Get("name").(string)) 229 // The resource doesn't exist anymore 230 d.SetId("") 231 232 return nil 233 } 234 235 return fmt.Errorf("Error reading ForwardingRule: %s", err) 236 } 237 238 d.Set("name", frule.Name) 239 d.Set("target", frule.Target) 240 d.Set("backend_service", frule.BackendService) 241 d.Set("description", frule.Description) 242 d.Set("load_balancing_scheme", frule.LoadBalancingScheme) 243 d.Set("network", frule.Network) 244 d.Set("port_range", frule.PortRange) 245 d.Set("ports", frule.Ports) 246 d.Set("project", project) 247 d.Set("region", region) 248 d.Set("subnetwork", frule.Subnetwork) 249 d.Set("ip_address", frule.IPAddress) 250 d.Set("ip_protocol", frule.IPProtocol) 251 d.Set("self_link", frule.SelfLink) 252 return nil 253 } 254 255 func resourceComputeForwardingRuleDelete(d *schema.ResourceData, meta interface{}) error { 256 config := meta.(*Config) 257 258 region, err := getRegion(d, config) 259 if err != nil { 260 return err 261 } 262 263 project, err := getProject(d, config) 264 if err != nil { 265 return err 266 } 267 268 // Delete the ForwardingRule 269 log.Printf("[DEBUG] ForwardingRule delete request") 270 op, err := config.clientCompute.ForwardingRules.Delete( 271 project, region, d.Id()).Do() 272 if err != nil { 273 return fmt.Errorf("Error deleting ForwardingRule: %s", err) 274 } 275 276 err = computeOperationWaitRegion(config, op, project, region, "Deleting Forwarding Rule") 277 if err != nil { 278 return err 279 } 280 281 d.SetId("") 282 return nil 283 }