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