github.com/leeprovoost/terraform@v0.6.10-0.20160119085442-96f3f76118e7/builtin/providers/google/resource_dns_record_set.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"time"
     7  
     8  	"github.com/hashicorp/terraform/helper/schema"
     9  	"google.golang.org/api/dns/v1"
    10  	"google.golang.org/api/googleapi"
    11  )
    12  
    13  func resourceDnsRecordSet() *schema.Resource {
    14  	return &schema.Resource{
    15  		Create: resourceDnsRecordSetCreate,
    16  		Read:   resourceDnsRecordSetRead,
    17  		Delete: resourceDnsRecordSetDelete,
    18  
    19  		Schema: map[string]*schema.Schema{
    20  			"name": &schema.Schema{
    21  				Type:     schema.TypeString,
    22  				Required: true,
    23  				ForceNew: true,
    24  			},
    25  
    26  			"managed_zone": &schema.Schema{
    27  				Type:     schema.TypeString,
    28  				Required: true,
    29  				ForceNew: true,
    30  			},
    31  
    32  			"type": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Required: true,
    35  				ForceNew: true,
    36  			},
    37  
    38  			"ttl": &schema.Schema{
    39  				Type:     schema.TypeInt,
    40  				Required: true,
    41  				ForceNew: true,
    42  			},
    43  
    44  			"rrdatas": &schema.Schema{
    45  				Type:     schema.TypeList,
    46  				Required: true,
    47  				ForceNew: true,
    48  				Elem: &schema.Schema{
    49  					Type: schema.TypeString,
    50  				},
    51  			},
    52  		},
    53  	}
    54  }
    55  
    56  func resourceDnsRecordSetCreate(d *schema.ResourceData, meta interface{}) error {
    57  	config := meta.(*Config)
    58  
    59  	zone := d.Get("managed_zone").(string)
    60  
    61  	rrdatasCount := d.Get("rrdatas.#").(int)
    62  
    63  	// Build the change
    64  	chg := &dns.Change{
    65  		Additions: []*dns.ResourceRecordSet{
    66  			&dns.ResourceRecordSet{
    67  				Name:    d.Get("name").(string),
    68  				Type:    d.Get("type").(string),
    69  				Ttl:     int64(d.Get("ttl").(int)),
    70  				Rrdatas: make([]string, rrdatasCount),
    71  			},
    72  		},
    73  	}
    74  
    75  	for i := 0; i < rrdatasCount; i++ {
    76  		rrdata := fmt.Sprintf("rrdatas.%d", i)
    77  		chg.Additions[0].Rrdatas[i] = d.Get(rrdata).(string)
    78  	}
    79  
    80  	log.Printf("[DEBUG] DNS Record create request: %#v", chg)
    81  	chg, err := config.clientDns.Changes.Create(config.Project, zone, chg).Do()
    82  	if err != nil {
    83  		return fmt.Errorf("Error creating DNS RecordSet: %s", err)
    84  	}
    85  
    86  	d.SetId(chg.Id)
    87  
    88  	w := &DnsChangeWaiter{
    89  		Service:     config.clientDns,
    90  		Change:      chg,
    91  		Project:     config.Project,
    92  		ManagedZone: zone,
    93  	}
    94  	state := w.Conf()
    95  	state.Delay = 10 * time.Second
    96  	state.Timeout = 10 * time.Minute
    97  	state.MinTimeout = 2 * time.Second
    98  	_, err = state.WaitForState()
    99  	if err != nil {
   100  		return fmt.Errorf("Error waiting for Google DNS change: %s", err)
   101  	}
   102  
   103  	return resourceDnsRecordSetRead(d, meta)
   104  }
   105  
   106  func resourceDnsRecordSetRead(d *schema.ResourceData, meta interface{}) error {
   107  	config := meta.(*Config)
   108  
   109  	zone := d.Get("managed_zone").(string)
   110  
   111  	// name and type are effectively the 'key'
   112  	name := d.Get("name").(string)
   113  	dnsType := d.Get("type").(string)
   114  
   115  	resp, err := config.clientDns.ResourceRecordSets.List(
   116  		config.Project, zone).Name(name).Type(dnsType).Do()
   117  	if err != nil {
   118  		if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
   119  			log.Printf("[WARN] Removing DNS Record Set %q because it's gone", d.Get("name").(string))
   120  			// The resource doesn't exist anymore
   121  			d.SetId("")
   122  
   123  			return nil
   124  		}
   125  
   126  		return fmt.Errorf("Error reading DNS RecordSet: %#v", err)
   127  	}
   128  	if len(resp.Rrsets) == 0 {
   129  		// The resource doesn't exist anymore
   130  		d.SetId("")
   131  		return nil
   132  	}
   133  
   134  	if len(resp.Rrsets) > 1 {
   135  		return fmt.Errorf("Only expected 1 record set, got %d", len(resp.Rrsets))
   136  	}
   137  
   138  	d.Set("ttl", resp.Rrsets[0].Ttl)
   139  	d.Set("rrdatas", resp.Rrsets[0].Rrdatas)
   140  
   141  	return nil
   142  }
   143  
   144  func resourceDnsRecordSetDelete(d *schema.ResourceData, meta interface{}) error {
   145  	config := meta.(*Config)
   146  
   147  	zone := d.Get("managed_zone").(string)
   148  
   149  	rrdatasCount := d.Get("rrdatas.#").(int)
   150  
   151  	// Build the change
   152  	chg := &dns.Change{
   153  		Deletions: []*dns.ResourceRecordSet{
   154  			&dns.ResourceRecordSet{
   155  				Name:    d.Get("name").(string),
   156  				Type:    d.Get("type").(string),
   157  				Ttl:     int64(d.Get("ttl").(int)),
   158  				Rrdatas: make([]string, rrdatasCount),
   159  			},
   160  		},
   161  	}
   162  
   163  	for i := 0; i < rrdatasCount; i++ {
   164  		rrdata := fmt.Sprintf("rrdatas.%d", i)
   165  		chg.Deletions[0].Rrdatas[i] = d.Get(rrdata).(string)
   166  	}
   167  	log.Printf("[DEBUG] DNS Record delete request: %#v", chg)
   168  	chg, err := config.clientDns.Changes.Create(config.Project, zone, chg).Do()
   169  	if err != nil {
   170  		return fmt.Errorf("Error deleting DNS RecordSet: %s", err)
   171  	}
   172  
   173  	w := &DnsChangeWaiter{
   174  		Service:     config.clientDns,
   175  		Change:      chg,
   176  		Project:     config.Project,
   177  		ManagedZone: zone,
   178  	}
   179  	state := w.Conf()
   180  	state.Delay = 10 * time.Second
   181  	state.Timeout = 10 * time.Minute
   182  	state.MinTimeout = 2 * time.Second
   183  	_, err = state.WaitForState()
   184  	if err != nil {
   185  		return fmt.Errorf("Error waiting for Google DNS change: %s", err)
   186  	}
   187  
   188  	d.SetId("")
   189  	return nil
   190  }