github.com/ezbercih/terraform@v0.1.1-0.20140729011846-3c33865e0839/builtin/providers/digitalocean/resource_digitalocean_record.go (about)

     1  package digitalocean
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/hashicorp/terraform/helper/config"
     8  	"github.com/hashicorp/terraform/helper/diff"
     9  	"github.com/hashicorp/terraform/terraform"
    10  	"github.com/pearkes/digitalocean"
    11  )
    12  
    13  func resource_digitalocean_record_create(
    14  	s *terraform.ResourceState,
    15  	d *terraform.ResourceDiff,
    16  	meta interface{}) (*terraform.ResourceState, error) {
    17  	p := meta.(*ResourceProvider)
    18  	client := p.client
    19  
    20  	// Merge the diff into the state so that we have all the attributes
    21  	// properly.
    22  	rs := s.MergeDiff(d)
    23  
    24  	var err error
    25  
    26  	newRecord := digitalocean.CreateRecord{
    27  		Type:     rs.Attributes["type"],
    28  		Name:     rs.Attributes["name"],
    29  		Data:     rs.Attributes["value"],
    30  		Priority: rs.Attributes["priority"],
    31  		Port:     rs.Attributes["port"],
    32  		Weight:   rs.Attributes["weight"],
    33  	}
    34  
    35  	log.Printf("[DEBUG] record create configuration: %#v", newRecord)
    36  
    37  	recId, err := client.CreateRecord(rs.Attributes["domain"], &newRecord)
    38  
    39  	if err != nil {
    40  		return nil, fmt.Errorf("Failed to create record: %s", err)
    41  	}
    42  
    43  	rs.ID = recId
    44  	log.Printf("[INFO] Record ID: %s", rs.ID)
    45  
    46  	record, err := resource_digitalocean_record_retrieve(rs.Attributes["domain"], rs.ID, client)
    47  	if err != nil {
    48  		return nil, fmt.Errorf("Couldn't find record: %s", err)
    49  	}
    50  
    51  	return resource_digitalocean_record_update_state(rs, record)
    52  }
    53  
    54  func resource_digitalocean_record_update(
    55  	s *terraform.ResourceState,
    56  	d *terraform.ResourceDiff,
    57  	meta interface{}) (*terraform.ResourceState, error) {
    58  	p := meta.(*ResourceProvider)
    59  	client := p.client
    60  	rs := s.MergeDiff(d)
    61  
    62  	updateRecord := digitalocean.UpdateRecord{}
    63  
    64  	if attr, ok := d.Attributes["name"]; ok {
    65  		updateRecord.Name = attr.New
    66  	}
    67  
    68  	log.Printf("[DEBUG] record update configuration: %#v", updateRecord)
    69  
    70  	err := client.UpdateRecord(rs.Attributes["domain"], rs.ID, &updateRecord)
    71  	if err != nil {
    72  		return rs, fmt.Errorf("Failed to update record: %s", err)
    73  	}
    74  
    75  	record, err := resource_digitalocean_record_retrieve(rs.Attributes["domain"], rs.ID, client)
    76  	if err != nil {
    77  		return rs, fmt.Errorf("Couldn't find record: %s", err)
    78  	}
    79  
    80  	return resource_digitalocean_record_update_state(rs, record)
    81  }
    82  
    83  func resource_digitalocean_record_destroy(
    84  	s *terraform.ResourceState,
    85  	meta interface{}) error {
    86  	p := meta.(*ResourceProvider)
    87  	client := p.client
    88  
    89  	log.Printf("[INFO] Deleting record: %s, %s", s.Attributes["domain"], s.ID)
    90  
    91  	err := client.DestroyRecord(s.Attributes["domain"], s.ID)
    92  
    93  	if err != nil {
    94  		return fmt.Errorf("Error deleting record: %s", err)
    95  	}
    96  
    97  	return nil
    98  }
    99  
   100  func resource_digitalocean_record_refresh(
   101  	s *terraform.ResourceState,
   102  	meta interface{}) (*terraform.ResourceState, error) {
   103  	p := meta.(*ResourceProvider)
   104  	client := p.client
   105  
   106  	rec, err := resource_digitalocean_record_retrieve(s.Attributes["domain"], s.ID, client)
   107  	if err != nil {
   108  		return nil, err
   109  	}
   110  
   111  	return resource_digitalocean_record_update_state(s, rec)
   112  }
   113  
   114  func resource_digitalocean_record_diff(
   115  	s *terraform.ResourceState,
   116  	c *terraform.ResourceConfig,
   117  	meta interface{}) (*terraform.ResourceDiff, error) {
   118  
   119  	b := &diff.ResourceBuilder{
   120  		Attrs: map[string]diff.AttrType{
   121  			"domain":   diff.AttrTypeCreate,
   122  			"name":     diff.AttrTypeUpdate,
   123  			"type":     diff.AttrTypeCreate,
   124  			"value":    diff.AttrTypeCreate,
   125  			"priority": diff.AttrTypeCreate,
   126  			"port":     diff.AttrTypeCreate,
   127  			"weight":   diff.AttrTypeCreate,
   128  		},
   129  
   130  		ComputedAttrs: []string{
   131  			"value",
   132  			"priority",
   133  			"weight",
   134  			"port",
   135  		},
   136  	}
   137  
   138  	return b.Diff(s, c)
   139  }
   140  
   141  func resource_digitalocean_record_update_state(
   142  	s *terraform.ResourceState,
   143  	rec *digitalocean.Record) (*terraform.ResourceState, error) {
   144  
   145  	s.Attributes["name"] = rec.Name
   146  	s.Attributes["type"] = rec.Type
   147  	s.Attributes["value"] = rec.Data
   148  	s.Attributes["weight"] = rec.StringWeight()
   149  	s.Attributes["priority"] = rec.StringPriority()
   150  	s.Attributes["port"] = rec.StringPort()
   151  
   152  	// We belong to a Domain
   153  	s.Dependencies = []terraform.ResourceDependency{
   154  		terraform.ResourceDependency{ID: s.Attributes["domain"]},
   155  	}
   156  
   157  	return s, nil
   158  }
   159  
   160  func resource_digitalocean_record_retrieve(domain string, id string, client *digitalocean.Client) (*digitalocean.Record, error) {
   161  	record, err := client.RetrieveRecord(domain, id)
   162  	if err != nil {
   163  		return nil, err
   164  	}
   165  
   166  	return &record, nil
   167  }
   168  
   169  func resource_digitalocean_record_validation() *config.Validator {
   170  	return &config.Validator{
   171  		Required: []string{
   172  			"type",
   173  			"domain",
   174  		},
   175  		Optional: []string{
   176  			"value",
   177  			"name",
   178  			"weight",
   179  			"port",
   180  			"priority",
   181  		},
   182  	}
   183  }