Update google resources where necessary to make use of subnetworks, update som docs

provider.go

@@ -145,3 +145,11 @@ func validateCredentials(v interface{}, k string) (warnings []string, errors []e
 
 	return
 }
+
+func getRegionFromZone(zone string) string {
+	if zone != "" && len(zone) > 2 {
+		region := zone[:len(zone)-2]
+		return region
+	}
+	return ""
+}

resource_compute_instance.go

@@ -111,7 +111,13 @@ func resourceComputeInstance() *schema.Resource {
 					Schema: map[string]*schema.Schema{
 						"network": &schema.Schema{
 							Type:     schema.TypeString,
-							Required: true,
+							Optional: true,
+							ForceNew: true,
+						},
+
+						"subnetwork": &schema.Schema{
+							Type:     schema.TypeString,
+							Optional: true,
 							ForceNew: true,
 						},
 
@@ -445,17 +451,36 @@ func resourceComputeInstanceCreate(d *schema.ResourceData, meta interface{}) err
 			prefix := fmt.Sprintf("network_interface.%d", i)
 			// Load up the name of this network_interfac
 			networkName := d.Get(prefix + ".network").(string)
-			network, err := config.clientCompute.Networks.Get(
-				config.Project, networkName).Do()
-			if err != nil {
-				return fmt.Errorf(
-					"Error referencing network '%s': %s",
-					networkName, err)
+			subnetworkName := d.Get(prefix + ".subnetwork").(string)
+			var networkLink, subnetworkLink string
+
+			if networkName != "" && subnetworkName != "" {
+				return fmt.Errorf("Cannot specify both network and subnetwork values.")
+			} else if networkName != "" {
+				network, err := config.clientCompute.Networks.Get(
+					config.Project, networkName).Do()
+				if err != nil {
+					return fmt.Errorf(
+						"Error referencing network '%s': %s",
+						networkName, err)
+				}
+				networkLink = network.SelfLink
+			} else {
+				region := getRegionFromZone(d.Get("zone").(string))
+				subnetwork, err := config.clientCompute.Subnetworks.Get(
+					config.Project, region, subnetworkName).Do()
+				if err != nil {
+					return fmt.Errorf(
+						"Error referencing subnetwork '%s' in region '%s': %s",
+						subnetworkName, region, err)
+				}
+				subnetworkLink = subnetwork.SelfLink
 			}
 
 			// Build the networkInterface
 			var iface compute.NetworkInterface
-			iface.Network = network.SelfLink
+			iface.Network = networkLink
+			iface.Subnetwork = subnetworkLink
 
 			// Handle access_config structs
 			accessConfigsCount := d.Get(prefix + ".access_config.#").(int)

resource_compute_instance_template.go

@@ -141,6 +141,12 @@ func resourceComputeInstanceTemplate() *schema.Resource {
 							ForceNew: true,
 						},
 
+						"subnetwork": &schema.Schema{
+							Type:     schema.TypeString,
+							Optional: true,
+							ForceNew: true,
+						},
+
 						"access_config": &schema.Schema{
 							Type:     schema.TypeList,
 							Optional: true,
@@ -337,9 +343,12 @@ func buildNetworks(d *schema.ResourceData, meta interface{}) (error, []*compute.
 			source += v.(string)
 		}
 
+		subnetworkLink := d.Get("subnetwork").(string)
+
 		// Build the networkInterface
 		var iface compute.NetworkInterface
 		iface.Network = source
+		iface.Subnetwork = subnetworkLink
 
 		accessConfigsCount := d.Get(prefix + ".access_config.#").(int)
 		iface.AccessConfigs = make([]*compute.AccessConfig, accessConfigsCount)

resource_compute_network.go

@@ -24,9 +24,10 @@ func resourceComputeNetwork() *schema.Resource {
 			},
 
 			"ipv4_range": &schema.Schema{
-				Type:     schema.TypeString,
-				Optional: true,
-				ForceNew: true,
+				Type:       schema.TypeString,
+				Optional:   true,
+				ForceNew:   true,
+				Deprecated: "Please use custom subnetworks instead",
 			},
 
 			"gateway_ipv4": &schema.Schema{

resource_compute_subnetwork.go

@@ -34,7 +34,7 @@ func resourceComputeSubnetwork() *schema.Resource {
 				ForceNew: true,
 			},
 
-			"ipCidrRange": &schema.Schema{
+			"ip_cidr_range": &schema.Schema{
 				Type:     schema.TypeString,
 				Required: true,
 				ForceNew: true,
@@ -70,7 +70,7 @@ func resourceComputeSubnetworkCreate(d *schema.ResourceData, meta interface{}) e
 	subnetwork := &compute.Subnetwork{
 		Name:        d.Get("name").(string),
 		Description: d.Get("description").(string),
-		IpCidrRange: d.Get("ipCidrRange").(string),
+		IpCidrRange: d.Get("ip_cidr_range").(string),
 		Network:     d.Get("network").(string),
 	}
 	region := d.Get("region").(string)

resource_compute_vpn_tunnel.go

@@ -55,6 +55,13 @@ func resourceComputeVpnTunnel() *schema.Resource {
 				Default:  2,
 				ForceNew: true,
 			},
+			"local_traffic_selector": &schema.Schema{
+				Type:     schema.TypeSet,
+				Optional: true,
+				ForceNew: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+				Set:      schema.HashString,
+			},
 			"detailed_status": &schema.Schema{
 				Type:     schema.TypeString,
 				Computed: true,
@@ -82,14 +89,24 @@ func resourceComputeVpnTunnelCreate(d *schema.ResourceData, meta interface{}) er
 		return fmt.Errorf("Only IKE version 1 or 2 supported, not %d", ikeVersion)
 	}
 
+	// Build up the list of sources
+	var localTrafficSelectors []string
+	if v := d.Get("local_traffic_selector").(*schema.Set); v.Len() > 0 {
+		localTrafficSelectors = make([]string, v.Len())
+		for i, v := range v.List() {
+			localTrafficSelectors[i] = v.(string)
+		}
+	}
+
 	vpnTunnelsService := compute.NewVpnTunnelsService(config.clientCompute)
 
 	vpnTunnel := &compute.VpnTunnel{
-		Name:             name,
-		PeerIp:           peerIp,
-		SharedSecret:     sharedSecret,
-		TargetVpnGateway: targetVpnGateway,
-		IkeVersion:       int64(ikeVersion),
+		Name:                 name,
+		PeerIp:               peerIp,
+		SharedSecret:         sharedSecret,
+		TargetVpnGateway:     targetVpnGateway,
+		IkeVersion:           int64(ikeVersion),
+		LocalTrafficSelector: localTrafficSelectors,
 	}
 
 	if v, ok := d.GetOk("description"); ok {