github.com/ndarilek/terraform@v0.3.8-0.20150320140257-d3135c1b2bac/builtin/providers/google/resource_compute_network.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"time"
     7  
     8  	"code.google.com/p/google-api-go-client/compute/v1"
     9  	"code.google.com/p/google-api-go-client/googleapi"
    10  	"github.com/hashicorp/terraform/helper/schema"
    11  )
    12  
    13  func resourceComputeNetwork() *schema.Resource {
    14  	return &schema.Resource{
    15  		Create: resourceComputeNetworkCreate,
    16  		Read:   resourceComputeNetworkRead,
    17  		Delete: resourceComputeNetworkDelete,
    18  
    19  		Schema: map[string]*schema.Schema{
    20  			"name": &schema.Schema{
    21  				Type:     schema.TypeString,
    22  				Required: true,
    23  				ForceNew: true,
    24  			},
    25  
    26  			"ipv4_range": &schema.Schema{
    27  				Type:     schema.TypeString,
    28  				Required: true,
    29  				ForceNew: true,
    30  			},
    31  
    32  			"gateway_ipv4": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Computed: true,
    35  			},
    36  
    37  			"self_link": &schema.Schema{
    38  				Type:     schema.TypeString,
    39  				Computed: true,
    40  			},
    41  		},
    42  	}
    43  }
    44  
    45  func resourceComputeNetworkCreate(d *schema.ResourceData, meta interface{}) error {
    46  	config := meta.(*Config)
    47  
    48  	// Build the network parameter
    49  	network := &compute.Network{
    50  		Name:      d.Get("name").(string),
    51  		IPv4Range: d.Get("ipv4_range").(string),
    52  	}
    53  	log.Printf("[DEBUG] Network insert request: %#v", network)
    54  	op, err := config.clientCompute.Networks.Insert(
    55  		config.Project, network).Do()
    56  	if err != nil {
    57  		return fmt.Errorf("Error creating network: %s", err)
    58  	}
    59  
    60  	// It probably maybe worked, so store the ID now
    61  	d.SetId(network.Name)
    62  
    63  	// Wait for the operation to complete
    64  	w := &OperationWaiter{
    65  		Service: config.clientCompute,
    66  		Op:      op,
    67  		Project: config.Project,
    68  		Type:    OperationWaitGlobal,
    69  	}
    70  	state := w.Conf()
    71  	state.Timeout = 2 * time.Minute
    72  	state.MinTimeout = 1 * time.Second
    73  	opRaw, err := state.WaitForState()
    74  	if err != nil {
    75  		return fmt.Errorf("Error waiting for network to create: %s", err)
    76  	}
    77  	op = opRaw.(*compute.Operation)
    78  	if op.Error != nil {
    79  		// The resource didn't actually create
    80  		d.SetId("")
    81  
    82  		// Return the error
    83  		return OperationError(*op.Error)
    84  	}
    85  
    86  	return resourceComputeNetworkRead(d, meta)
    87  }
    88  
    89  func resourceComputeNetworkRead(d *schema.ResourceData, meta interface{}) error {
    90  	config := meta.(*Config)
    91  
    92  	network, err := config.clientCompute.Networks.Get(
    93  		config.Project, d.Id()).Do()
    94  	if err != nil {
    95  		if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
    96  			// The resource doesn't exist anymore
    97  			d.SetId("")
    98  
    99  			return nil
   100  		}
   101  
   102  		return fmt.Errorf("Error reading network: %s", err)
   103  	}
   104  
   105  	d.Set("gateway_ipv4", network.GatewayIPv4)
   106  	d.Set("self_link", network.SelfLink)
   107  
   108  	return nil
   109  }
   110  
   111  func resourceComputeNetworkDelete(d *schema.ResourceData, meta interface{}) error {
   112  	config := meta.(*Config)
   113  
   114  	// Delete the network
   115  	op, err := config.clientCompute.Networks.Delete(
   116  		config.Project, d.Id()).Do()
   117  	if err != nil {
   118  		return fmt.Errorf("Error deleting network: %s", err)
   119  	}
   120  
   121  	// Wait for the operation to complete
   122  	w := &OperationWaiter{
   123  		Service: config.clientCompute,
   124  		Op:      op,
   125  		Project: config.Project,
   126  		Type:    OperationWaitGlobal,
   127  	}
   128  	state := w.Conf()
   129  	state.Timeout = 2 * time.Minute
   130  	state.MinTimeout = 1 * time.Second
   131  	opRaw, err := state.WaitForState()
   132  	if err != nil {
   133  		return fmt.Errorf("Error waiting for network to delete: %s", err)
   134  	}
   135  	op = opRaw.(*compute.Operation)
   136  	if op.Error != nil {
   137  		// Return the error
   138  		return OperationError(*op.Error)
   139  	}
   140  
   141  	d.SetId("")
   142  	return nil
   143  }