github.com/hobbeswalsh/terraform@v0.3.7-0.20150619183303-ad17cf55a0fa/builtin/providers/digitalocean/resource_digitalocean_record.go (about)

     1  package digitalocean
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"strings"
     7  
     8  	"github.com/hashicorp/terraform/helper/schema"
     9  	"github.com/pearkes/digitalocean"
    10  )
    11  
    12  func resourceDigitalOceanRecord() *schema.Resource {
    13  	return &schema.Resource{
    14  		Create: resourceDigitalOceanRecordCreate,
    15  		Read:   resourceDigitalOceanRecordRead,
    16  		Update: resourceDigitalOceanRecordUpdate,
    17  		Delete: resourceDigitalOceanRecordDelete,
    18  
    19  		Schema: map[string]*schema.Schema{
    20  			"type": &schema.Schema{
    21  				Type:     schema.TypeString,
    22  				Required: true,
    23  				ForceNew: true,
    24  			},
    25  
    26  			"domain": &schema.Schema{
    27  				Type:     schema.TypeString,
    28  				Required: true,
    29  				ForceNew: true,
    30  			},
    31  
    32  			"name": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Optional: true,
    35  			},
    36  
    37  			"port": &schema.Schema{
    38  				Type:     schema.TypeString,
    39  				Optional: true,
    40  				Computed: true,
    41  				ForceNew: true,
    42  			},
    43  
    44  			"priority": &schema.Schema{
    45  				Type:     schema.TypeString,
    46  				Optional: true,
    47  				Computed: true,
    48  				ForceNew: true,
    49  			},
    50  
    51  			"weight": &schema.Schema{
    52  				Type:     schema.TypeString,
    53  				Optional: true,
    54  				Computed: true,
    55  				ForceNew: true,
    56  			},
    57  
    58  			"value": &schema.Schema{
    59  				Type:     schema.TypeString,
    60  				Optional: true,
    61  				Computed: true,
    62  				ForceNew: true,
    63  			},
    64  		},
    65  	}
    66  }
    67  
    68  func resourceDigitalOceanRecordCreate(d *schema.ResourceData, meta interface{}) error {
    69  	client := meta.(*digitalocean.Client)
    70  
    71  	newRecord := digitalocean.CreateRecord{
    72  		Type:     d.Get("type").(string),
    73  		Name:     d.Get("name").(string),
    74  		Data:     d.Get("value").(string),
    75  		Priority: d.Get("priority").(string),
    76  		Port:     d.Get("port").(string),
    77  		Weight:   d.Get("weight").(string),
    78  	}
    79  
    80  	log.Printf("[DEBUG] record create configuration: %#v", newRecord)
    81  	recId, err := client.CreateRecord(d.Get("domain").(string), &newRecord)
    82  	if err != nil {
    83  		return fmt.Errorf("Failed to create record: %s", err)
    84  	}
    85  
    86  	d.SetId(recId)
    87  	log.Printf("[INFO] Record ID: %s", d.Id())
    88  
    89  	return resourceDigitalOceanRecordRead(d, meta)
    90  }
    91  
    92  func resourceDigitalOceanRecordRead(d *schema.ResourceData, meta interface{}) error {
    93  	client := meta.(*digitalocean.Client)
    94  	domain := d.Get("domain").(string)
    95  
    96  	rec, err := client.RetrieveRecord(domain, d.Id())
    97  	if err != nil {
    98  		// If the record is somehow already destroyed, mark as
    99  		// succesfully gone
   100  		if strings.Contains(err.Error(), "404 Not Found") {
   101  			d.SetId("")
   102  			return nil
   103  		}
   104  
   105  		return err
   106  	}
   107  
   108  	// Update response data for records with domain value
   109  	if t := rec.Type; t == "CNAME" || t == "MX" || t == "NS" || t == "SRV" {
   110  		// Append dot to response if resource value is absolute
   111  		if value := d.Get("value").(string); strings.HasSuffix(value, ".") {
   112  			rec.Data += "."
   113  			// If resource value ends with current domain, make response data absolute
   114  			if strings.HasSuffix(value, domain+".") {
   115  				rec.Data += domain + "."
   116  			}
   117  		}
   118  	}
   119  
   120  	d.Set("name", rec.Name)
   121  	d.Set("type", rec.Type)
   122  	d.Set("value", rec.Data)
   123  	d.Set("weight", rec.StringWeight())
   124  	d.Set("priority", rec.StringPriority())
   125  	d.Set("port", rec.StringPort())
   126  
   127  	return nil
   128  }
   129  
   130  func resourceDigitalOceanRecordUpdate(d *schema.ResourceData, meta interface{}) error {
   131  	client := meta.(*digitalocean.Client)
   132  
   133  	var updateRecord digitalocean.UpdateRecord
   134  	if v, ok := d.GetOk("name"); ok {
   135  		updateRecord.Name = v.(string)
   136  	}
   137  
   138  	log.Printf("[DEBUG] record update configuration: %#v", updateRecord)
   139  	err := client.UpdateRecord(d.Get("domain").(string), d.Id(), &updateRecord)
   140  	if err != nil {
   141  		return fmt.Errorf("Failed to update record: %s", err)
   142  	}
   143  
   144  	return resourceDigitalOceanRecordRead(d, meta)
   145  }
   146  
   147  func resourceDigitalOceanRecordDelete(d *schema.ResourceData, meta interface{}) error {
   148  	client := meta.(*digitalocean.Client)
   149  
   150  	log.Printf(
   151  		"[INFO] Deleting record: %s, %s", d.Get("domain").(string), d.Id())
   152  	err := client.DestroyRecord(d.Get("domain").(string), d.Id())
   153  	if err != nil {
   154  		// If the record is somehow already destroyed, mark as
   155  		// succesfully gone
   156  		if strings.Contains(err.Error(), "404 Not Found") {
   157  			return nil
   158  		}
   159  
   160  		return fmt.Errorf("Error deleting record: %s", err)
   161  	}
   162  
   163  	return nil
   164  }