github.com/andresvia/terraform@v0.6.15-0.20160412045437-d51c75946785/builtin/providers/google/resource_compute_subnetwork.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"strings"
     8  
     9  	"github.com/hashicorp/terraform/helper/schema"
    10  	"google.golang.org/api/compute/v1"
    11  	"google.golang.org/api/googleapi"
    12  )
    13  
    14  func resourceComputeSubnetwork() *schema.Resource {
    15  	return &schema.Resource{
    16  		Create: resourceComputeSubnetworkCreate,
    17  		Read:   resourceComputeSubnetworkRead,
    18  		Delete: resourceComputeSubnetworkDelete,
    19  
    20  		Schema: map[string]*schema.Schema{
    21  			"ip_cidr_range": &schema.Schema{
    22  				Type:     schema.TypeString,
    23  				Required: true,
    24  				ForceNew: true,
    25  			},
    26  
    27  			"name": &schema.Schema{
    28  				Type:     schema.TypeString,
    29  				Required: true,
    30  				ForceNew: true,
    31  			},
    32  
    33  			"network": &schema.Schema{
    34  				Type:     schema.TypeString,
    35  				Required: true,
    36  				ForceNew: true,
    37  			},
    38  
    39  			"description": &schema.Schema{
    40  				Type:     schema.TypeString,
    41  				Optional: true,
    42  				ForceNew: true,
    43  			},
    44  
    45  			"gateway_address": &schema.Schema{
    46  				Type:     schema.TypeString,
    47  				Computed: true,
    48  			},
    49  
    50  			"project": &schema.Schema{
    51  				Type:     schema.TypeString,
    52  				Optional: true,
    53  				ForceNew: true,
    54  			},
    55  
    56  			"region": &schema.Schema{
    57  				Type:     schema.TypeString,
    58  				Optional: true,
    59  				ForceNew: true,
    60  			},
    61  
    62  			"self_link": &schema.Schema{
    63  				Type:     schema.TypeString,
    64  				Computed: true,
    65  			},
    66  		},
    67  	}
    68  }
    69  
    70  func createSubnetID(s *compute.Subnetwork) string {
    71  	return fmt.Sprintf("%s/%s", s.Region, s.Name)
    72  }
    73  
    74  func splitSubnetID(id string) (region string, name string) {
    75  	parts := strings.Split(id, "/")
    76  	region = parts[0]
    77  	name = parts[1]
    78  	return
    79  }
    80  
    81  func resourceComputeSubnetworkCreate(d *schema.ResourceData, meta interface{}) error {
    82  	config := meta.(*Config)
    83  
    84  	region, err := getRegion(d, config)
    85  	if err != nil {
    86  		return err
    87  	}
    88  
    89  	project, err := getProject(d, config)
    90  	if err != nil {
    91  		return err
    92  	}
    93  
    94  	// Build the subnetwork parameters
    95  	subnetwork := &compute.Subnetwork{
    96  		Name:        d.Get("name").(string),
    97  		Description: d.Get("description").(string),
    98  		IpCidrRange: d.Get("ip_cidr_range").(string),
    99  		Network:     d.Get("network").(string),
   100  	}
   101  
   102  	log.Printf("[DEBUG] Subnetwork insert request: %#v", subnetwork)
   103  	op, err := config.clientCompute.Subnetworks.Insert(
   104  		project, region, subnetwork).Do()
   105  
   106  	if err != nil {
   107  		return fmt.Errorf("Error creating subnetwork: %s", err)
   108  	}
   109  
   110  	// It probably maybe worked, so store the ID now. ID is a combination of region + subnetwork
   111  	// name because subnetwork names are not unique in a project, per the Google docs:
   112  	// "When creating a new subnetwork, its name has to be unique in that project for that region, even across networks.
   113  	// The same name can appear twice in a project, as long as each one is in a different region."
   114  	// https://cloud.google.com/compute/docs/subnetworks
   115  	subnetwork.Region = region
   116  	d.SetId(createSubnetID(subnetwork))
   117  
   118  	err = computeOperationWaitRegion(config, op, region, "Creating Subnetwork")
   119  	if err != nil {
   120  		return err
   121  	}
   122  
   123  	return resourceComputeSubnetworkRead(d, meta)
   124  }
   125  
   126  func resourceComputeSubnetworkRead(d *schema.ResourceData, meta interface{}) error {
   127  	config := meta.(*Config)
   128  
   129  	region, err := getRegion(d, config)
   130  	if err != nil {
   131  		return err
   132  	}
   133  
   134  	project, err := getProject(d, config)
   135  	if err != nil {
   136  		return err
   137  	}
   138  
   139  	name := d.Get("name").(string)
   140  
   141  	subnetwork, err := config.clientCompute.Subnetworks.Get(
   142  		project, region, name).Do()
   143  	if err != nil {
   144  		if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
   145  			log.Printf("[WARN] Removing Subnetwork %q because it's gone", name)
   146  			// The resource doesn't exist anymore
   147  			d.SetId("")
   148  
   149  			return nil
   150  		}
   151  
   152  		return fmt.Errorf("Error reading subnetwork: %s", err)
   153  	}
   154  
   155  	d.Set("gateway_address", subnetwork.GatewayAddress)
   156  	d.Set("self_link", subnetwork.SelfLink)
   157  
   158  	return nil
   159  }
   160  
   161  func resourceComputeSubnetworkDelete(d *schema.ResourceData, meta interface{}) error {
   162  	config := meta.(*Config)
   163  
   164  	region, err := getRegion(d, config)
   165  	if err != nil {
   166  		return err
   167  	}
   168  
   169  	project, err := getProject(d, config)
   170  	if err != nil {
   171  		return err
   172  	}
   173  
   174  	// Delete the subnetwork
   175  	op, err := config.clientCompute.Subnetworks.Delete(
   176  		project, region, d.Get("name").(string)).Do()
   177  	if err != nil {
   178  		return fmt.Errorf("Error deleting subnetwork: %s", err)
   179  	}
   180  
   181  	err = computeOperationWaitRegion(config, op, region, "Deleting Subnetwork")
   182  	if err != nil {
   183  		return err
   184  	}
   185  
   186  	d.SetId("")
   187  	return nil
   188  }