github.com/nathanielks/terraform@v0.6.1-0.20170509030759-13e1a62319dc/builtin/providers/google/resource_compute_route.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 resourceComputeRoute() *schema.Resource { 13 return &schema.Resource{ 14 Create: resourceComputeRouteCreate, 15 Read: resourceComputeRouteRead, 16 Delete: resourceComputeRouteDelete, 17 Importer: &schema.ResourceImporter{ 18 State: schema.ImportStatePassthrough, 19 }, 20 21 Schema: map[string]*schema.Schema{ 22 "dest_range": &schema.Schema{ 23 Type: schema.TypeString, 24 Required: true, 25 ForceNew: true, 26 }, 27 28 "name": &schema.Schema{ 29 Type: schema.TypeString, 30 Required: true, 31 ForceNew: true, 32 }, 33 34 "network": &schema.Schema{ 35 Type: schema.TypeString, 36 Required: true, 37 ForceNew: true, 38 }, 39 40 "priority": &schema.Schema{ 41 Type: schema.TypeInt, 42 Required: true, 43 ForceNew: true, 44 }, 45 46 "next_hop_gateway": &schema.Schema{ 47 Type: schema.TypeString, 48 Optional: true, 49 ForceNew: true, 50 }, 51 52 "next_hop_instance": &schema.Schema{ 53 Type: schema.TypeString, 54 Optional: true, 55 ForceNew: true, 56 }, 57 58 "next_hop_instance_zone": &schema.Schema{ 59 Type: schema.TypeString, 60 Optional: true, 61 ForceNew: true, 62 }, 63 64 "next_hop_ip": &schema.Schema{ 65 Type: schema.TypeString, 66 Optional: true, 67 ForceNew: true, 68 }, 69 70 "next_hop_network": &schema.Schema{ 71 Type: schema.TypeString, 72 Computed: true, 73 }, 74 75 "next_hop_vpn_tunnel": &schema.Schema{ 76 Type: schema.TypeString, 77 Optional: true, 78 ForceNew: true, 79 }, 80 81 "project": &schema.Schema{ 82 Type: schema.TypeString, 83 Optional: true, 84 ForceNew: true, 85 }, 86 87 "self_link": &schema.Schema{ 88 Type: schema.TypeString, 89 Computed: true, 90 }, 91 92 "tags": &schema.Schema{ 93 Type: schema.TypeSet, 94 Optional: true, 95 ForceNew: true, 96 Elem: &schema.Schema{Type: schema.TypeString}, 97 Set: schema.HashString, 98 }, 99 }, 100 } 101 } 102 103 func resourceComputeRouteCreate(d *schema.ResourceData, meta interface{}) error { 104 config := meta.(*Config) 105 106 project, err := getProject(d, config) 107 if err != nil { 108 return err 109 } 110 111 // Look up the network to attach the route to 112 network, err := getNetworkLink(d, config, "network") 113 if err != nil { 114 return fmt.Errorf("Error reading network: %s", err) 115 } 116 117 // Next hop data 118 var nextHopInstance, nextHopIp, nextHopGateway, 119 nextHopVpnTunnel string 120 if v, ok := d.GetOk("next_hop_ip"); ok { 121 nextHopIp = v.(string) 122 } 123 if v, ok := d.GetOk("next_hop_gateway"); ok { 124 if v == "default-internet-gateway" { 125 nextHopGateway = fmt.Sprintf("projects/%s/global/gateways/default-internet-gateway", project) 126 } else { 127 nextHopGateway = v.(string) 128 } 129 } 130 if v, ok := d.GetOk("next_hop_vpn_tunnel"); ok { 131 nextHopVpnTunnel = v.(string) 132 } 133 if v, ok := d.GetOk("next_hop_instance"); ok { 134 nextInstance, err := config.clientCompute.Instances.Get( 135 project, 136 d.Get("next_hop_instance_zone").(string), 137 v.(string)).Do() 138 if err != nil { 139 return fmt.Errorf("Error reading instance: %s", err) 140 } 141 142 nextHopInstance = nextInstance.SelfLink 143 } 144 145 // Tags 146 var tags []string 147 if v := d.Get("tags").(*schema.Set); v.Len() > 0 { 148 tags = make([]string, v.Len()) 149 for i, v := range v.List() { 150 tags[i] = v.(string) 151 } 152 } 153 154 // Build the route parameter 155 route := &compute.Route{ 156 Name: d.Get("name").(string), 157 DestRange: d.Get("dest_range").(string), 158 Network: network, 159 NextHopInstance: nextHopInstance, 160 NextHopVpnTunnel: nextHopVpnTunnel, 161 NextHopIp: nextHopIp, 162 NextHopGateway: nextHopGateway, 163 Priority: int64(d.Get("priority").(int)), 164 Tags: tags, 165 } 166 log.Printf("[DEBUG] Route insert request: %#v", route) 167 op, err := config.clientCompute.Routes.Insert( 168 project, route).Do() 169 if err != nil { 170 return fmt.Errorf("Error creating route: %s", err) 171 } 172 173 // It probably maybe worked, so store the ID now 174 d.SetId(route.Name) 175 176 err = computeOperationWaitGlobal(config, op, project, "Creating Route") 177 if err != nil { 178 return err 179 } 180 181 return resourceComputeRouteRead(d, meta) 182 } 183 184 func resourceComputeRouteRead(d *schema.ResourceData, meta interface{}) error { 185 config := meta.(*Config) 186 187 project, err := getProject(d, config) 188 if err != nil { 189 return err 190 } 191 192 route, err := config.clientCompute.Routes.Get( 193 project, d.Id()).Do() 194 if err != nil { 195 if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 { 196 log.Printf("[WARN] Removing Route %q because it's gone", d.Get("name").(string)) 197 // The resource doesn't exist anymore 198 d.SetId("") 199 200 return nil 201 } 202 203 return fmt.Errorf("Error reading route: %#v", err) 204 } 205 206 d.Set("next_hop_network", route.NextHopNetwork) 207 d.Set("self_link", route.SelfLink) 208 209 return nil 210 } 211 212 func resourceComputeRouteDelete(d *schema.ResourceData, meta interface{}) error { 213 config := meta.(*Config) 214 215 project, err := getProject(d, config) 216 if err != nil { 217 return err 218 } 219 220 // Delete the route 221 op, err := config.clientCompute.Routes.Delete( 222 project, d.Id()).Do() 223 if err != nil { 224 return fmt.Errorf("Error deleting route: %s", err) 225 } 226 227 err = computeOperationWaitGlobal(config, op, project, "Deleting Route") 228 if err != nil { 229 return err 230 } 231 232 d.SetId("") 233 return nil 234 }