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