github.com/joshgarnett/terraform@v0.5.4-0.20160219181435-92dc20bb3594/builtin/providers/google/resource_compute_network.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/hashicorp/terraform/helper/schema"
     8  	"google.golang.org/api/compute/v1"
     9  	"google.golang.org/api/googleapi"
    10  )
    11  
    12  func resourceComputeNetwork() *schema.Resource {
    13  	return &schema.Resource{
    14  		Create: resourceComputeNetworkCreate,
    15  		Read:   resourceComputeNetworkRead,
    16  		Delete: resourceComputeNetworkDelete,
    17  
    18  		Schema: map[string]*schema.Schema{
    19  			"name": &schema.Schema{
    20  				Type:     schema.TypeString,
    21  				Required: true,
    22  				ForceNew: true,
    23  			},
    24  
    25  			"ipv4_range": &schema.Schema{
    26  				Type:       schema.TypeString,
    27  				Optional:   true,
    28  				ForceNew:   true,
    29  				Deprecated: "Please use google_compute_subnetwork resources instead.",
    30  			},
    31  
    32  			"gateway_ipv4": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Computed: true,
    35  			},
    36  
    37  			"auto_create_subnetworks": &schema.Schema{
    38  				Type:     schema.TypeBool,
    39  				Optional: true,
    40  				ForceNew: true,
    41  				/* Ideally this would default to true as per the API, but that would cause
    42  				   existing Terraform configs which have not been updated to report this as
    43  				   a change. Perhaps we can bump this for a minor release bump rather than
    44  				   a point release. */
    45  				Default: false,
    46  			},
    47  
    48  			"description": &schema.Schema{
    49  				Type:     schema.TypeString,
    50  				Optional: true,
    51  				ForceNew: true,
    52  			},
    53  
    54  			"self_link": &schema.Schema{
    55  				Type:     schema.TypeString,
    56  				Computed: true,
    57  			},
    58  		},
    59  	}
    60  }
    61  
    62  func resourceComputeNetworkCreate(d *schema.ResourceData, meta interface{}) error {
    63  	config := meta.(*Config)
    64  
    65  	//
    66  	// Possible modes:
    67  	// - 1 Legacy mode - Create a network in the legacy mode. ipv4_range is set. auto_create_subnetworks must be false
    68  	//     and not sent in request
    69  	// - 2 Distributed Mode - Create a new generation network that supports subnetworks:
    70  	//   - 2.a - Auto subnet mode - auto_create_subnetworks = true, Google will generate 1 subnetwork per region
    71  	//   - 2.b - Custom subnet mode - auto_create_subnetworks = false & ipv4_range not set,
    72  	//
    73  	ipv4range := d.Get("ipv4_range").(string)
    74  	autoCreateSubnetworks := d.Get("auto_create_subnetworks").(bool)
    75  
    76  	if ipv4range != "" && autoCreateSubnetworks {
    77  		return fmt.Errorf("Error: cannot define ipv4_range with auto_create_subnetworks = true.")
    78  	}
    79  
    80  	// Build the network parameter
    81  	network := &compute.Network{
    82  		Name: d.Get("name").(string),
    83  		AutoCreateSubnetworks: autoCreateSubnetworks,
    84  		Description:           d.Get("description").(string),
    85  	}
    86  
    87  	if v, ok := d.GetOk("ipv4_range"); ok {
    88  		log.Printf("[DEBUG] Setting IPv4Range (%#v) for legacy network mode", v.(string))
    89  		network.IPv4Range = v.(string)
    90  	} else {
    91  		// custom subnet mode, so make sure AutoCreateSubnetworks field is included in request otherwise
    92  		// google will create a network in legacy mode.
    93  		network.ForceSendFields = []string{"AutoCreateSubnetworks"}
    94  	}
    95  
    96  	log.Printf("[DEBUG] Network insert request: %#v", network)
    97  	op, err := config.clientCompute.Networks.Insert(
    98  		config.Project, network).Do()
    99  	if err != nil {
   100  		return fmt.Errorf("Error creating network: %s", err)
   101  	}
   102  
   103  	// It probably maybe worked, so store the ID now
   104  	d.SetId(network.Name)
   105  
   106  	err = computeOperationWaitGlobal(config, op, "Creating Network")
   107  	if err != nil {
   108  		return err
   109  	}
   110  
   111  	return resourceComputeNetworkRead(d, meta)
   112  }
   113  
   114  func resourceComputeNetworkRead(d *schema.ResourceData, meta interface{}) error {
   115  	config := meta.(*Config)
   116  
   117  	network, err := config.clientCompute.Networks.Get(
   118  		config.Project, d.Id()).Do()
   119  	if err != nil {
   120  		if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
   121  			log.Printf("[WARN] Removing Network %q because it's gone", d.Get("name").(string))
   122  			// The resource doesn't exist anymore
   123  			d.SetId("")
   124  
   125  			return nil
   126  		}
   127  
   128  		return fmt.Errorf("Error reading network: %s", err)
   129  	}
   130  
   131  	d.Set("gateway_ipv4", network.GatewayIPv4)
   132  	d.Set("self_link", network.SelfLink)
   133  
   134  	return nil
   135  }
   136  
   137  func resourceComputeNetworkDelete(d *schema.ResourceData, meta interface{}) error {
   138  	config := meta.(*Config)
   139  
   140  	// Delete the network
   141  	op, err := config.clientCompute.Networks.Delete(
   142  		config.Project, d.Id()).Do()
   143  	if err != nil {
   144  		return fmt.Errorf("Error deleting network: %s", err)
   145  	}
   146  
   147  	err = computeOperationWaitGlobal(config, op, "Deleting Network")
   148  	if err != nil {
   149  		return err
   150  	}
   151  
   152  	d.SetId("")
   153  	return nil
   154  }