github.com/leeprovoost/terraform@v0.6.10-0.20160119085442-96f3f76118e7/builtin/providers/google/resource_compute_vpn_tunnel.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/hashicorp/terraform/helper/schema"
     8  
     9  	"google.golang.org/api/compute/v1"
    10  	"google.golang.org/api/googleapi"
    11  )
    12  
    13  func resourceComputeVpnTunnel() *schema.Resource {
    14  	return &schema.Resource{
    15  		// Unfortunately, the VPNTunnelService does not support update
    16  		// operations. This is why everything is marked forcenew
    17  		Create: resourceComputeVpnTunnelCreate,
    18  		Read:   resourceComputeVpnTunnelRead,
    19  		Delete: resourceComputeVpnTunnelDelete,
    20  
    21  		Schema: map[string]*schema.Schema{
    22  			"name": &schema.Schema{
    23  				Type:     schema.TypeString,
    24  				Required: true,
    25  				ForceNew: true,
    26  			},
    27  			"description": &schema.Schema{
    28  				Type:     schema.TypeString,
    29  				Optional: true,
    30  				ForceNew: true,
    31  			},
    32  			"region": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Optional: true,
    35  				ForceNew: true,
    36  			},
    37  			"peer_ip": &schema.Schema{
    38  				Type:     schema.TypeString,
    39  				Required: true,
    40  				ForceNew: true,
    41  			},
    42  			"shared_secret": &schema.Schema{
    43  				Type:     schema.TypeString,
    44  				Required: true,
    45  				ForceNew: true,
    46  			},
    47  			"target_vpn_gateway": &schema.Schema{
    48  				Type:     schema.TypeString,
    49  				Required: true,
    50  				ForceNew: true,
    51  			},
    52  			"ike_version": &schema.Schema{
    53  				Type:     schema.TypeInt,
    54  				Optional: true,
    55  				Default:  2,
    56  				ForceNew: true,
    57  			},
    58  			"detailed_status": &schema.Schema{
    59  				Type:     schema.TypeString,
    60  				Computed: true,
    61  			},
    62  			"self_link": &schema.Schema{
    63  				Type:     schema.TypeString,
    64  				Computed: true,
    65  			},
    66  		},
    67  	}
    68  }
    69  
    70  func resourceComputeVpnTunnelCreate(d *schema.ResourceData, meta interface{}) error {
    71  	config := meta.(*Config)
    72  
    73  	name := d.Get("name").(string)
    74  	region := getOptionalRegion(d, config)
    75  	peerIp := d.Get("peer_ip").(string)
    76  	sharedSecret := d.Get("shared_secret").(string)
    77  	targetVpnGateway := d.Get("target_vpn_gateway").(string)
    78  	ikeVersion := d.Get("ike_version").(int)
    79  	project := config.Project
    80  
    81  	if ikeVersion < 1 || ikeVersion > 2 {
    82  		return fmt.Errorf("Only IKE version 1 or 2 supported, not %d", ikeVersion)
    83  	}
    84  
    85  	vpnTunnelsService := compute.NewVpnTunnelsService(config.clientCompute)
    86  
    87  	vpnTunnel := &compute.VpnTunnel{
    88  		Name:             name,
    89  		PeerIp:           peerIp,
    90  		SharedSecret:     sharedSecret,
    91  		TargetVpnGateway: targetVpnGateway,
    92  		IkeVersion:       int64(ikeVersion),
    93  	}
    94  
    95  	if v, ok := d.GetOk("description"); ok {
    96  		vpnTunnel.Description = v.(string)
    97  	}
    98  
    99  	op, err := vpnTunnelsService.Insert(project, region, vpnTunnel).Do()
   100  	if err != nil {
   101  		return fmt.Errorf("Error Inserting VPN Tunnel %s : %s", name, err)
   102  	}
   103  
   104  	err = computeOperationWaitRegion(config, op, region, "Inserting VPN Tunnel")
   105  	if err != nil {
   106  		return fmt.Errorf("Error Waiting to Insert VPN Tunnel %s: %s", name, err)
   107  	}
   108  
   109  	return resourceComputeVpnTunnelRead(d, meta)
   110  }
   111  
   112  func resourceComputeVpnTunnelRead(d *schema.ResourceData, meta interface{}) error {
   113  	config := meta.(*Config)
   114  
   115  	name := d.Get("name").(string)
   116  	region := d.Get("region").(string)
   117  	project := config.Project
   118  
   119  	vpnTunnelsService := compute.NewVpnTunnelsService(config.clientCompute)
   120  
   121  	vpnTunnel, err := vpnTunnelsService.Get(project, region, name).Do()
   122  	if err != nil {
   123  		if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
   124  			log.Printf("[WARN] Removing VPN Tunnel %q because it's gone", d.Get("name").(string))
   125  			// The resource doesn't exist anymore
   126  			d.SetId("")
   127  
   128  			return nil
   129  		}
   130  
   131  		return fmt.Errorf("Error Reading VPN Tunnel %s: %s", name, err)
   132  	}
   133  
   134  	d.Set("detailed_status", vpnTunnel.DetailedStatus)
   135  	d.Set("self_link", vpnTunnel.SelfLink)
   136  
   137  	d.SetId(name)
   138  
   139  	return nil
   140  }
   141  
   142  func resourceComputeVpnTunnelDelete(d *schema.ResourceData, meta interface{}) error {
   143  	config := meta.(*Config)
   144  
   145  	name := d.Get("name").(string)
   146  	region := d.Get("region").(string)
   147  	project := config.Project
   148  
   149  	vpnTunnelsService := compute.NewVpnTunnelsService(config.clientCompute)
   150  
   151  	op, err := vpnTunnelsService.Delete(project, region, name).Do()
   152  	if err != nil {
   153  		return fmt.Errorf("Error Reading VPN Tunnel %s: %s", name, err)
   154  	}
   155  
   156  	err = computeOperationWaitRegion(config, op, region, "Deleting VPN Tunnel")
   157  	if err != nil {
   158  		return fmt.Errorf("Error Waiting to Delete VPN Tunnel %s: %s", name, err)
   159  	}
   160  
   161  	return nil
   162  }