Merge pull request #569 from svanharmelen/f-refactor-dnsimple-provider

Refactor to use the schema.Provider approach

builtin/bins/provider-dnsimple/main.go

@@ -3,13 +3,10 @@ package main
 import (
 	"github.com/hashicorp/terraform/builtin/providers/dnsimple"
 	"github.com/hashicorp/terraform/plugin"
-	"github.com/hashicorp/terraform/terraform"
 )
 
 func main() {
 	plugin.Serve(&plugin.ServeOpts{
-		ProviderFunc: func() terraform.ResourceProvider {
-			return new(dnsimple.ResourceProvider)
-		},
+		ProviderFunc: dnsimple.Provider,
 	})
 }

builtin/providers/dnsimple/config.go

@@ -3,29 +3,17 @@ package dnsimple
 import (
 	"fmt"
 	"log"
-	"os"
 
 	"github.com/pearkes/dnsimple"
 )
 
 type Config struct {
-	Token string `mapstructure:"token"`
-	Email string `mapstructure:"email"`
+	Email string
+	Token string
 }
 
 // Client() returns a new client for accessing dnsimple.
-//
 func (c *Config) Client() (*dnsimple.Client, error) {
-
-	// If we have env vars set (like in the acc) tests,
-	// we need to override the values passed in here.
-	if v := os.Getenv("DNSIMPLE_EMAIL"); v != "" {
-		c.Email = v
-	}
-	if v := os.Getenv("DNSIMPLE_TOKEN"); v != "" {
-		c.Token = v
-	}
-
 	client, err := dnsimple.NewClient(c.Email, c.Token)
 
 	if err != nil {

builtin/providers/dnsimple/provider.go

@@ -0,0 +1,54 @@
+package dnsimple
+
+import (
+	"os"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+// Provider returns a terraform.ResourceProvider.
+func Provider() terraform.ResourceProvider {
+	return &schema.Provider{
+		Schema: map[string]*schema.Schema{
+			"email": &schema.Schema{
+				Type:        schema.TypeString,
+				Required:    true,
+				DefaultFunc: envDefaultFunc("DNSIMPLE_EMAIL"),
+				Description: "A registered DNSimple email address.",
+			},
+
+			"token": &schema.Schema{
+				Type:        schema.TypeString,
+				Required:    true,
+				DefaultFunc: envDefaultFunc("DNSIMPLE_TOKEN"),
+				Description: "The token key for API operations.",
+			},
+		},
+
+		ResourcesMap: map[string]*schema.Resource{
+			"dnsimple_record": resourceDNSimpleRecord(),
+		},
+
+		ConfigureFunc: providerConfigure,
+	}
+}
+
+func envDefaultFunc(k string) schema.SchemaDefaultFunc {
+	return func() (interface{}, error) {
+		if v := os.Getenv(k); v != "" {
+			return v, nil
+		}
+
+		return nil, nil
+	}
+}
+
+func providerConfigure(d *schema.ResourceData) (interface{}, error) {
+	config := Config{
+		Email: d.Get("email").(string),
+		Token: d.Get("token").(string),
+	}
+
+	return config.Client()
+}

builtin/providers/dnsimple/provider_test.go

@@ -0,0 +1,43 @@
+package dnsimple
+
+import (
+	"os"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+var testAccProviders map[string]terraform.ResourceProvider
+var testAccProvider *schema.Provider
+
+func init() {
+	testAccProvider = Provider().(*schema.Provider)
+	testAccProviders = map[string]terraform.ResourceProvider{
+		"dnsimple": testAccProvider,
+	}
+}
+
+func TestProvider(t *testing.T) {
+	if err := Provider().(*schema.Provider).InternalValidate(); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+}
+
+func TestProvider_impl(t *testing.T) {
+	var _ terraform.ResourceProvider = Provider()
+}
+
+func testAccPreCheck(t *testing.T) {
+	if v := os.Getenv("DNSIMPLE_EMAIL"); v == "" {
+		t.Fatal("DNSIMPLE_EMAIL must be set for acceptance tests")
+	}
+
+	if v := os.Getenv("DNSIMPLE_TOKEN"); v == "" {
+		t.Fatal("DNSIMPLE_TOKEN must be set for acceptance tests")
+	}
+
+	if v := os.Getenv("DNSIMPLE_DOMAIN"); v == "" {
+		t.Fatal("DNSIMPLE_DOMAIN must be set for acceptance tests. The domain is used to ` and destroy record against.")
+	}
+}

builtin/providers/dnsimple/resource_dnsimple_record.go

@@ -4,104 +4,150 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/hashicorp/terraform/helper/config"
-	"github.com/hashicorp/terraform/helper/diff"
-	"github.com/hashicorp/terraform/terraform"
+	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/pearkes/dnsimple"
 )
 
-func resource_dnsimple_record_create(
-	s *terraform.InstanceState,
-	d *terraform.InstanceDiff,
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	client := p.client
+func resourceDNSimpleRecord() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceDNSimpleRecordCreate,
+		Read:   resourceDNSimpleRecordRead,
+		Update: resourceDNSimpleRecordUpdate,
+		Delete: resourceDNSimpleRecordDelete,
 
-	// Merge the diff into the state so that we have all the attributes
-	// properly.
-	rs := s.MergeDiff(d)
+		Schema: map[string]*schema.Schema{
+			"domain": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
 
-	var err error
+			"domain_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
 
-	newRecord := dnsimple.ChangeRecord{
-		Name:  rs.Attributes["name"],
-		Value: rs.Attributes["value"],
-		Type:  rs.Attributes["type"],
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"hostname": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"type": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"value": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"ttl": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+
+			"priority": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func resourceDNSimpleRecordCreate(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*dnsimple.Client)
+
+	// Create the new record
+	newRecord := &dnsimple.ChangeRecord{
+		Name:  d.Get("name").(string),
+		Type:  d.Get("type").(string),
+		Value: d.Get("value").(string),
 	}
 
-	if attr, ok := rs.Attributes["ttl"]; ok {
-		newRecord.Ttl = attr
+	if ttl, ok := d.GetOk("ttl"); ok {
+		newRecord.Ttl = ttl.(string)
 	}
 
 	log.Printf("[DEBUG] record create configuration: %#v", newRecord)
 
-	recId, err := client.CreateRecord(rs.Attributes["domain"], &newRecord)
+	recId, err := client.CreateRecord(d.Get("domain").(string), newRecord)
 
 	if err != nil {
-		return nil, fmt.Errorf("Failed to create record: %s", err)
+		return fmt.Errorf("Failed to create record: %s", err)
 	}
 
-	rs.ID = recId
-	log.Printf("[INFO] record ID: %s", rs.ID)
+	d.SetId(recId)
+	log.Printf("[INFO] record ID: %s", d.Id())
 
-	record, err := resource_dnsimple_record_retrieve(rs.Attributes["domain"], rs.ID, client)
-	if err != nil {
-		return nil, fmt.Errorf("Couldn't find record: %s", err)
-	}
-
-	return resource_dnsimple_record_update_state(rs, record)
+	return resourceDNSimpleRecordRead(d, meta)
 }
 
-func resource_dnsimple_record_update(
-	s *terraform.InstanceState,
-	d *terraform.InstanceDiff,
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	client := p.client
-	rs := s.MergeDiff(d)
+func resourceDNSimpleRecordRead(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*dnsimple.Client)
 
-	updateRecord := dnsimple.ChangeRecord{}
-
-	if attr, ok := d.Attributes["name"]; ok {
-		updateRecord.Name = attr.New
+	rec, err := client.RetrieveRecord(d.Get("domain").(string), d.Id())
+	if err != nil {
+		return fmt.Errorf("Couldn't find record: %s", err)
 	}
 
-	if attr, ok := d.Attributes["value"]; ok {
-		updateRecord.Value = attr.New
+	d.Set("domain_id", rec.StringDomainId())
+	d.Set("name", rec.Name)
+	d.Set("type", rec.RecordType)
+	d.Set("value", rec.Content)
+	d.Set("ttl", rec.StringTtl())
+	d.Set("priority", rec.StringPrio())
+
+	if rec.Name == "" {
+		d.Set("hostname", d.Get("domain").(string))
+	} else {
+		d.Set("hostname", fmt.Sprintf("%s.%s", rec.Name, d.Get("domain").(string)))
 	}
 
-	if attr, ok := d.Attributes["type"]; ok {
-		updateRecord.Type = attr.New
+	return nil
+}
+
+func resourceDNSimpleRecordUpdate(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*dnsimple.Client)
+
+	updateRecord := &dnsimple.ChangeRecord{}
+
+	if attr, ok := d.GetOk("name"); ok {
+		updateRecord.Name = attr.(string)
 	}
 
-	if attr, ok := d.Attributes["ttl"]; ok {
-		updateRecord.Ttl = attr.New
+	if attr, ok := d.GetOk("type"); ok {
+		updateRecord.Type = attr.(string)
+	}
+
+	if attr, ok := d.GetOk("value"); ok {
+		updateRecord.Value = attr.(string)
+	}
+
+	if attr, ok := d.GetOk("ttl"); ok {
+		updateRecord.Ttl = attr.(string)
 	}
 
 	log.Printf("[DEBUG] record update configuration: %#v", updateRecord)
 
-	_, err := client.UpdateRecord(rs.Attributes["domain"], rs.ID, &updateRecord)
+	_, err := client.UpdateRecord(d.Get("domain").(string), d.Id(), updateRecord)
 	if err != nil {
-		return rs, fmt.Errorf("Failed to update record: %s", err)
+		return fmt.Errorf("Failed to update record: %s", err)
 	}
 
-	record, err := resource_dnsimple_record_retrieve(rs.Attributes["domain"], rs.ID, client)
-	if err != nil {
-		return rs, fmt.Errorf("Couldn't find record: %s", err)
-	}
-
-	return resource_dnsimple_record_update_state(rs, record)
+	return resourceDNSimpleRecordRead(d, meta)
 }
 
-func resource_dnsimple_record_destroy(
-	s *terraform.InstanceState,
-	meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	client := p.client
+func resourceDNSimpleRecordDelete(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*dnsimple.Client)
 
-	log.Printf("[INFO] Deleting record: %s, %s", s.Attributes["domain"], s.ID)
+	log.Printf("[INFO] Deleting record: %s, %s", d.Get("domain").(string), d.Id())
 
-	err := client.DestroyRecord(s.Attributes["domain"], s.ID)
+	err := client.DestroyRecord(d.Get("domain").(string), d.Id())
 
 	if err != nil {
 		return fmt.Errorf("Error deleting record: %s", err)
@@ -109,88 +155,3 @@ func resource_dnsimple_record_destroy(
 
 	return nil
 }
-
-func resource_dnsimple_record_refresh(
-	s *terraform.InstanceState,
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	client := p.client
-
-	rec, err := resource_dnsimple_record_retrieve(s.Attributes["domain"], s.ID, client)
-	if err != nil {
-		return nil, err
-	}
-
-	return resource_dnsimple_record_update_state(s, rec)
-}
-
-func resource_dnsimple_record_diff(
-	s *terraform.InstanceState,
-	c *terraform.ResourceConfig,
-	meta interface{}) (*terraform.InstanceDiff, error) {
-
-	b := &diff.ResourceBuilder{
-		Attrs: map[string]diff.AttrType{
-			"domain": diff.AttrTypeCreate,
-			"name":   diff.AttrTypeUpdate,
-			"value":  diff.AttrTypeUpdate,
-			"ttl":    diff.AttrTypeUpdate,
-			"type":   diff.AttrTypeUpdate,
-		},
-
-		ComputedAttrs: []string{
-			"priority",
-			"domain_id",
-			"ttl",
-		},
-
-		ComputedAttrsUpdate: []string{
-			"hostname",
-		},
-	}
-
-	return b.Diff(s, c)
-}
-
-func resource_dnsimple_record_update_state(
-	s *terraform.InstanceState,
-	rec *dnsimple.Record) (*terraform.InstanceState, error) {
-
-	s.Attributes["name"] = rec.Name
-	s.Attributes["value"] = rec.Content
-	s.Attributes["type"] = rec.RecordType
-	s.Attributes["ttl"] = rec.StringTtl()
-	s.Attributes["priority"] = rec.StringPrio()
-	s.Attributes["domain_id"] = rec.StringDomainId()
-
-	if rec.Name == "" {
-		s.Attributes["hostname"] = s.Attributes["domain"]
-	} else {
-		s.Attributes["hostname"] = fmt.Sprintf("%s.%s", rec.Name, s.Attributes["domain"])
-	}
-
-	return s, nil
-}
-
-func resource_dnsimple_record_retrieve(domain string, id string, client *dnsimple.Client) (*dnsimple.Record, error) {
-	record, err := client.RetrieveRecord(domain, id)
-	if err != nil {
-		return nil, err
-	}
-
-	return record, nil
-}
-
-func resource_dnsimple_record_validation() *config.Validator {
-	return &config.Validator{
-		Required: []string{
-			"domain",
-			"name",
-			"value",
-			"type",
-		},
-		Optional: []string{
-			"ttl",
-		},
-	}
-}

builtin/providers/dnsimple/resource_dnsimple_record_test.go

@@ -76,7 +76,7 @@ func TestAccDNSimpleRecord_Updated(t *testing.T) {
 }
 
 func testAccCheckDNSimpleRecordDestroy(s *terraform.State) error {
-	client := testAccProvider.client
+	client := testAccProvider.Meta().(*dnsimple.Client)
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "dnsimple_record" {
@@ -127,7 +127,7 @@ func testAccCheckDNSimpleRecordExists(n string, record *dnsimple.Record) resourc
 			return fmt.Errorf("No Record ID is set")
 		}
 
-		client := testAccProvider.client
+		client := testAccProvider.Meta().(*dnsimple.Client)
 
 		foundRecord, err := client.RetrieveRecord(rs.Primary.Attributes["domain"], rs.Primary.ID)
 

builtin/providers/dnsimple/resource_provider.go

@@ -1,77 +0,0 @@
-package dnsimple
-
-import (
-	"log"
-
-	"github.com/hashicorp/terraform/helper/config"
-	"github.com/hashicorp/terraform/terraform"
-	"github.com/pearkes/dnsimple"
-)
-
-type ResourceProvider struct {
-	Config Config
-
-	client *dnsimple.Client
-}
-
-func (p *ResourceProvider) Input(
-	input terraform.UIInput,
-	c *terraform.ResourceConfig) (*terraform.ResourceConfig, error) {
-	return c, nil
-}
-
-func (p *ResourceProvider) Validate(c *terraform.ResourceConfig) ([]string, []error) {
-	v := &config.Validator{
-		Required: []string{
-			"token",
-			"email",
-		},
-	}
-
-	return v.Validate(c)
-}
-
-func (p *ResourceProvider) ValidateResource(
-	t string, c *terraform.ResourceConfig) ([]string, []error) {
-	return resourceMap.Validate(t, c)
-}
-
-func (p *ResourceProvider) Configure(c *terraform.ResourceConfig) error {
-	if _, err := config.Decode(&p.Config, c.Config); err != nil {
-		return err
-	}
-
-	log.Println("[INFO] Initializing DNSimple client")
-	var err error
-	p.client, err = p.Config.Client()
-
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (p *ResourceProvider) Apply(
-	info *terraform.InstanceInfo,
-	s *terraform.InstanceState,
-	d *terraform.InstanceDiff) (*terraform.InstanceState, error) {
-	return resourceMap.Apply(info, s, d, p)
-}
-
-func (p *ResourceProvider) Diff(
-	info *terraform.InstanceInfo,
-	s *terraform.InstanceState,
-	c *terraform.ResourceConfig) (*terraform.InstanceDiff, error) {
-	return resourceMap.Diff(info, s, c, p)
-}
-
-func (p *ResourceProvider) Refresh(
-	info *terraform.InstanceInfo,
-	s *terraform.InstanceState) (*terraform.InstanceState, error) {
-	return resourceMap.Refresh(info, s, p)
-}
-
-func (p *ResourceProvider) Resources() []terraform.ResourceType {
-	return resourceMap.Resources()
-}

builtin/providers/dnsimple/resource_provider_test.go

@@ -1,80 +0,0 @@
-package dnsimple
-
-import (
-	"os"
-	"reflect"
-	"testing"
-
-	"github.com/hashicorp/terraform/config"
-	"github.com/hashicorp/terraform/terraform"
-)
-
-var testAccProviders map[string]terraform.ResourceProvider
-var testAccProvider *ResourceProvider
-
-func init() {
-	testAccProvider = new(ResourceProvider)
-	testAccProviders = map[string]terraform.ResourceProvider{
-		"dnsimple": testAccProvider,
-	}
-}
-
-func TestResourceProvider_impl(t *testing.T) {
-	var _ terraform.ResourceProvider = new(ResourceProvider)
-}
-
-func TestResourceProvider_Configure(t *testing.T) {
-	rp := new(ResourceProvider)
-	var expectedToken string
-	var expectedEmail string
-
-	if v := os.Getenv("DNSIMPLE_EMAIL"); v != "" {
-		expectedEmail = v
-	} else {
-		expectedEmail = "foo"
-	}
-
-	if v := os.Getenv("DNSIMPLE_TOKEN"); v != "" {
-		expectedToken = v
-	} else {
-		expectedToken = "foo"
-	}
-
-	raw := map[string]interface{}{
-		"token": expectedToken,
-		"email": expectedEmail,
-	}
-
-	rawConfig, err := config.NewRawConfig(raw)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = rp.Configure(terraform.NewResourceConfig(rawConfig))
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	expected := Config{
-		Token: expectedToken,
-		Email: expectedEmail,
-	}
-
-	if !reflect.DeepEqual(rp.Config, expected) {
-		t.Fatalf("bad: %#v", rp.Config)
-	}
-}
-
-func testAccPreCheck(t *testing.T) {
-	if v := os.Getenv("DNSIMPLE_EMAIL"); v == "" {
-		t.Fatal("DNSIMPLE_EMAIL must be set for acceptance tests")
-	}
-
-	if v := os.Getenv("DNSIMPLE_TOKEN"); v == "" {
-		t.Fatal("DNSIMPLE_TOKEN must be set for acceptance tests")
-	}
-
-	if v := os.Getenv("DNSIMPLE_DOMAIN"); v == "" {
-		t.Fatal("DNSIMPLE_DOMAIN must be set for acceptance tests. The domain is used to ` and destroy record against.")
-	}
-}

builtin/providers/dnsimple/resources.go

@@ -1,24 +0,0 @@
-package dnsimple
-
-import (
-	"github.com/hashicorp/terraform/helper/resource"
-)
-
-// resourceMap is the mapping of resources we support to their basic
-// operations. This makes it easy to implement new resource types.
-var resourceMap *resource.Map
-
-func init() {
-	resourceMap = &resource.Map{
-		Mapping: map[string]resource.Resource{
-			"dnsimple_record": resource.Resource{
-				ConfigValidator: resource_dnsimple_record_validation(),
-				Create:          resource_dnsimple_record_create,
-				Destroy:         resource_dnsimple_record_destroy,
-				Diff:            resource_dnsimple_record_diff,
-				Update:          resource_dnsimple_record_update,
-				Refresh:         resource_dnsimple_record_refresh,
-			},
-		},
-	}
-}