github.com/andresvia/terraform@v0.6.15-0.20160412045437-d51c75946785/builtin/providers/powerdns/resource_powerdns_record.go (about)

     1  package powerdns
     2  
     3  import (
     4  	"log"
     5  
     6  	"fmt"
     7  
     8  	"github.com/hashicorp/terraform/helper/schema"
     9  )
    10  
    11  func resourcePDNSRecord() *schema.Resource {
    12  	return &schema.Resource{
    13  		Create: resourcePDNSRecordCreate,
    14  		Read:   resourcePDNSRecordRead,
    15  		Delete: resourcePDNSRecordDelete,
    16  		Exists: resourcePDNSRecordExists,
    17  
    18  		Schema: map[string]*schema.Schema{
    19  			"zone": {
    20  				Type:     schema.TypeString,
    21  				Required: true,
    22  				ForceNew: true,
    23  			},
    24  
    25  			"name": {
    26  				Type:     schema.TypeString,
    27  				Required: true,
    28  				ForceNew: true,
    29  			},
    30  
    31  			"type": {
    32  				Type:     schema.TypeString,
    33  				Required: true,
    34  				ForceNew: true,
    35  			},
    36  
    37  			"ttl": {
    38  				Type:     schema.TypeInt,
    39  				Required: true,
    40  				ForceNew: true,
    41  			},
    42  
    43  			"records": {
    44  				Type:     schema.TypeSet,
    45  				Elem:     &schema.Schema{Type: schema.TypeString},
    46  				Required: true,
    47  				ForceNew: true,
    48  				Set:      schema.HashString,
    49  			},
    50  		},
    51  	}
    52  }
    53  
    54  func resourcePDNSRecordCreate(d *schema.ResourceData, meta interface{}) error {
    55  	client := meta.(*Client)
    56  
    57  	rrSet := ResourceRecordSet{
    58  		Name: d.Get("name").(string),
    59  		Type: d.Get("type").(string),
    60  	}
    61  
    62  	zone := d.Get("zone").(string)
    63  	ttl := d.Get("ttl").(int)
    64  	recs := d.Get("records").(*schema.Set).List()
    65  
    66  	if len(recs) > 0 {
    67  		records := make([]Record, 0, len(recs))
    68  		for _, recContent := range recs {
    69  			records = append(records, Record{Name: rrSet.Name, Type: rrSet.Type, TTL: ttl, Content: recContent.(string)})
    70  		}
    71  		rrSet.Records = records
    72  
    73  		log.Printf("[DEBUG] Creating PowerDNS Record: %#v", rrSet)
    74  
    75  		recId, err := client.ReplaceRecordSet(zone, rrSet)
    76  		if err != nil {
    77  			return fmt.Errorf("Failed to create PowerDNS Record: %s", err)
    78  		}
    79  
    80  		d.SetId(recId)
    81  		log.Printf("[INFO] Created PowerDNS Record with ID: %s", d.Id())
    82  
    83  	} else {
    84  		log.Printf("[DEBUG] Deleting empty PowerDNS Record: %#v", rrSet)
    85  		err := client.DeleteRecordSet(zone, rrSet.Name, rrSet.Type)
    86  		if err != nil {
    87  			return fmt.Errorf("Failed to delete PowerDNS Record: %s", err)
    88  		}
    89  
    90  		d.SetId(rrSet.Id())
    91  	}
    92  
    93  	return resourcePDNSRecordRead(d, meta)
    94  }
    95  
    96  func resourcePDNSRecordRead(d *schema.ResourceData, meta interface{}) error {
    97  	client := meta.(*Client)
    98  
    99  	log.Printf("[DEBUG] Reading PowerDNS Record: %s", d.Id())
   100  	records, err := client.ListRecordsByID(d.Get("zone").(string), d.Id())
   101  	if err != nil {
   102  		return fmt.Errorf("Couldn't fetch PowerDNS Record: %s", err)
   103  	}
   104  
   105  	recs := make([]string, 0, len(records))
   106  	for _, r := range records {
   107  		recs = append(recs, r.Content)
   108  	}
   109  	d.Set("records", recs)
   110  
   111  	if len(records) > 0 {
   112  		d.Set("ttl", records[0].TTL)
   113  	}
   114  
   115  	return nil
   116  }
   117  
   118  func resourcePDNSRecordDelete(d *schema.ResourceData, meta interface{}) error {
   119  	client := meta.(*Client)
   120  
   121  	log.Printf("[INFO] Deleting PowerDNS Record: %s", d.Id())
   122  	err := client.DeleteRecordSetByID(d.Get("zone").(string), d.Id())
   123  
   124  	if err != nil {
   125  		return fmt.Errorf("Error deleting PowerDNS Record: %s", err)
   126  	}
   127  
   128  	return nil
   129  }
   130  
   131  func resourcePDNSRecordExists(d *schema.ResourceData, meta interface{}) (bool, error) {
   132  	zone := d.Get("zone").(string)
   133  	name := d.Get("name").(string)
   134  	tpe := d.Get("type").(string)
   135  
   136  	log.Printf("[INFO] Checking existence of PowerDNS Record: %s, %s", name, tpe)
   137  
   138  	client := meta.(*Client)
   139  	exists, err := client.RecordExists(zone, name, tpe)
   140  
   141  	if err != nil {
   142  		return false, fmt.Errorf("Error checking PowerDNS Record: %s", err)
   143  	} else {
   144  		return exists, nil
   145  	}
   146  }