github.com/atsaki/terraform@v0.4.3-0.20150919165407-25bba5967654/builtin/providers/google/resource_compute_vpn_tunnel.go (about)

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