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