public/terraform-provider-google
0
0
Fork 0
mirror of https://github.com/letic/terraform-provider-google.git synced 2024-07-03 08:42:39 +00:00
Code Issues Projects Releases Wiki Activity

wip: review changes:

Browse Source 
- config.clientCompute.Routers
- peer fields renamed
- more consistent logging
- better handling of SetId for error handling
- function for router locks
- test configs as functions
- simplify exists logic
- use getProject, getRegion logic on acceptance tests
- CheckDestroy for peers an interfaces
- dynamic router name for tunnel test
- extra fields for BgpPeer
- resource documentation
This commit is contained in:
Roberto Jung Drebes 2017-04-28 21:17:08 +02:00
parent 808cbd35dd
commit 4aa863b26b
12 changed files with 832 additions and 653 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
import_compute_router_interface_test.go
View File

@ -1,20 +1,32 @@
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccComputeRouterInterface_import(t *testing.T) {
resourceName := "google_compute_router_interface.foobar"
network := fmt.Sprintf("router-interface-import-test-%s", acctest.RandString(10))
subnet := fmt.Sprintf("router-interface-import-test-%s", acctest.RandString(10))
address := fmt.Sprintf("router-interface-import-test-%s", acctest.RandString(10))
gateway := fmt.Sprintf("router-interface-import-test-%s", acctest.RandString(10))
espRule := fmt.Sprintf("router-interface-import-test-%s", acctest.RandString(10))
udp500Rule := fmt.Sprintf("router-interface-import-test-%s", acctest.RandString(10))
udp4500Rule := fmt.Sprintf("router-interface-import-test-%s", acctest.RandString(10))
router := fmt.Sprintf("router-interface-import-test-%s", acctest.RandString(10))
tunnel := fmt.Sprintf("router-interface-import-test-%s", acctest.RandString(10))
iface := fmt.Sprintf("router-interface-import-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeRouterInterface_basic,
Config: testAccComputeRouterInterfaceBasic(network, subnet, address, gateway, espRule, udp500Rule,
udp4500Rule, router, tunnel, iface),
},
resource.TestStep{

17
import_compute_router_peer_test.go
View File

@ -1,20 +1,33 @@
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccComputeRouterPeer_import(t *testing.T) {
resourceName := "google_compute_router_peer.foobar"
network := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
subnet := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
address := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
gateway := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
espRule := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
udp500Rule := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
udp4500Rule := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
router := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
tunnel := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
iface := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
peer := fmt.Sprintf("router-peer-import-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeRouterPeer_basic,
Config: testAccComputeRouterPeerBasic(network, subnet, address, gateway, espRule, udp500Rule,
udp4500Rule, router, tunnel, iface, peer),
},
resource.TestStep{

8
import_compute_router_test.go
View File

@ -1,21 +1,25 @@
package google
import (
"fmt"
"testing"
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
)
func TestAccComputeRouter_import(t *testing.T) {
resourceName := "google_compute_router.foobar"
network := fmt.Sprintf("router-import-test-%s", acctest.RandString(10))
subnet := fmt.Sprintf("router-import-test-%s", acctest.RandString(10))
router := fmt.Sprintf("router-import-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckComputeRouterDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeRouter_networkLink,
Config: testAccComputeRouterNetworkLink(network, subnet, router),
},
resource.TestStep{

4
provider.go
View File

@ -256,3 +256,7 @@ func getNetworkNameFromSelfLink(network string) (string, error) {
return network, nil
}
func getRouterLockName(region string, router string) string {
return fmt.Sprintf("router/%s/%s", region, router)
}

23
provider_test.go
View File

@ -1,6 +1,7 @@
package google
import (
"fmt"
"io/ioutil"
"os"
"strings"
@ -87,3 +88,25 @@ func TestProvider_getRegionFromZone(t *testing.T) {
t.Fatalf("Region (%s) did not match expected value: %s", actual, expected)
}
}
// getTestRegion has the same logic as the provider's getRegion, to be used in tests.
func getTestRegion(is *terraform.InstanceState, config *Config) (string, error) {
if res, ok := is.Attributes["region"]; ok {
return res, nil
}
if config.Region != "" {
return config.Region, nil
}
return "", fmt.Errorf("%q: required field is not set", "region")
}
// getTestProject has the same logic as the provider's getProject, to be used in tests.
func getTestProject(is *terraform.InstanceState, config *Config) (string, error) {
if res, ok := is.Attributes["project"]; ok {
return res, nil
}
if config.Project != "" {
return config.Project, nil
}
return "", fmt.Errorf("%q: required field is not set", "project")
}

26
resource_compute_router.go
View File

@ -93,15 +93,15 @@ func resourceComputeRouterCreate(d *schema.ResourceData, meta interface{}) error
name := d.Get("name").(string)
routerId := fmt.Sprintf("router/%s/%s", region, name)
mutexKV.Lock(routerId)
defer mutexKV.Unlock(routerId)
routerLock := getRouterLockName(region, name)
mutexKV.Lock(routerLock)
defer mutexKV.Unlock(routerLock)
network, err := getNetworkLink(d, config, "network")
if err != nil {
return err
}
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
router := &compute.Router{
Name: name,
@ -127,9 +127,10 @@ func resourceComputeRouterCreate(d *schema.ResourceData, meta interface{}) error
if err != nil {
return fmt.Errorf("Error Inserting Router %s into network %s: %s", name, network, err)
}
d.SetId(fmt.Sprintf("%s/%s", region, name))
err = computeOperationWaitRegion(config, op, project, region, "Inserting Router")
if err != nil {
d.SetId("")
return fmt.Errorf("Error Waiting to Insert Router %s into network %s: %s", name, network, err)
}
@ -151,12 +152,12 @@ func resourceComputeRouterRead(d *schema.ResourceData, meta interface{}) error {
}
name := d.Get("name").(string)
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
router, err := routersService.Get(project, region, name).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
log.Printf("[WARN] Removing Router %q because it's gone", d.Get("name").(string))
log.Printf("[WARN] Removing router %s/%s because it is gone", region, name)
d.SetId("")
return nil
@ -172,6 +173,8 @@ func resourceComputeRouterRead(d *schema.ResourceData, meta interface{}) error {
d.Set("network", router.Network)
}
d.Set("name", router.Name)
d.Set("description", router.Description)
d.Set("region", region)
d.Set("bgp", flattenAsn(router.Bgp.Asn))
d.SetId(fmt.Sprintf("%s/%s", region, name))
@ -195,11 +198,11 @@ func resourceComputeRouterDelete(d *schema.ResourceData, meta interface{}) error
name := d.Get("name").(string)
routerId := fmt.Sprintf("router/%s/%s", region, name)
mutexKV.Lock(routerId)
defer mutexKV.Unlock(routerId)
routerLock := getRouterLockName(region, name)
mutexKV.Lock(routerLock)
defer mutexKV.Unlock(routerLock)
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
op, err := routersService.Delete(project, region, name).Do()
if err != nil {
@ -211,6 +214,7 @@ func resourceComputeRouterDelete(d *schema.ResourceData, meta interface{}) error
return fmt.Errorf("Error Waiting to Delete Router %s: %s", name, err)
}
d.SetId("")
return nil
}

150
resource_compute_router_interface.go
View File

@ -75,15 +75,15 @@ func resourceComputeRouterInterfaceCreate(d *schema.ResourceData, meta interface
routerName := d.Get("router").(string)
ifaceName := d.Get("name").(string)
routerId := fmt.Sprintf("router/%s/%s", region, routerName)
mutexKV.Lock(routerId)
defer mutexKV.Unlock(routerId)
routerLock := getRouterLockName(region, routerName)
mutexKV.Lock(routerLock)
defer mutexKV.Unlock(routerLock)
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
router, err := routersService.Get(project, region, routerName).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
log.Printf("[WARN] Removing router interface because its router %s/%s is gone", region, routerName)
log.Printf("[WARN] Removing router interface %s because its router %s/%s is gone", ifaceName, region, routerName)
d.SetId("")
return nil
@ -92,53 +92,42 @@ func resourceComputeRouterInterfaceCreate(d *schema.ResourceData, meta interface
return fmt.Errorf("Error Reading router %s/%s: %s", region, routerName, err)
}
var ifaceExists bool = false
var ifaces []*compute.RouterInterface = router.Interfaces
ifaces := router.Interfaces
for _, iface := range ifaces {
if iface.Name == ifaceName {
ifaceExists = true
break
d.SetId("")
return fmt.Errorf("Router %s has interface %s already", routerName, ifaceName)
}
}
if !ifaceExists {
vpnTunnel, err := getVpnTunnelLink(config, project, region, d.Get("vpn_tunnel").(string))
if err != nil {
return err
}
vpnTunnel, err := getVpnTunnelLink(config, project, region, d.Get("vpn_tunnel").(string))
if err != nil {
return err
}
iface := &compute.RouterInterface{Name: ifaceName,
LinkedVpnTunnel: vpnTunnel}
iface := &compute.RouterInterface{Name: ifaceName,
LinkedVpnTunnel: vpnTunnel}
if v, ok := d.GetOk("ip_range"); ok {
iface.IpRange = v.(string)
}
if v, ok := d.GetOk("ip_range"); ok {
iface.IpRange = v.(string)
}
log.Printf("[INFO] Adding interface %s", ifaceName)
ifaces = append(ifaces, iface)
patchRouter := &compute.Router{
Interfaces: ifaces,
}
log.Printf(
"[INFO] Adding interface %s", ifaceName)
ifaces = append(ifaces, iface)
patchRouter := &compute.Router{
Interfaces: ifaces,
}
log.Printf("[DEBUG] Updating router %s/%s with interfaces: %+v", region, routerName, ifaces)
op, err := routersService.Patch(project, region, router.Name, patchRouter).Do()
if err != nil {
return fmt.Errorf("Error patching router %s/%s: %s", region, routerName, err)
}
err = computeOperationWaitRegion(config, op, project, region, "Patching router")
if err != nil {
return fmt.Errorf("Error waiting to patch router %s/%s: %s", region, routerName, err)
}
d.SetId(fmt.Sprintf("%s/%s/%s", region, routerName, ifaceName))
} else {
log.Printf("[DEBUG] Router %s has interface %s already", routerName, ifaceName)
log.Printf("[DEBUG] Updating router %s/%s with interfaces: %+v", region, routerName, ifaces)
op, err := routersService.Patch(project, region, router.Name, patchRouter).Do()
if err != nil {
return fmt.Errorf("Error patching router %s/%s: %s", region, routerName, err)
}
d.SetId(fmt.Sprintf("%s/%s/%s", region, routerName, ifaceName))
err = computeOperationWaitRegion(config, op, project, region, "Patching router")
if err != nil {
d.SetId("")
return fmt.Errorf("Error waiting to patch router %s/%s: %s", region, routerName, err)
}
return resourceComputeRouterInterfaceRead(d, meta)
@ -161,11 +150,11 @@ func resourceComputeRouterInterfaceRead(d *schema.ResourceData, meta interface{}
routerName := d.Get("router").(string)
ifaceName := d.Get("name").(string)
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
router, err := routersService.Get(project, region, routerName).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
log.Printf("[WARN] Removing router interface because its router %s/%s is gone", region, routerName)
log.Printf("[WARN] Removing router interface %s because its router %s/%s is gone", ifaceName, region, routerName)
d.SetId("")
return nil
@ -174,13 +163,9 @@ func resourceComputeRouterInterfaceRead(d *schema.ResourceData, meta interface{}
return fmt.Errorf("Error Reading router %s/%s: %s", region, routerName, err)
}
var ifaceFound bool = false
var ifaces []*compute.RouterInterface = router.Interfaces
for _, iface := range ifaces {
for _, iface := range router.Interfaces {
if iface.Name == ifaceName {
ifaceFound = true
d.SetId(fmt.Sprintf("%s/%s/%s", region, routerName, ifaceName))
// if we don't have a tunnel (when importing), set it to the URI returned from the server
if _, ok := d.GetOk("vpn_tunnel"); !ok {
@ -191,13 +176,12 @@ func resourceComputeRouterInterfaceRead(d *schema.ResourceData, meta interface{}
d.Set("vpn_tunnel", vpnTunnelName)
}
d.Set("ip_range", iface.IpRange)
return nil
}
}
if !ifaceFound {
log.Printf("[WARN] Removing router interface %s/%s/%s because it is gone", region, routerName, ifaceName)
d.SetId("")
}
log.Printf("[WARN] Removing router interface %s/%s/%s because it is gone", region, routerName, ifaceName)
d.SetId("")
return nil
}
@ -218,15 +202,15 @@ func resourceComputeRouterInterfaceDelete(d *schema.ResourceData, meta interface
routerName := d.Get("router").(string)
ifaceName := d.Get("name").(string)
routerId := fmt.Sprintf("router/%s/%s", region, routerName)
mutexKV.Lock(routerId)
defer mutexKV.Unlock(routerId)
routerLock := getRouterLockName(region, routerName)
mutexKV.Lock(routerLock)
defer mutexKV.Unlock(routerLock)
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
router, err := routersService.Get(project, region, routerName).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
log.Printf("[WARN] Removing router interface because its router %d is gone", d.Get("router").(string))
log.Printf("[WARN] Removing router interface %s because its router %s/%s is gone", ifaceName, region, routerName)
return nil
}
@ -234,11 +218,10 @@ func resourceComputeRouterInterfaceDelete(d *schema.ResourceData, meta interface
return fmt.Errorf("Error Reading Router %s: %s", routerName, err)
}
var ifaceFound bool = false
var ifaceFound bool
var oldIfaces []*compute.RouterInterface = router.Interfaces
var newIfaces []*compute.RouterInterface = make([]*compute.RouterInterface, len(router.Interfaces))
for _, iface := range oldIfaces {
newIfaces := make([]*compute.RouterInterface, 0, len(router.Interfaces))
for _, iface := range router.Interfaces {
if iface.Name == ifaceName {
ifaceFound = true
@ -248,29 +231,30 @@ func resourceComputeRouterInterfaceDelete(d *schema.ResourceData, meta interface
}
}
if ifaceFound {
log.Printf(
"[INFO] Removing interface %s", ifaceName)
patchRouter := &compute.Router{
Interfaces: newIfaces,
}
log.Printf("[DEBUG] Updating router %s/%s with interfaces: %+v", region, routerName, newIfaces)
op, err := routersService.Patch(project, region, router.Name, patchRouter).Do()
if err != nil {
return fmt.Errorf("Error patching router %s/%s: %s", region, routerName, err)
}
err = computeOperationWaitRegion(config, op, project, region, "Patching router")
if err != nil {
return fmt.Errorf("Error waiting to patch router %s/%s: %s", region, routerName, err)
}
} else {
if !ifaceFound {
log.Printf("[DEBUG] Router %s/%s had no interface %s already", region, routerName, ifaceName)
d.SetId("")
return nil
}
log.Printf(
"[INFO] Removing interface %s from router %s/%s", ifaceName, region, routerName)
patchRouter := &compute.Router{
Interfaces: newIfaces,
}
log.Printf("[DEBUG] Updating router %s/%s with interfaces: %+v", region, routerName, newIfaces)
op, err := routersService.Patch(project, region, router.Name, patchRouter).Do()
if err != nil {
return fmt.Errorf("Error patching router %s/%s: %s", region, routerName, err)
}
err = computeOperationWaitRegion(config, op, project, region, "Patching router")
if err != nil {
return fmt.Errorf("Error waiting to patch router %s/%s: %s", region, routerName, err)
}
d.SetId("")
return nil
}

368
resource_compute_router_interface_test.go
View File

@ -7,42 +7,94 @@ import (
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/terraform"
"google.golang.org/api/compute/v1"
)
func TestAccComputeRouterInterface_basic(t *testing.T) {
network := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
subnet := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
address := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
gateway := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
espRule := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
udp500Rule := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
udp4500Rule := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
router := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
tunnel := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
iface := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckComputeRouterInterfaceDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeRouterInterface_basic,
Config: testAccComputeRouterInterfaceBasic(network, subnet, address, gateway, espRule, udp500Rule,
udp4500Rule, router, tunnel, iface),
Check: testAccCheckComputeRouterInterfaceExists(
"google_compute_router_interface.foobar"),
},
resource.TestStep{
Config: testAccComputeRouterInterface_keepRouter,
Check: testAccCheckComputeRouterInterfaceDestroy(
Config: testAccComputeRouterInterfaceKeepRouter(network, subnet, address, gateway, espRule, udp500Rule,
udp4500Rule, router, tunnel),
Check: testAccCheckComputeRouterInterfaceDelete(
"google_compute_router_interface.foobar"),
},
},
})
}
func testAccCheckComputeRouterInterfaceDestroy(n string) resource.TestCheckFunc {
func testAccCheckComputeRouterInterfaceDestroy(s *terraform.State) error {
config := testAccProvider.Meta().(*Config)
routersService := config.clientCompute.Routers
for _, rs := range s.RootModule().Resources {
if rs.Type != "google_compute_router" {
continue
}
project, err := getTestProject(rs.Primary, config)
if err != nil {
return err
}
region, err := getTestRegion(rs.Primary, config)
if err != nil {
return err
}
routerName := rs.Primary.Attributes["router"]
_, err = routersService.Get(project, region, routerName).Do()
if err == nil {
return fmt.Errorf("Error, Router %s in region %s still exists",
routerName, region)
}
}
return nil
}
func testAccCheckComputeRouterInterfaceDelete(n string) resource.TestCheckFunc {
return func(s *terraform.State) error {
config := testAccProvider.Meta().(*Config)
project := config.Project
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
for _, rs := range s.RootModule().Resources {
if rs.Type != "google_compute_router_interface" {
continue
}
region := rs.Primary.Attributes["region"]
project, err := getTestProject(rs.Primary, config)
if err != nil {
return err
}
region, err := getTestRegion(rs.Primary, config)
if err != nil {
return err
}
name := rs.Primary.Attributes["name"]
routerName := rs.Primary.Attributes["router"]
@ -52,21 +104,13 @@ func testAccCheckComputeRouterInterfaceDestroy(n string) resource.TestCheckFunc
return fmt.Errorf("Error Reading Router %s: %s", routerName, err)
}
var ifaceExists bool = false
var ifaces []*compute.RouterInterface = router.Interfaces
ifaces := router.Interfaces
for _, iface := range ifaces {
if iface.Name == name {
ifaceExists = true
break
return fmt.Errorf("Interface %s still exists on router %s/%s", name, region, router.Name)
}
}
if ifaceExists {
return fmt.Errorf("Interface %s still exists on router %s", name, router.Name)
}
}
return nil
@ -85,163 +129,165 @@ func testAccCheckComputeRouterInterfaceExists(n string) resource.TestCheckFunc {
}
config := testAccProvider.Meta().(*Config)
project, err := getTestProject(rs.Primary, config)
if err != nil {
return err
}
region, err := getTestRegion(rs.Primary, config)
if err != nil {
return err
}
name := rs.Primary.Attributes["name"]
routerName := rs.Primary.Attributes["router"]
region := rs.Primary.Attributes["region"]
project := config.Project
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
router, err := routersService.Get(project, region, routerName).Do()
if err != nil {
return fmt.Errorf("Error Reading Router %s: %s", routerName, err)
}
var ifaceExists bool = false
var ifaces []*compute.RouterInterface = router.Interfaces
for _, iface := range ifaces {
for _, iface := range router.Interfaces {
if iface.Name == name {
ifaceExists = true
break
return nil
}
}
if !ifaceExists {
return fmt.Errorf("Interface %s not found for router %s", name, router.Name)
}
return nil
return fmt.Errorf("Interface %s not found for router %s", name, router.Name)
}
}
var testAccComputeRouterInterface_basic = fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "interface-test-%s"
func testAccComputeRouterInterfaceBasic(network, subnet, address, gateway, espFwRule, udp500FwRule, udp4500FwRule, router, tunnel, iface string) string {
return fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "%s"
}
resource "google_compute_subnetwork" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_address" "foobar" {
name = "%s"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_vpn_gateway" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_forwarding_rule" "foobar_esp" {
name = "%s"
region = "${google_compute_vpn_gateway.foobar.region}"
ip_protocol = "ESP"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp500" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_esp.region}"
ip_protocol = "UDP"
port_range = "500-500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp4500" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
ip_protocol = "UDP"
port_range = "4500-4500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_router" "foobar"{
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
resource "google_compute_vpn_tunnel" "foobar" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
shared_secret = "unguessable"
peer_ip = "8.8.8.8"
router = "${google_compute_router.foobar.name}"
}
resource "google_compute_router_interface" "foobar" {
name = "%s"
router = "${google_compute_router.foobar.name}"
region = "${google_compute_router.foobar.region}"
ip_range = "169.254.3.1/30"
vpn_tunnel = "${google_compute_vpn_tunnel.foobar.name}"
}
`, network, subnet, address, gateway, espFwRule, udp500FwRule, udp4500FwRule, router, tunnel, iface)
}
resource "google_compute_subnetwork" "foobar" {
name = "interface-test-%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_address" "foobar" {
name = "interface-test-%s"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_vpn_gateway" "foobar" {
name = "interface-test-%s"
network = "${google_compute_network.foobar.self_link}"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_forwarding_rule" "foobar_esp" {
name = "interface-test-%s"
region = "${google_compute_vpn_gateway.foobar.region}"
ip_protocol = "ESP"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp500" {
name = "interface-test-%s"
region = "${google_compute_forwarding_rule.foobar_esp.region}"
ip_protocol = "UDP"
port_range = "500-500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp4500" {
name = "interface-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
ip_protocol = "UDP"
port_range = "4500-4500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_router" "foobar"{
name = "interface-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
resource "google_compute_vpn_tunnel" "foobar" {
name = "interface-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
shared_secret = "unguessable"
peer_ip = "8.8.8.8"
router = "${google_compute_router.foobar.name}"
}
resource "google_compute_router_interface" "foobar" {
name = "interface-test-%s"
router = "${google_compute_router.foobar.name}"
region = "${google_compute_router.foobar.region}"
ip_range = "169.254.3.1/30"
vpn_tunnel = "${google_compute_vpn_tunnel.foobar.name}"
}`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10))
var testAccComputeRouterInterface_keepRouter = fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "interface-test-%s"
func testAccComputeRouterInterfaceKeepRouter(network, subnet, address, gateway, espFwRule, udp500FwRule, udp4500FwRule, router, tunnel string) string {
return fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "%s"
}
resource "google_compute_subnetwork" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_address" "foobar" {
name = "%s"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_vpn_gateway" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_forwarding_rule" "foobar_esp" {
name = "%s"
region = "${google_compute_vpn_gateway.foobar.region}"
ip_protocol = "ESP"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp500" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_esp.region}"
ip_protocol = "UDP"
port_range = "500-500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp4500" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
ip_protocol = "UDP"
port_range = "4500-4500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_router" "foobar"{
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
resource "google_compute_vpn_tunnel" "foobar" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
shared_secret = "unguessable"
peer_ip = "8.8.8.8"
router = "${google_compute_router.foobar.name}"
}
`, network, subnet, address, gateway, espFwRule, udp500FwRule, udp4500FwRule, router, tunnel)
}
resource "google_compute_subnetwork" "foobar" {
name = "interface-test-%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_address" "foobar" {
name = "interface-test-%s"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_vpn_gateway" "foobar" {
name = "interface-test-%s"
network = "${google_compute_network.foobar.self_link}"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_forwarding_rule" "foobar_esp" {
name = "interface-test-%s"
region = "${google_compute_vpn_gateway.foobar.region}"
ip_protocol = "ESP"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp500" {
name = "interface-test-%s"
region = "${google_compute_forwarding_rule.foobar_esp.region}"
ip_protocol = "UDP"
port_range = "500-500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp4500" {
name = "interface-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
ip_protocol = "UDP"
port_range = "4500-4500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_router" "foobar"{
name = "interface-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
resource "google_compute_vpn_tunnel" "foobar" {
name = "interface-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
shared_secret = "unguessable"
peer_ip = "8.8.8.8"
router = "${google_compute_router.foobar.name}"
}`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10), acctest.RandString(10))

175
resource_compute_router_peer.go
View File

@ -37,18 +37,29 @@ func resourceComputeRouterPeer() *schema.Resource {
ForceNew: true,
},
"ip_address": &schema.Schema{
"peer_ip_address": &schema.Schema{
Type: schema.TypeString,
Optional: true,
ForceNew: true,
},
"asn": &schema.Schema{
"peer_asn": &schema.Schema{
Type: schema.TypeInt,
Required: true,
ForceNew: true,
},
"advertised_route_priority": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
ForceNew: true,
},
"ip_address": &schema.Schema{
Type: schema.TypeString,
Computed: true,
},
"project": &schema.Schema{
Type: schema.TypeString,
Optional: true,
@ -82,15 +93,15 @@ func resourceComputeRouterPeerCreate(d *schema.ResourceData, meta interface{}) e
routerName := d.Get("router").(string)
peerName := d.Get("name").(string)
routerId := fmt.Sprintf("router/%s/%s", region, routerName)
mutexKV.Lock(routerId)
defer mutexKV.Unlock(routerId)
routerLock := getRouterLockName(region, routerName)
mutexKV.Lock(routerLock)
defer mutexKV.Unlock(routerLock)
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
router, err := routersService.Get(project, region, routerName).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
log.Printf("[WARN] Removing router peer because its router %s/%s is gone", region, routerName)
log.Printf("[WARN] Removing router peer %s because its router %s/%s is gone", peerName, region, routerName)
d.SetId("")
return nil
@ -99,54 +110,47 @@ func resourceComputeRouterPeerCreate(d *schema.ResourceData, meta interface{}) e
return fmt.Errorf("Error Reading router %s/%s: %s", region, routerName, err)
}
var peerExists bool = false
var peers []*compute.RouterBgpPeer = router.BgpPeers
peers := router.BgpPeers
for _, peer := range peers {
if peer.Name == peerName {
peerExists = true
break
d.SetId("")
return fmt.Errorf("Router %s has peer %s already", routerName, peerName)
}
}
if !peerExists {
ifaceName := d.Get("interface").(string)
ifaceName := d.Get("interface").(string)
peer := &compute.RouterBgpPeer{Name: peerName,
InterfaceName: ifaceName}
peer := &compute.RouterBgpPeer{Name: peerName,
InterfaceName: ifaceName}
if v, ok := d.GetOk("peer_ip_address"); ok {
peer.PeerIpAddress = v.(string)
}
if v, ok := d.GetOk("ip_address"); ok {
peer.PeerIpAddress = v.(string)
}
if v, ok := d.GetOk("peer_asn"); ok {
peer.PeerAsn = int64(v.(int))
}
if v, ok := d.GetOk("asn"); ok {
peer.PeerAsn = int64(v.(int))
}
if v, ok := d.GetOk("advertised_route_priority"); ok {
peer.AdvertisedRoutePriority = int64(v.(int))
}
log.Printf(
"[INFO] Adding peer %s", peerName)
peers = append(peers, peer)
patchRouter := &compute.Router{
BgpPeers: peers,
}
log.Printf("[INFO] Adding peer %s", peerName)
peers = append(peers, peer)
patchRouter := &compute.Router{
BgpPeers: peers,
}
log.Printf("[DEBUG] Updating router %s/%s with peers: %+v", region, routerName, peers)
op, err := routersService.Patch(project, region, router.Name, patchRouter).Do()
if err != nil {
return fmt.Errorf("Error patching router %s/%s: %s", region, routerName, err)
}
err = computeOperationWaitRegion(config, op, project, region, "Patching router")
if err != nil {
return fmt.Errorf("Error waiting to patch router %s/%s: %s", region, routerName, err)
}
d.SetId(fmt.Sprintf("%s/%s/%s", region, routerName, peerName))
} else {
log.Printf("[DEBUG] Router %s has peer %s already", routerName, peerName)
log.Printf("[DEBUG] Updating router %s/%s with peers: %+v", region, routerName, peers)
op, err := routersService.Patch(project, region, router.Name, patchRouter).Do()
if err != nil {
return fmt.Errorf("Error patching router %s/%s: %s", region, routerName, err)
}
d.SetId(fmt.Sprintf("%s/%s/%s", region, routerName, peerName))
err = computeOperationWaitRegion(config, op, project, region, "Patching router")
if err != nil {
d.SetId("")
return fmt.Errorf("Error waiting to patch router %s/%s: %s", region, routerName, err)
}
return resourceComputeRouterPeerRead(d, meta)
@ -169,11 +173,11 @@ func resourceComputeRouterPeerRead(d *schema.ResourceData, meta interface{}) err
routerName := d.Get("router").(string)
peerName := d.Get("name").(string)
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
router, err := routersService.Get(project, region, routerName).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
log.Printf("[WARN] Removing router peer because its router %s/%s is gone", region, routerName)
log.Printf("[WARN] Removing router peer %s because its router %s/%s is gone", peerName, region, routerName)
d.SetId("")
return nil
@ -182,24 +186,21 @@ func resourceComputeRouterPeerRead(d *schema.ResourceData, meta interface{}) err
return fmt.Errorf("Error Reading router %s/%s: %s", region, routerName, err)
}
var peerFound bool = false
var peers []*compute.RouterBgpPeer = router.BgpPeers
for _, peer := range peers {
for _, peer := range router.BgpPeers {
if peer.Name == peerName {
peerFound = true
d.SetId(fmt.Sprintf("%s/%s/%s", region, routerName, peerName))
d.Set("interface", peer.InterfaceName)
d.Set("ip_address", peer.PeerIpAddress)
d.Set("asn", peer.PeerAsn)
d.Set("peer_ip_address", peer.PeerIpAddress)
d.Set("peer_asn", peer.PeerAsn)
d.Set("advertised_route_priority", peer.AdvertisedRoutePriority)
d.Set("ip_address", peer.IpAddress)
return nil
}
}
if !peerFound {
log.Printf("[WARN] Removing router peer %s/%s/%s because it is gone", region, routerName, peerName)
d.SetId("")
}
log.Printf("[WARN] Removing router peer %s/%s/%s because it is gone", region, routerName, peerName)
d.SetId("")
return nil
}
@ -220,15 +221,15 @@ func resourceComputeRouterPeerDelete(d *schema.ResourceData, meta interface{}) e
routerName := d.Get("router").(string)
peerName := d.Get("name").(string)
routerId := fmt.Sprintf("router/%s/%s", region, routerName)
mutexKV.Lock(routerId)
defer mutexKV.Unlock(routerId)
routerLock := getRouterLockName(region, routerName)
mutexKV.Lock(routerLock)
defer mutexKV.Unlock(routerLock)
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
router, err := routersService.Get(project, region, routerName).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
log.Printf("[WARN] Removing router peer because its router %d is gone", d.Get("router").(string))
log.Printf("[WARN] Removing router peer %s because its router %s/%s is gone", peerName, region, routerName)
return nil
}
@ -236,43 +237,43 @@ func resourceComputeRouterPeerDelete(d *schema.ResourceData, meta interface{}) e
return fmt.Errorf("Error Reading Router %s: %s", routerName, err)
}
var peerFound bool = false
var peerFound bool
var oldIfaces []*compute.RouterBgpPeer = router.BgpPeers
var newIfaces []*compute.RouterBgpPeer = make([]*compute.RouterBgpPeer, len(router.BgpPeers))
for _, peer := range oldIfaces {
var newPeers []*compute.RouterBgpPeer = make([]*compute.RouterBgpPeer, 0, len(router.BgpPeers))
for _, peer := range router.BgpPeers {
if peer.Name == peerName {
peerFound = true
continue
} else {
newIfaces = append(newIfaces, peer)
newPeers = append(newPeers, peer)
}
}
if peerFound {
log.Printf(
"[INFO] Removing peer %s", peerName)
patchRouter := &compute.Router{
BgpPeers: newIfaces,
}
log.Printf("[DEBUG] Updating router %s/%s with peers: %+v", region, routerName, newIfaces)
op, err := routersService.Patch(project, region, router.Name, patchRouter).Do()
if err != nil {
return fmt.Errorf("Error patching router %s/%s: %s", region, routerName, err)
}
err = computeOperationWaitRegion(config, op, project, region, "Patching router")
if err != nil {
return fmt.Errorf("Error waiting to patch router %s/%s: %s", region, routerName, err)
}
} else {
if !peerFound {
log.Printf("[DEBUG] Router %s/%s had no peer %s already", region, routerName, peerName)
d.SetId("")
return nil
}
log.Printf(
"[INFO] Removing peer %s from router %s/%s", peerName, region, routerName)
patchRouter := &compute.Router{
BgpPeers: newPeers,
}
log.Printf("[DEBUG] Updating router %s/%s with peers: %+v", region, routerName, newPeers)
op, err := routersService.Patch(project, region, router.Name, patchRouter).Do()
if err != nil {
return fmt.Errorf("Error patching router %s/%s: %s", region, routerName, err)
}
err = computeOperationWaitRegion(config, op, project, region, "Patching router")
if err != nil {
return fmt.Errorf("Error waiting to patch router %s/%s: %s", region, routerName, err)
}
d.SetId("")
return nil
}

401
resource_compute_router_peer_test.go
View File

@ -7,42 +7,95 @@ import (
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/terraform"
"google.golang.org/api/compute/v1"
)
func TestAccComputeRouterPeer_basic(t *testing.T) {
network := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
subnet := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
address := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
gateway := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
espRule := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
udp500Rule := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
udp4500Rule := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
router := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
tunnel := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
iface := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
peer := fmt.Sprintf("router-peer-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckComputeRouterPeerDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeRouterPeer_basic,
Config: testAccComputeRouterPeerBasic(network, subnet, address, gateway, espRule, udp500Rule,
udp4500Rule, router, tunnel, iface, peer),
Check: testAccCheckComputeRouterPeerExists(
"google_compute_router_peer.foobar"),
},
resource.TestStep{
Config: testAccComputeRouterPeer_keepRouter,
Check: testAccCheckComputeRouterPeerDestroy(
Config: testAccComputeRouterPeerKeepRouter(network, subnet, address, gateway, espRule, udp500Rule,
udp4500Rule, router, tunnel, iface),
Check: testAccCheckComputeRouterPeerDelete(
"google_compute_router_peer.foobar"),
},
},
})
}
func testAccCheckComputeRouterPeerDestroy(n string) resource.TestCheckFunc {
func testAccCheckComputeRouterPeerDestroy(s *terraform.State) error {
config := testAccProvider.Meta().(*Config)
routersService := config.clientCompute.Routers
for _, rs := range s.RootModule().Resources {
if rs.Type != "google_compute_router" {
continue
}
project, err := getTestProject(rs.Primary, config)
if err != nil {
return err
}
region, err := getTestRegion(rs.Primary, config)
if err != nil {
return err
}
routerName := rs.Primary.Attributes["router"]
_, err = routersService.Get(project, region, routerName).Do()
if err == nil {
return fmt.Errorf("Error, Router %s in region %s still exists",
routerName, region)
}
}
return nil
}
func testAccCheckComputeRouterPeerDelete(n string) resource.TestCheckFunc {
return func(s *terraform.State) error {
config := testAccProvider.Meta().(*Config)
project := config.Project
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
for _, rs := range s.RootModule().Resources {
if rs.Type != "google_compute_router_peer" {
continue
}
region := rs.Primary.Attributes["region"]
project, err := getTestProject(rs.Primary, config)
if err != nil {
return err
}
region, err := getTestRegion(rs.Primary, config)
if err != nil {
return err
}
name := rs.Primary.Attributes["name"]
routerName := rs.Primary.Attributes["router"]
@ -52,21 +105,13 @@ func testAccCheckComputeRouterPeerDestroy(n string) resource.TestCheckFunc {
return fmt.Errorf("Error Reading Router %s: %s", routerName, err)
}
var peerExists bool = false
var peers []*compute.RouterBgpPeer = router.BgpPeers
peers := router.BgpPeers
for _, peer := range peers {
if peer.Name == name {
peerExists = true
break
return fmt.Errorf("Peer %s still exists on router %s/%s", name, region, router.Name)
}
}
if peerExists {
return fmt.Errorf("Peer %s still exists on router %s", name, router.Name)
}
}
return nil
@ -85,179 +130,181 @@ func testAccCheckComputeRouterPeerExists(n string) resource.TestCheckFunc {
}
config := testAccProvider.Meta().(*Config)
project, err := getTestProject(rs.Primary, config)
if err != nil {
return err
}
region, err := getTestRegion(rs.Primary, config)
if err != nil {
return err
}
name := rs.Primary.Attributes["name"]
routerName := rs.Primary.Attributes["router"]
region := rs.Primary.Attributes["region"]
project := config.Project
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
router, err := routersService.Get(project, region, routerName).Do()
if err != nil {
return fmt.Errorf("Error Reading Router %s: %s", routerName, err)
}
var peerExists bool = false
var peers []*compute.RouterBgpPeer = router.BgpPeers
for _, peer := range peers {
for _, peer := range router.BgpPeers {
if peer.Name == name {
peerExists = true
break
return nil
}
}
if !peerExists {
return fmt.Errorf("Peer %s not found for router %s", name, router.Name)
}
return nil
return fmt.Errorf("Peer %s not found for router %s", name, router.Name)
}
}
var testAccComputeRouterPeer_basic = fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "peer-test-%s"
func testAccComputeRouterPeerBasic(network, subnet, address, gateway, espFwRule, udp500FwRule, udp4500FwRule, router, tunnel, iface, peer string) string {
return fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "%s"
}
resource "google_compute_subnetwork" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_address" "foobar" {
name = "%s"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_vpn_gateway" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_forwarding_rule" "foobar_esp" {
name = "%s"
region = "${google_compute_vpn_gateway.foobar.region}"
ip_protocol = "ESP"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp500" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_esp.region}"
ip_protocol = "UDP"
port_range = "500-500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp4500" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
ip_protocol = "UDP"
port_range = "4500-4500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_router" "foobar"{
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
resource "google_compute_vpn_tunnel" "foobar" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
shared_secret = "unguessable"
peer_ip = "8.8.8.8"
router = "${google_compute_router.foobar.name}"
}
resource "google_compute_router_interface" "foobar" {
name = "%s"
router = "${google_compute_router.foobar.name}"
region = "${google_compute_router.foobar.region}"
ip_range = "169.254.3.1/30"
vpn_tunnel = "${google_compute_vpn_tunnel.foobar.name}"
}
resource "google_compute_router_peer" "foobar" {
name = "%s"
router = "${google_compute_router.foobar.name}"
region = "${google_compute_router.foobar.region}"
peer_ip_address = "169.254.3.2"
peer_asn = 65515
advertised_route_priority = 100
interface = "${google_compute_router_interface.foobar.name}"
}
`, network, subnet, address, gateway, espFwRule, udp500FwRule, udp4500FwRule, router, tunnel, iface, peer)
}
resource "google_compute_subnetwork" "foobar" {
name = "peer-test-%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_address" "foobar" {
name = "peer-test-%s"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_vpn_gateway" "foobar" {
name = "peer-test-%s"
network = "${google_compute_network.foobar.self_link}"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_forwarding_rule" "foobar_esp" {
name = "peer-test-%s"
region = "${google_compute_vpn_gateway.foobar.region}"
ip_protocol = "ESP"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp500" {
name = "peer-test-%s"
region = "${google_compute_forwarding_rule.foobar_esp.region}"
ip_protocol = "UDP"
port_range = "500-500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp4500" {
name = "peer-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
ip_protocol = "UDP"
port_range = "4500-4500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_router" "foobar"{
name = "peer-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
resource "google_compute_vpn_tunnel" "foobar" {
name = "peer-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
shared_secret = "unguessable"
peer_ip = "8.8.8.8"
router = "${google_compute_router.foobar.name}"
}
resource "google_compute_router_interface" "foobar" {
name = "peer-test-%s"
router = "${google_compute_router.foobar.name}"
region = "${google_compute_router.foobar.region}"
ip_range = "169.254.3.1/30"
vpn_tunnel = "${google_compute_vpn_tunnel.foobar.name}"
}
resource "google_compute_router_peer" "foobar" {
name = "peer-test-%s"
router = "${google_compute_router.foobar.name}"
region = "${google_compute_router.foobar.region}"
ip_address = "169.254.3.2"
asn = 65515
interface = "${google_compute_router_interface.foobar.name}"
}`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10))
var testAccComputeRouterPeer_keepRouter = fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "peer-test-%s"
func testAccComputeRouterPeerKeepRouter(network, subnet, address, gateway, espFwRule, udp500FwRule, udp4500FwRule, router, tunnel, iface string) string {
return fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "%s"
}
resource "google_compute_subnetwork" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_address" "foobar" {
name = "%s"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_vpn_gateway" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_forwarding_rule" "foobar_esp" {
name = "%s"
region = "${google_compute_vpn_gateway.foobar.region}"
ip_protocol = "ESP"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp500" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_esp.region}"
ip_protocol = "UDP"
port_range = "500-500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp4500" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
ip_protocol = "UDP"
port_range = "4500-4500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_router" "foobar"{
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
resource "google_compute_vpn_tunnel" "foobar" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
shared_secret = "unguessable"
peer_ip = "8.8.8.8"
router = "${google_compute_router.foobar.name}"
}
resource "google_compute_router_interface" "foobar" {
name = "%s"
router = "${google_compute_router.foobar.name}"
region = "${google_compute_router.foobar.region}"
ip_range = "169.254.3.1/30"
vpn_tunnel = "${google_compute_vpn_tunnel.foobar.name}"
}
`, network, subnet, address, gateway, espFwRule, udp500FwRule, udp4500FwRule, router, tunnel, iface)
}
resource "google_compute_subnetwork" "foobar" {
name = "peer-test-%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_address" "foobar" {
name = "peer-test-%s"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_vpn_gateway" "foobar" {
name = "peer-test-%s"
network = "${google_compute_network.foobar.self_link}"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_forwarding_rule" "foobar_esp" {
name = "peer-test-%s"
region = "${google_compute_vpn_gateway.foobar.region}"
ip_protocol = "ESP"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp500" {
name = "peer-test-%s"
region = "${google_compute_forwarding_rule.foobar_esp.region}"
ip_protocol = "UDP"
port_range = "500-500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp4500" {
name = "peer-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
ip_protocol = "UDP"
port_range = "4500-4500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_router" "foobar"{
name = "peer-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
resource "google_compute_vpn_tunnel" "foobar" {
name = "peer-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
shared_secret = "unguessable"
peer_ip = "8.8.8.8"
router = "${google_compute_router.foobar.name}"
}
resource "google_compute_router_interface" "foobar" {
name = "peer-test-%s"
router = "${google_compute_router.foobar.name}"
region = "${google_compute_router.foobar.region}"
ip_range = "169.254.3.1/30"
vpn_tunnel = "${google_compute_vpn_tunnel.foobar.name}"
}`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10))

164
resource_compute_router_test.go
View File

@ -7,18 +7,19 @@ import (
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/terraform"
"google.golang.org/api/compute/v1"
)
func TestAccComputeRouter_basic(t *testing.T) {
network := fmt.Sprintf("router-test-%s", acctest.RandString(10))
subnet := fmt.Sprintf("router-test-%s", acctest.RandString(10))
router := fmt.Sprintf("router-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckComputeRouterDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeRouter_basic,
Config: testAccComputeRouterBasic(network, subnet, router),
Check: resource.ComposeTestCheckFunc(
testAccCheckComputeRouterExists(
"google_compute_router.foobar"),
@ -31,13 +32,16 @@ func TestAccComputeRouter_basic(t *testing.T) {
}
func TestAccComputeRouter_noRegion(t *testing.T) {
network := fmt.Sprintf("router-test-%s", acctest.RandString(10))
subnet := fmt.Sprintf("router-test-%s", acctest.RandString(10))
router := fmt.Sprintf("router-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckComputeRouterDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeRouter_noRegion,
Config: testAccComputeRouterNoRegion(network, subnet, router),
Check: resource.ComposeTestCheckFunc(
testAccCheckComputeRouterExists(
"google_compute_router.foobar"),
@ -50,13 +54,16 @@ func TestAccComputeRouter_noRegion(t *testing.T) {
}
func TestAccComputeRouter_networkLink(t *testing.T) {
network := fmt.Sprintf("router-test-%s", acctest.RandString(10))
subnet := fmt.Sprintf("router-test-%s", acctest.RandString(10))
router := fmt.Sprintf("router-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckComputeRouterDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeRouter_networkLink,
Config: testAccComputeRouterNetworkLink(network, subnet, router),
Check: testAccCheckComputeRouterExists(
"google_compute_router.foobar"),
},
@ -66,19 +73,27 @@ func TestAccComputeRouter_networkLink(t *testing.T) {
func testAccCheckComputeRouterDestroy(s *terraform.State) error {
config := testAccProvider.Meta().(*Config)
project := config.Project
routersService := compute.NewRoutersService(config.clientCompute)
routersService := config.clientCompute.Routers
for _, rs := range s.RootModule().Resources {
if rs.Type != "google_compute_router" {
continue
}
region := rs.Primary.Attributes["region"]
project, err := getTestProject(rs.Primary, config)
if err != nil {
return err
}
region, err := getTestRegion(rs.Primary, config)
if err != nil {
return err
}
name := rs.Primary.Attributes["name"]
_, err := routersService.Get(project, region, name).Do()
_, err = routersService.Get(project, region, name).Do()
if err == nil {
return fmt.Errorf("Error, Router %s in region %s still exists",
@ -101,12 +116,21 @@ func testAccCheckComputeRouterExists(n string) resource.TestCheckFunc {
}
config := testAccProvider.Meta().(*Config)
name := rs.Primary.Attributes["name"]
region := rs.Primary.Attributes["region"]
project := config.Project
routersService := compute.NewRoutersService(config.clientCompute)
_, err := routersService.Get(project, region, name).Do()
project, err := getTestProject(rs.Primary, config)
if err != nil {
return err
}
region, err := getTestRegion(rs.Primary, config)
if err != nil {
return err
}
name := rs.Primary.Attributes["name"]
routersService := config.clientCompute.Routers
_, err = routersService.Get(project, region, name).Do()
if err != nil {
return fmt.Errorf("Error Reading Router %s: %s", name, err)
@ -116,61 +140,67 @@ func testAccCheckComputeRouterExists(n string) resource.TestCheckFunc {
}
}
var testAccComputeRouter_basic = fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "router-test-%s"
func testAccComputeRouterBasic(network, subnet, router string) string {
return fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "%s"
}
resource "google_compute_subnetwork" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "europe-west1"
}
resource "google_compute_router" "foobar" {
name = "%s"
region = "${google_compute_subnetwork.foobar.region}"
network = "${google_compute_network.foobar.name}"
bgp {
asn = 64514
}
}
`, network, subnet, router)
}
resource "google_compute_subnetwork" "foobar" {
name = "router-test-%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "europe-west1"
}
resource "google_compute_router" "foobar" {
name = "router-test-%s"
region = "${google_compute_subnetwork.foobar.region}"
network = "${google_compute_network.foobar.name}"
bgp {
asn = 64514
}
}
`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10))
var testAccComputeRouter_noRegion = fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "router-test-%s"
func testAccComputeRouterNoRegion(network, subnet, router string) string {
return fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "%s"
}
resource "google_compute_subnetwork" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_router" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.name}"
bgp {
asn = 64514
}
}
`, network, subnet, router)
}
resource "google_compute_subnetwork" "foobar" {
name = "router-test-%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_router" "foobar" {
name = "router-test-%s"
network = "${google_compute_network.foobar.name}"
bgp {
asn = 64514
}
}
`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10))
var testAccComputeRouter_networkLink = fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "router-test-%s"
func testAccComputeRouterNetworkLink(network, subnet, router string) string {
return fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "%s"
}
resource "google_compute_subnetwork" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_router" "foobar" {
name = "%s"
region = "${google_compute_subnetwork.foobar.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
`, network, subnet, router)
}
resource "google_compute_subnetwork" "foobar" {
name = "router-test-%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_router" "foobar" {
name = "router-test-%s"
region = "${google_compute_subnetwork.foobar.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10))

133
resource_compute_vpn_tunnel_test.go
View File

@ -33,18 +33,28 @@ func TestAccComputeVpnTunnel_basic(t *testing.T) {
}
func TestAccComputeVpnTunnel_router(t *testing.T) {
network := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
subnet := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
address := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
gateway := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
espRule := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
udp500Rule := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
udp4500Rule := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
router := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
tunnel := fmt.Sprintf("router-interface-test-%s", acctest.RandString(10))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckComputeVpnTunnelDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeVpnTunnel_router,
Config: testAccComputeVpnTunnelRouter(network, subnet, address, gateway, espRule, udp500Rule,
udp4500Rule, router, tunnel),
Check: resource.ComposeTestCheckFunc(
testAccCheckComputeVpnTunnelExists(
"google_compute_vpn_tunnel.foobar"),
resource.TestCheckResourceAttr(
"google_compute_vpn_tunnel.foobar", "router", "tunnel-test-router"),
"google_compute_vpn_tunnel.foobar", "router", router),
),
},
},
@ -173,66 +183,67 @@ resource "google_compute_vpn_tunnel" "foobar" {
acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10))
var testAccComputeVpnTunnel_router = fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "tunnel-test-%s"
func testAccComputeVpnTunnelRouter(network, subnet, address, gateway, espFwRule, udp500FwRule, udp4500FwRule, router, tunnel string) string {
return fmt.Sprintf(`
resource "google_compute_network" "foobar" {
name = "%s"
}
resource "google_compute_subnetwork" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_address" "foobar" {
name = "%s"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_vpn_gateway" "foobar" {
name = "%s"
network = "${google_compute_network.foobar.self_link}"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_forwarding_rule" "foobar_esp" {
name = "%s"
region = "${google_compute_vpn_gateway.foobar.region}"
ip_protocol = "ESP"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp500" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_esp.region}"
ip_protocol = "UDP"
port_range = "500-500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp4500" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
ip_protocol = "UDP"
port_range = "4500-4500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_router" "foobar"{
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
resource "google_compute_vpn_tunnel" "foobar" {
name = "%s"
region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
shared_secret = "unguessable"
peer_ip = "8.8.8.8"
router = "${google_compute_router.foobar.name}"
}
`, network, subnet, address, gateway, espFwRule, udp500FwRule, udp4500FwRule, router, tunnel)
}
resource "google_compute_subnetwork" "foobar" {
name = "tunnel-test-%s"
network = "${google_compute_network.foobar.self_link}"
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "google_compute_address" "foobar" {
name = "tunnel-test-%s"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_vpn_gateway" "foobar" {
name = "tunnel-test-%s"
network = "${google_compute_network.foobar.self_link}"
region = "${google_compute_subnetwork.foobar.region}"
}
resource "google_compute_forwarding_rule" "foobar_esp" {
name = "tunnel-test-%s"
region = "${google_compute_vpn_gateway.foobar.region}"
ip_protocol = "ESP"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp500" {
name = "tunnel-test-%s"
region = "${google_compute_forwarding_rule.foobar_esp.region}"
ip_protocol = "UDP"
port_range = "500-500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_forwarding_rule" "foobar_udp4500" {
name = "tunnel-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
ip_protocol = "UDP"
port_range = "4500-4500"
ip_address = "${google_compute_address.foobar.address}"
target = "${google_compute_vpn_gateway.foobar.self_link}"
}
resource "google_compute_router" "foobar"{
name = "tunnel-test-router"
region = "${google_compute_forwarding_rule.foobar_udp500.region}"
network = "${google_compute_network.foobar.self_link}"
bgp {
asn = 64514
}
}
resource "google_compute_vpn_tunnel" "foobar" {
name = "tunnel-test-%s"
region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
shared_secret = "unguessable"
peer_ip = "8.8.8.8"
router = "${google_compute_router.foobar.name}"
}`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
acctest.RandString(10), acctest.RandString(10))
var testAccComputeVpnTunnelDefaultTrafficSelectors = fmt.Sprintf(`
resource "google_compute_network" "foobar" {