github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/builtin/providers/azurerm/resource_arm_virtual_network_peering.go (about)

     1  package azurerm
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"net/http"
     7  	"sync"
     8  
     9  	"github.com/Azure/azure-sdk-for-go/arm/network"
    10  	"github.com/hashicorp/terraform/helper/schema"
    11  )
    12  
    13  // peerMutex is used to prevet multiple Peering resources being creaed, updated
    14  // or deleted at the same time
    15  var peerMutex = &sync.Mutex{}
    16  
    17  func resourceArmVirtualNetworkPeering() *schema.Resource {
    18  	return &schema.Resource{
    19  		Create: resourceArmVirtualNetworkPeeringCreate,
    20  		Read:   resourceArmVirtualNetworkPeeringRead,
    21  		Update: resourceArmVirtualNetworkPeeringCreate,
    22  		Delete: resourceArmVirtualNetworkPeeringDelete,
    23  		Importer: &schema.ResourceImporter{
    24  			State: schema.ImportStatePassthrough,
    25  		},
    26  
    27  		Schema: map[string]*schema.Schema{
    28  			"name": {
    29  				Type:     schema.TypeString,
    30  				Required: true,
    31  				ForceNew: true,
    32  			},
    33  
    34  			"resource_group_name": {
    35  				Type:     schema.TypeString,
    36  				Required: true,
    37  				ForceNew: true,
    38  			},
    39  
    40  			"virtual_network_name": {
    41  				Type:     schema.TypeString,
    42  				Required: true,
    43  				ForceNew: true,
    44  			},
    45  
    46  			"remote_virtual_network_id": {
    47  				Type:     schema.TypeString,
    48  				Required: true,
    49  				ForceNew: true,
    50  			},
    51  
    52  			"allow_virtual_network_access": {
    53  				Type:     schema.TypeBool,
    54  				Optional: true,
    55  				Computed: true,
    56  			},
    57  
    58  			"allow_forwarded_traffic": {
    59  				Type:     schema.TypeBool,
    60  				Optional: true,
    61  				Computed: true,
    62  			},
    63  
    64  			"allow_gateway_transit": {
    65  				Type:     schema.TypeBool,
    66  				Optional: true,
    67  				Computed: true,
    68  			},
    69  
    70  			"use_remote_gateways": {
    71  				Type:     schema.TypeBool,
    72  				Optional: true,
    73  				Computed: true,
    74  			},
    75  		},
    76  	}
    77  }
    78  
    79  func resourceArmVirtualNetworkPeeringCreate(d *schema.ResourceData, meta interface{}) error {
    80  	client := meta.(*ArmClient).vnetPeeringsClient
    81  
    82  	log.Printf("[INFO] preparing arguments for Azure ARM virtual network peering creation.")
    83  
    84  	name := d.Get("name").(string)
    85  	vnetName := d.Get("virtual_network_name").(string)
    86  	resGroup := d.Get("resource_group_name").(string)
    87  
    88  	peer := network.VirtualNetworkPeering{
    89  		Name: &name,
    90  		VirtualNetworkPeeringPropertiesFormat: getVirtualNetworkPeeringProperties(d),
    91  	}
    92  
    93  	peerMutex.Lock()
    94  	defer peerMutex.Unlock()
    95  
    96  	_, error := client.CreateOrUpdate(resGroup, vnetName, name, peer, make(chan struct{}))
    97  	err := <-error
    98  	if err != nil {
    99  		return err
   100  	}
   101  
   102  	read, err := client.Get(resGroup, vnetName, name)
   103  	if err != nil {
   104  		return err
   105  	}
   106  	if read.ID == nil {
   107  		return fmt.Errorf("Cannot read Virtual Network Peering %s (resource group %s) ID", name, resGroup)
   108  	}
   109  
   110  	d.SetId(*read.ID)
   111  
   112  	return resourceArmVirtualNetworkPeeringRead(d, meta)
   113  }
   114  
   115  func resourceArmVirtualNetworkPeeringRead(d *schema.ResourceData, meta interface{}) error {
   116  	client := meta.(*ArmClient).vnetPeeringsClient
   117  
   118  	id, err := parseAzureResourceID(d.Id())
   119  	if err != nil {
   120  		return err
   121  	}
   122  	resGroup := id.ResourceGroup
   123  	vnetName := id.Path["virtualNetworks"]
   124  	name := id.Path["virtualNetworkPeerings"]
   125  
   126  	resp, err := client.Get(resGroup, vnetName, name)
   127  	if err != nil {
   128  		if resp.StatusCode == http.StatusNotFound {
   129  			d.SetId("")
   130  			return nil
   131  		}
   132  		return fmt.Errorf("Error making Read request on Azure virtual network peering %s: %s", name, err)
   133  	}
   134  
   135  	peer := *resp.VirtualNetworkPeeringPropertiesFormat
   136  
   137  	// update appropriate values
   138  	d.Set("resource_group_name", resGroup)
   139  	d.Set("name", resp.Name)
   140  	d.Set("virtual_network_name", vnetName)
   141  	d.Set("allow_virtual_network_access", peer.AllowVirtualNetworkAccess)
   142  	d.Set("allow_forwarded_traffic", peer.AllowForwardedTraffic)
   143  	d.Set("allow_gateway_transit", peer.AllowGatewayTransit)
   144  	d.Set("use_remote_gateways", peer.UseRemoteGateways)
   145  	d.Set("remote_virtual_network_id", peer.RemoteVirtualNetwork.ID)
   146  
   147  	return nil
   148  }
   149  
   150  func resourceArmVirtualNetworkPeeringDelete(d *schema.ResourceData, meta interface{}) error {
   151  	client := meta.(*ArmClient).vnetPeeringsClient
   152  
   153  	id, err := parseAzureResourceID(d.Id())
   154  	if err != nil {
   155  		return err
   156  	}
   157  	resGroup := id.ResourceGroup
   158  	vnetName := id.Path["virtualNetworks"]
   159  	name := id.Path["virtualNetworkPeerings"]
   160  
   161  	peerMutex.Lock()
   162  	defer peerMutex.Unlock()
   163  
   164  	_, error := client.Delete(resGroup, vnetName, name, make(chan struct{}))
   165  	err = <-error
   166  
   167  	return err
   168  }
   169  
   170  func getVirtualNetworkPeeringProperties(d *schema.ResourceData) *network.VirtualNetworkPeeringPropertiesFormat {
   171  	allowVirtualNetworkAccess := d.Get("allow_virtual_network_access").(bool)
   172  	allowForwardedTraffic := d.Get("allow_forwarded_traffic").(bool)
   173  	allowGatewayTransit := d.Get("allow_gateway_transit").(bool)
   174  	useRemoteGateways := d.Get("use_remote_gateways").(bool)
   175  	remoteVirtualNetworkID := d.Get("remote_virtual_network_id").(string)
   176  
   177  	return &network.VirtualNetworkPeeringPropertiesFormat{
   178  		AllowVirtualNetworkAccess: &allowVirtualNetworkAccess,
   179  		AllowForwardedTraffic:     &allowForwardedTraffic,
   180  		AllowGatewayTransit:       &allowGatewayTransit,
   181  		UseRemoteGateways:         &useRemoteGateways,
   182  		RemoteVirtualNetwork: &network.SubResource{
   183  			ID: &remoteVirtualNetworkID,
   184  		},
   185  	}
   186  }