providers/google: cloud_router

import_compute_router_interface_test.go

@@ -0,0 +1,27 @@
+package google
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccComputeRouterInterface_import(t *testing.T) {
+	resourceName := "google_compute_router_interface.foobar"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeRouterInterface_basic,
+			},
+
+			resource.TestStep{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}

import_compute_router_peer_test.go

@@ -0,0 +1,27 @@
+package google
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccComputeRouterPeer_import(t *testing.T) {
+	resourceName := "google_compute_router_peer.foobar"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeRouterPeer_basic,
+			},
+
+			resource.TestStep{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}

import_compute_router_test.go

@@ -0,0 +1,28 @@
+package google
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccComputeRouter_import(t *testing.T) {
+	resourceName := "google_compute_router.foobar"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeRouterDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeRouter_networkLink,
+			},
+
+			resource.TestStep{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}

provider.go

@@ -5,12 +5,16 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/hashicorp/terraform/helper/mutexkv"
 	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/hashicorp/terraform/terraform"
 	"google.golang.org/api/compute/v1"
 	"google.golang.org/api/googleapi"
 )
 
+// Global MutexKV
+var mutexKV = mutexkv.NewMutexKV()
+
 // Provider returns a terraform.ResourceProvider.
 func Provider() terraform.ResourceProvider {
 	return &schema.Provider{
@@ -76,6 +80,9 @@ func Provider() terraform.ResourceProvider {
 			"google_compute_project_metadata":       resourceComputeProjectMetadata(),
 			"google_compute_region_backend_service": resourceComputeRegionBackendService(),
 			"google_compute_route":                  resourceComputeRoute(),
+			"google_compute_router":                 resourceComputeRouter(),
+			"google_compute_router_interface":       resourceComputeRouterInterface(),
+			"google_compute_router_peer":            resourceComputeRouterPeer(),
 			"google_compute_ssl_certificate":        resourceComputeSslCertificate(),
 			"google_compute_subnetwork":             resourceComputeSubnetwork(),
 			"google_compute_target_http_proxy":      resourceComputeTargetHttpProxy(),

resource_compute_router.go

@@ -0,0 +1,251 @@
+package google
+
+import (
+	"fmt"
+	"log"
+
+	"strings"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"google.golang.org/api/compute/v1"
+	"google.golang.org/api/googleapi"
+)
+
+func resourceComputeRouter() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceComputeRouterCreate,
+		Read:   resourceComputeRouterRead,
+		Delete: resourceComputeRouterDelete,
+		Importer: &schema.ResourceImporter{
+			State: resourceComputeRouterImportState,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"network": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"description": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"project": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"region": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				Computed: true,
+				ForceNew: true,
+			},
+
+			"bgp": &schema.Schema{
+				Type:     schema.TypeList,
+				MaxItems: 1,
+				Required: true,
+				ForceNew: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+
+						"asn": &schema.Schema{
+							Type:     schema.TypeInt,
+							Required: true,
+							ForceNew: true,
+						},
+					},
+				},
+			},
+
+			"self_link": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func resourceComputeRouterCreate(d *schema.ResourceData, meta interface{}) error {
+
+	config := meta.(*Config)
+
+	region, err := getRegion(d, config)
+	if err != nil {
+		return err
+	}
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	name := d.Get("name").(string)
+
+	routerId := fmt.Sprintf("router/%s/%s", region, name)
+	mutexKV.Lock(routerId)
+	defer mutexKV.Unlock(routerId)
+
+	network, err := getNetworkLink(d, config, "network")
+	if err != nil {
+		return err
+	}
+	routersService := compute.NewRoutersService(config.clientCompute)
+
+	router := &compute.Router{
+		Name:    name,
+		Network: network,
+	}
+
+	if v, ok := d.GetOk("description"); ok {
+		router.Description = v.(string)
+	}
+
+	if _, ok := d.GetOk("bgp"); ok {
+		prefix := "bgp.0"
+		if v, ok := d.GetOk(prefix + ".asn"); ok {
+			asn := v.(int)
+			bgp := &compute.RouterBgp{
+				Asn: int64(asn),
+			}
+			router.Bgp = bgp
+		}
+	}
+
+	op, err := routersService.Insert(project, region, router).Do()
+	if err != nil {
+		return fmt.Errorf("Error Inserting Router %s into network %s: %s", name, network, err)
+	}
+
+	err = computeOperationWaitRegion(config, op, project, region, "Inserting Router")
+	if err != nil {
+		return fmt.Errorf("Error Waiting to Insert Router %s into network %s: %s", name, network, err)
+	}
+
+	return resourceComputeRouterRead(d, meta)
+}
+
+func resourceComputeRouterRead(d *schema.ResourceData, meta interface{}) error {
+
+	config := meta.(*Config)
+
+	region, err := getRegion(d, config)
+	if err != nil {
+		return err
+	}
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	name := d.Get("name").(string)
+	routersService := compute.NewRoutersService(config.clientCompute)
+	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))
+			d.SetId("")
+
+			return nil
+		}
+
+		return fmt.Errorf("Error Reading Router %s: %s", name, err)
+	}
+
+	d.Set("self_link", router.SelfLink)
+
+	// if we don't have a network (when importing), set it to the URI returned from the server
+	if _, ok := d.GetOk("network"); !ok {
+		d.Set("network", router.Network)
+	}
+
+	d.Set("region", region)
+	d.Set("bgp", flattenAsn(router.Bgp.Asn))
+	d.SetId(fmt.Sprintf("%s/%s", region, name))
+
+	return nil
+}
+
+func resourceComputeRouterDelete(d *schema.ResourceData, meta interface{}) error {
+
+	config := meta.(*Config)
+
+	region, err := getRegion(d, config)
+	if err != nil {
+		return err
+	}
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	name := d.Get("name").(string)
+
+	routerId := fmt.Sprintf("router/%s/%s", region, name)
+	mutexKV.Lock(routerId)
+	defer mutexKV.Unlock(routerId)
+
+	routersService := compute.NewRoutersService(config.clientCompute)
+
+	op, err := routersService.Delete(project, region, name).Do()
+	if err != nil {
+		return fmt.Errorf("Error Reading Router %s: %s", name, err)
+	}
+
+	err = computeOperationWaitRegion(config, op, project, region, "Deleting Router")
+	if err != nil {
+		return fmt.Errorf("Error Waiting to Delete Router %s: %s", name, err)
+	}
+
+	return nil
+}
+
+func resourceComputeRouterImportState(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
+	parts := strings.Split(d.Id(), "/")
+	if len(parts) != 2 {
+		return nil, fmt.Errorf("Invalid router specifier. Expecting {region}/{name}")
+	}
+
+	d.Set("region", parts[0])
+	d.Set("name", parts[1])
+
+	return []*schema.ResourceData{d}, nil
+}
+
+func getRouterLink(config *Config, project string, region string, router string) (string, error) {
+
+	if !strings.HasPrefix(router, "https://www.googleapis.com/compute/") {
+		// Router value provided is just the name, lookup the router SelfLink
+		routerData, err := config.clientCompute.Routers.Get(
+			project, region, router).Do()
+		if err != nil {
+			return "", fmt.Errorf("Error reading router: %s", err)
+		}
+		router = routerData.SelfLink
+	}
+
+	return router, nil
+
+}
+
+func flattenAsn(asn int64) []map[string]interface{} {
+	result := make([]map[string]interface{}, 0, 1)
+	r := make(map[string]interface{})
+	r["asn"] = asn
+	result = append(result, r)
+	return result
+}

resource_compute_router_interface.go

@@ -0,0 +1,288 @@
+package google
+
+import (
+	"fmt"
+	"log"
+
+	"strings"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"google.golang.org/api/compute/v1"
+	"google.golang.org/api/googleapi"
+)
+
+func resourceComputeRouterInterface() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceComputeRouterInterfaceCreate,
+		Read:   resourceComputeRouterInterfaceRead,
+		Delete: resourceComputeRouterInterfaceDelete,
+		Importer: &schema.ResourceImporter{
+			State: resourceComputeRouterInterfaceImportState,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"router": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"vpn_tunnel": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"ip_range": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+			"project": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"region": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				Computed: true,
+				ForceNew: true,
+			},
+		},
+	}
+}
+
+func resourceComputeRouterInterfaceCreate(d *schema.ResourceData, meta interface{}) error {
+
+	config := meta.(*Config)
+
+	region, err := getRegion(d, config)
+	if err != nil {
+		return err
+	}
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	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)
+
+	routersService := compute.NewRoutersService(config.clientCompute)
+	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)
+			d.SetId("")
+
+			return nil
+		}
+
+		return fmt.Errorf("Error Reading router %s/%s: %s", region, routerName, err)
+	}
+
+	var ifaceExists bool = false
+
+	var ifaces []*compute.RouterInterface = router.Interfaces
+	for _, iface := range ifaces {
+
+		if iface.Name == ifaceName {
+			ifaceExists = true
+			break
+		}
+	}
+
+	if !ifaceExists {
+
+		vpnTunnel, err := getVpnTunnelLink(config, project, region, d.Get("vpn_tunnel").(string))
+		if err != nil {
+			return err
+		}
+
+		iface := &compute.RouterInterface{Name: ifaceName,
+			LinkedVpnTunnel: vpnTunnel}
+
+		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("[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)
+	}
+
+	return resourceComputeRouterInterfaceRead(d, meta)
+}
+
+func resourceComputeRouterInterfaceRead(d *schema.ResourceData, meta interface{}) error {
+
+	config := meta.(*Config)
+
+	region, err := getRegion(d, config)
+	if err != nil {
+		return err
+	}
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	routerName := d.Get("router").(string)
+	ifaceName := d.Get("name").(string)
+
+	routersService := compute.NewRoutersService(config.clientCompute)
+	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)
+			d.SetId("")
+
+			return nil
+		}
+
+		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 {
+
+		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 {
+				vpnTunnelName, err := getVpnTunnelName(iface.LinkedVpnTunnel)
+				if err != nil {
+					return err
+				}
+				d.Set("vpn_tunnel", vpnTunnelName)
+			}
+			d.Set("ip_range", iface.IpRange)
+		}
+	}
+	if !ifaceFound {
+		log.Printf("[WARN] Removing router interface %s/%s/%s because it is gone", region, routerName, ifaceName)
+		d.SetId("")
+	}
+
+	return nil
+}
+
+func resourceComputeRouterInterfaceDelete(d *schema.ResourceData, meta interface{}) error {
+
+	config := meta.(*Config)
+
+	region, err := getRegion(d, config)
+	if err != nil {
+		return err
+	}
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	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)
+
+	routersService := compute.NewRoutersService(config.clientCompute)
+	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))
+
+			return nil
+		}
+
+		return fmt.Errorf("Error Reading Router %s: %s", routerName, err)
+	}
+
+	var ifaceFound bool = false
+
+	var oldIfaces []*compute.RouterInterface = router.Interfaces
+	var newIfaces []*compute.RouterInterface = make([]*compute.RouterInterface, len(router.Interfaces))
+	for _, iface := range oldIfaces {
+
+		if iface.Name == ifaceName {
+			ifaceFound = true
+			continue
+		} else {
+			newIfaces = append(newIfaces, iface)
+		}
+	}
+
+	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 {
+		log.Printf("[DEBUG] Router %s/%s had no interface %s already", region, routerName, ifaceName)
+	}
+
+	return nil
+}
+
+func resourceComputeRouterInterfaceImportState(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
+	parts := strings.Split(d.Id(), "/")
+	if len(parts) != 3 {
+		return nil, fmt.Errorf("Invalid router specifier. Expecting {region}/{router}")
+	}
+
+	d.Set("region", parts[0])
+	d.Set("router", parts[1])
+	d.Set("name", parts[2])
+
+	return []*schema.ResourceData{d}, nil
+}

resource_compute_router_interface_test.go

@@ -0,0 +1,247 @@
+package google
+
+import (
+	"fmt"
+	"testing"
+
+	"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) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeRouterInterface_basic,
+				Check: testAccCheckComputeRouterInterfaceExists(
+					"google_compute_router_interface.foobar"),
+			},
+			resource.TestStep{
+				Config: testAccComputeRouterInterface_keepRouter,
+				Check: testAccCheckComputeRouterInterfaceDestroy(
+					"google_compute_router_interface.foobar"),
+			},
+		},
+	})
+}
+
+func testAccCheckComputeRouterInterfaceDestroy(n string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		config := testAccProvider.Meta().(*Config)
+		project := config.Project
+
+		routersService := compute.NewRoutersService(config.clientCompute)
+
+		for _, rs := range s.RootModule().Resources {
+			if rs.Type != "google_compute_router_interface" {
+				continue
+			}
+
+			region := rs.Primary.Attributes["region"]
+			name := rs.Primary.Attributes["name"]
+			routerName := rs.Primary.Attributes["router"]
+
+			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 {
+
+				if iface.Name == name {
+					ifaceExists = true
+					break
+				}
+			}
+
+			if ifaceExists {
+				return fmt.Errorf("Interface %s still exists on router %s", name, router.Name)
+			}
+
+		}
+
+		return nil
+	}
+}
+
+func testAccCheckComputeRouterInterfaceExists(n string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("Not found: %s", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("No ID is set")
+		}
+
+		config := testAccProvider.Meta().(*Config)
+		name := rs.Primary.Attributes["name"]
+		routerName := rs.Primary.Attributes["router"]
+		region := rs.Primary.Attributes["region"]
+		project := config.Project
+
+		routersService := compute.NewRoutersService(config.clientCompute)
+		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 {
+
+			if iface.Name == name {
+				ifaceExists = true
+				break
+			}
+		}
+
+		if !ifaceExists {
+			return fmt.Errorf("Interface %s not found for router %s", name, router.Name)
+		}
+
+		return nil
+	}
+}
+
+var testAccComputeRouterInterface_basic = fmt.Sprintf(`
+resource "google_compute_network" "foobar" {
+        name = "interface-test-%s"
+}
+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"
+}
+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))

resource_compute_router_peer.go

@@ -0,0 +1,290 @@
+package google
+
+import (
+	"fmt"
+	"log"
+
+	"strings"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"google.golang.org/api/compute/v1"
+	"google.golang.org/api/googleapi"
+)
+
+func resourceComputeRouterPeer() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceComputeRouterPeerCreate,
+		Read:   resourceComputeRouterPeerRead,
+		Delete: resourceComputeRouterPeerDelete,
+		Importer: &schema.ResourceImporter{
+			State: resourceComputeRouterPeerImportState,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"router": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"interface": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"ip_address": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"asn": &schema.Schema{
+				Type:     schema.TypeInt,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"project": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"region": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				Computed: true,
+				ForceNew: true,
+			},
+		},
+	}
+}
+
+func resourceComputeRouterPeerCreate(d *schema.ResourceData, meta interface{}) error {
+
+	config := meta.(*Config)
+
+	region, err := getRegion(d, config)
+	if err != nil {
+		return err
+	}
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	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)
+
+	routersService := compute.NewRoutersService(config.clientCompute)
+	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)
+			d.SetId("")
+
+			return nil
+		}
+
+		return fmt.Errorf("Error Reading router %s/%s: %s", region, routerName, err)
+	}
+
+	var peerExists bool = false
+
+	var peers []*compute.RouterBgpPeer = router.BgpPeers
+	for _, peer := range peers {
+
+		if peer.Name == peerName {
+			peerExists = true
+			break
+		}
+	}
+
+	if !peerExists {
+
+		ifaceName := d.Get("interface").(string)
+
+		peer := &compute.RouterBgpPeer{Name: peerName,
+			InterfaceName: ifaceName}
+
+		if v, ok := d.GetOk("ip_address"); ok {
+			peer.PeerIpAddress = v.(string)
+		}
+
+		if v, ok := d.GetOk("asn"); ok {
+			peer.PeerAsn = int64(v.(int))
+		}
+
+		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)
+	}
+
+	return resourceComputeRouterPeerRead(d, meta)
+}
+
+func resourceComputeRouterPeerRead(d *schema.ResourceData, meta interface{}) error {
+
+	config := meta.(*Config)
+
+	region, err := getRegion(d, config)
+	if err != nil {
+		return err
+	}
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	routerName := d.Get("router").(string)
+	peerName := d.Get("name").(string)
+
+	routersService := compute.NewRoutersService(config.clientCompute)
+	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)
+			d.SetId("")
+
+			return nil
+		}
+
+		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 {
+
+		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)
+		}
+	}
+	if !peerFound {
+		log.Printf("[WARN] Removing router peer %s/%s/%s because it is gone", region, routerName, peerName)
+		d.SetId("")
+	}
+
+	return nil
+}
+
+func resourceComputeRouterPeerDelete(d *schema.ResourceData, meta interface{}) error {
+
+	config := meta.(*Config)
+
+	region, err := getRegion(d, config)
+	if err != nil {
+		return err
+	}
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	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)
+
+	routersService := compute.NewRoutersService(config.clientCompute)
+	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))
+
+			return nil
+		}
+
+		return fmt.Errorf("Error Reading Router %s: %s", routerName, err)
+	}
+
+	var peerFound bool = false
+
+	var oldIfaces []*compute.RouterBgpPeer = router.BgpPeers
+	var newIfaces []*compute.RouterBgpPeer = make([]*compute.RouterBgpPeer, len(router.BgpPeers))
+	for _, peer := range oldIfaces {
+
+		if peer.Name == peerName {
+			peerFound = true
+			continue
+		} else {
+			newIfaces = append(newIfaces, 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 {
+		log.Printf("[DEBUG] Router %s/%s had no peer %s already", region, routerName, peerName)
+	}
+
+	return nil
+}
+
+func resourceComputeRouterPeerImportState(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
+	parts := strings.Split(d.Id(), "/")
+	if len(parts) != 3 {
+		return nil, fmt.Errorf("Invalid router specifier. Expecting {region}/{router}")
+	}
+
+	d.Set("region", parts[0])
+	d.Set("router", parts[1])
+	d.Set("name", parts[2])
+
+	return []*schema.ResourceData{d}, nil
+}

resource_compute_router_peer_test.go

@@ -0,0 +1,263 @@
+package google
+
+import (
+	"fmt"
+	"testing"
+
+	"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) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeRouterPeer_basic,
+				Check: testAccCheckComputeRouterPeerExists(
+					"google_compute_router_peer.foobar"),
+			},
+			resource.TestStep{
+				Config: testAccComputeRouterPeer_keepRouter,
+				Check: testAccCheckComputeRouterPeerDestroy(
+					"google_compute_router_peer.foobar"),
+			},
+		},
+	})
+}
+
+func testAccCheckComputeRouterPeerDestroy(n string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		config := testAccProvider.Meta().(*Config)
+		project := config.Project
+
+		routersService := compute.NewRoutersService(config.clientCompute)
+
+		for _, rs := range s.RootModule().Resources {
+			if rs.Type != "google_compute_router_peer" {
+				continue
+			}
+
+			region := rs.Primary.Attributes["region"]
+			name := rs.Primary.Attributes["name"]
+			routerName := rs.Primary.Attributes["router"]
+
+			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 {
+
+				if peer.Name == name {
+					peerExists = true
+					break
+				}
+			}
+
+			if peerExists {
+				return fmt.Errorf("Peer %s still exists on router %s", name, router.Name)
+			}
+
+		}
+
+		return nil
+	}
+}
+
+func testAccCheckComputeRouterPeerExists(n string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("Not found: %s", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("No ID is set")
+		}
+
+		config := testAccProvider.Meta().(*Config)
+		name := rs.Primary.Attributes["name"]
+		routerName := rs.Primary.Attributes["router"]
+		region := rs.Primary.Attributes["region"]
+		project := config.Project
+
+		routersService := compute.NewRoutersService(config.clientCompute)
+		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 {
+
+			if peer.Name == name {
+				peerExists = true
+				break
+			}
+		}
+
+		if !peerExists {
+			return fmt.Errorf("Peer %s not found for router %s", name, router.Name)
+		}
+
+		return nil
+	}
+}
+
+var testAccComputeRouterPeer_basic = fmt.Sprintf(`
+resource "google_compute_network" "foobar" {
+        name = "peer-test-%s"
+}
+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"
+}
+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))

resource_compute_router_test.go

@@ -0,0 +1,176 @@
+package google
+
+import (
+	"fmt"
+	"testing"
+
+	"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) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeRouterDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeRouter_basic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeRouterExists(
+						"google_compute_router.foobar"),
+					resource.TestCheckResourceAttr(
+						"google_compute_router.foobar", "region", "europe-west1"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccComputeRouter_noRegion(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeRouterDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeRouter_noRegion,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeRouterExists(
+						"google_compute_router.foobar"),
+					resource.TestCheckResourceAttr(
+						"google_compute_router.foobar", "region", "us-central1"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccComputeRouter_networkLink(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeRouterDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeRouter_networkLink,
+				Check: testAccCheckComputeRouterExists(
+					"google_compute_router.foobar"),
+			},
+		},
+	})
+}
+
+func testAccCheckComputeRouterDestroy(s *terraform.State) error {
+	config := testAccProvider.Meta().(*Config)
+	project := config.Project
+
+	routersService := compute.NewRoutersService(config.clientCompute)
+
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type != "google_compute_router" {
+			continue
+		}
+
+		region := rs.Primary.Attributes["region"]
+		name := rs.Primary.Attributes["name"]
+
+		_, err := routersService.Get(project, region, name).Do()
+
+		if err == nil {
+			return fmt.Errorf("Error, Router %s in region %s still exists",
+				name, region)
+		}
+	}
+
+	return nil
+}
+
+func testAccCheckComputeRouterExists(n string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("Not found: %s", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("No ID is set")
+		}
+
+		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()
+
+		if err != nil {
+			return fmt.Errorf("Error Reading Router %s: %s", name, err)
+		}
+
+		return nil
+	}
+}
+
+var testAccComputeRouter_basic = fmt.Sprintf(`
+resource "google_compute_network" "foobar" {
+	name = "router-test-%s"
+}
+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"
+}
+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"
+}
+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))

resource_compute_vpn_tunnel.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"log"
 	"net"
+	"strings"
 
 	"github.com/hashicorp/terraform/helper/schema"
 
@@ -77,6 +78,7 @@ func resourceComputeVpnTunnel() *schema.Resource {
 				Type:     schema.TypeSet,
 				Optional: true,
 				ForceNew: true,
+				Computed: true,
 				Elem:     &schema.Schema{Type: schema.TypeString},
 				Set:      schema.HashString,
 			},
@@ -93,6 +95,12 @@ func resourceComputeVpnTunnel() *schema.Resource {
 				ForceNew: true,
 			},
 
+			"router": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
 			"self_link": &schema.Schema{
 				Type:     schema.TypeString,
 				Computed: true,
@@ -157,6 +165,14 @@ func resourceComputeVpnTunnelCreate(d *schema.ResourceData, meta interface{}) er
 		vpnTunnel.Description = v.(string)
 	}
 
+	if v, ok := d.GetOk("router"); ok {
+		routerLink, err := getRouterLink(config, project, region, v.(string))
+		if err != nil {
+			return err
+		}
+		vpnTunnel.Router = routerLink
+	}
+
 	op, err := vpnTunnelsService.Insert(project, region, vpnTunnel).Do()
 	if err != nil {
 		return fmt.Errorf("Error Inserting VPN Tunnel %s : %s", name, err)
@@ -335,3 +351,33 @@ var invalidPeerAddrs = []struct {
 		to:   net.ParseIP("255.255.255.255"),
 	},
 }
+
+func getVpnTunnelLink(config *Config, project string, region string, tunnel string) (string, error) {
+
+	if !strings.HasPrefix(tunnel, "https://www.googleapis.com/compute/") {
+		// Tunnel value provided is just the name, lookup the tunnel SelfLink
+		tunnelData, err := config.clientCompute.VpnTunnels.Get(
+			project, region, tunnel).Do()
+		if err != nil {
+			return "", fmt.Errorf("Error reading tunnel: %s", err)
+		}
+		tunnel = tunnelData.SelfLink
+	}
+
+	return tunnel, nil
+
+}
+
+func getVpnTunnelName(vpntunnel string) (string, error) {
+
+	if strings.HasPrefix(vpntunnel, "https://www.googleapis.com/compute/") {
+		// extract the VPN tunnel name from SelfLink URL
+		vpntunnelName := vpntunnel[strings.LastIndex(vpntunnel, "/")+1:]
+		if vpntunnelName == "" {
+			return "", fmt.Errorf("VPN tunnel url not valid")
+		}
+		return vpntunnelName, nil
+	}
+
+	return vpntunnel, nil
+}

resource_compute_vpn_tunnel_test.go

@@ -32,6 +32,25 @@ func TestAccComputeVpnTunnel_basic(t *testing.T) {
 	})
 }
 
+func TestAccComputeVpnTunnel_router(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeVpnTunnelDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeVpnTunnel_router,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeVpnTunnelExists(
+						"google_compute_vpn_tunnel.foobar"),
+					resource.TestCheckResourceAttr(
+						"google_compute_vpn_tunnel.foobar", "router", "tunnel-test-router"),
+				),
+			},
+		},
+	})
+}
+
 func TestAccComputeVpnTunnel_defaultTrafficSelectors(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
@@ -154,6 +173,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"
+}
+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" {
 	name = "tunnel-test-%s"