provider/cloudflare: Add proxied option (hashicorp#5508)

This change adds the support for the proxied configuration option for a
record which enables origin protection for CloudFlare records.

In order to do so the golang library needed to be changed as the old did
not support the option and was using and outdated API version.

Open issues which ask for this (hashicorp#5049, hashicorp#3805).

Author: xla

Godeps/Godeps.json

@@ -1,10 +1,9 @@
 package cloudflare
 
 import (
-	"fmt"
 	"log"
 
-	"github.com/pearkes/cloudflare"
+	"github.com/crackcomm/cloudflare"
 )
 
 type Config struct {
@@ -14,13 +13,12 @@ type Config struct {
 
 // Client() returns a new client for accessing cloudflare.
 func (c *Config) Client() (*cloudflare.Client, error) {
-	client, err := cloudflare.NewClient(c.Email, c.Token)
+	client := cloudflare.New(&cloudflare.Options{
+		Email: c.Email,
+		Key:   c.Token,
+	})
 
-	if err != nil {
-		return nil, fmt.Errorf("Error setting up client: %s", err)
-	}
-
-	log.Printf("[INFO] CloudFlare Client configured for user: %s", client.Email)
+	log.Printf("[INFO] CloudFlare Client configured for user: %s", c.Email)
 
 	return client, nil
 }

builtin/providers/cloudflare/config.go

@@ -38,6 +38,6 @@ func testAccPreCheck(t *testing.T) {
 	}
 
 	if v := os.Getenv("CLOUDFLARE_DOMAIN"); v == "" {
-		t.Fatal("CLOUDFLARE_DOMAIN must be set for acceptance tests. The domain is used to ` and destroy record against.")
+		t.Fatal("CLOUDFLARE_DOMAIN must be set for acceptance tests. The domain is used to create and destroy record against.")
 	}
 }

builtin/providers/cloudflare/provider_test.go

@@ -4,9 +4,12 @@ import (
 	"fmt"
 	"log"
 	"strings"
+	"time"
 
+	"golang.org/x/net/context"
+
+	"github.com/crackcomm/cloudflare"
 	"github.com/hashicorp/terraform/helper/schema"
-	"github.com/pearkes/cloudflare"
 )
 
 func resourceCloudFlareRecord() *schema.Resource {
@@ -44,14 +47,25 @@ func resourceCloudFlareRecord() *schema.Resource {
 			},
 
 			"ttl": &schema.Schema{
-				Type:     schema.TypeString,
+				Type:     schema.TypeInt,
 				Optional: true,
 				Computed: true,
 			},
 
 			"priority": &schema.Schema{
-				Type:     schema.TypeString,
+				Type:     schema.TypeInt,
+				Optional: true,
+			},
+
+			"proxied": &schema.Schema{
+				Default:  false,
 				Optional: true,
+				Type:     schema.TypeBool,
+			},
+
+			"zone_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
 			},
 		},
 	}
@@ -60,81 +74,111 @@ func resourceCloudFlareRecord() *schema.Resource {
 func resourceCloudFlareRecordCreate(d *schema.ResourceData, meta interface{}) error {
 	client := meta.(*cloudflare.Client)
 
-	// Create the new record
-	newRecord := &cloudflare.CreateRecord{
-		Name:    d.Get("name").(string),
-		Type:    d.Get("type").(string),
-		Content: d.Get("value").(string),
+	newRecord := &cloudflare.Record{
+		Content:  d.Get("value").(string),
+		Name:     d.Get("name").(string),
+		Proxied:  d.Get("proxied").(bool),
+		Type:     d.Get("type").(string),
+		ZoneName: d.Get("domain").(string),
+	}
+
+	if priority, ok := d.GetOk("priority"); ok {
+		newRecord.Priority = priority.(int)
 	}
 
 	if ttl, ok := d.GetOk("ttl"); ok {
-		newRecord.Ttl = ttl.(string)
+		newRecord.TTL = ttl.(int)
 	}
 
-	if priority, ok := d.GetOk("priority"); ok {
-		newRecord.Priority = priority.(string)
+	zone, err := retrieveZone(client, newRecord.ZoneName)
+	if err != nil {
+		return err
 	}
 
+	d.Set("zone_id", zone.ID)
+	newRecord.ZoneID = zone.ID
+
 	log.Printf("[DEBUG] CloudFlare Record create configuration: %#v", newRecord)
 
-	rec, err := client.CreateRecord(d.Get("domain").(string), newRecord)
+	ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(time.Second*30))
 
+	err = client.Records.Create(ctx, newRecord)
 	if err != nil {
-		return fmt.Errorf("Failed to create CloudFlare Record: %s", err)
+		return fmt.Errorf("Failed to create record: %s", err)
 	}
 
-	d.SetId(rec.Id)
+	d.SetId(newRecord.ID)
+
 	log.Printf("[INFO] CloudFlare Record ID: %s", d.Id())
 
 	return resourceCloudFlareRecordRead(d, meta)
 }
 
 func resourceCloudFlareRecordRead(d *schema.ResourceData, meta interface{}) error {
-	client := meta.(*cloudflare.Client)
+	var (
+		client = meta.(*cloudflare.Client)
+		domain = d.Get("domain").(string)
+		rName  = strings.Join([]string{d.Get("name").(string), domain}, ".")
+	)
 
-	rec, err := client.RetrieveRecord(d.Get("domain").(string), d.Id())
+	zone, err := retrieveZone(client, domain)
 	if err != nil {
-		if strings.Contains(err.Error(), "not found") {
-			d.SetId("")
-			return nil
-		}
+		return err
+	}
 
-		return fmt.Errorf(
-			"Couldn't find CloudFlare Record ID (%s) for domain (%s): %s",
-			d.Id(), d.Get("domain").(string), err)
+	record, err := retrieveRecord(client, zone, rName)
+	if err != nil {
+		return err
 	}
 
-	d.Set("name", rec.Name)
-	d.Set("hostname", rec.FullName)
-	d.Set("type", rec.Type)
-	d.Set("value", rec.Value)
-	d.Set("ttl", rec.Ttl)
-	d.Set("priority", rec.Priority)
+	d.SetId(record.ID)
+	d.Set("hostname", record.Name)
+	d.Set("type", record.Type)
+	d.Set("value", record.Content)
+	d.Set("ttl", record.TTL)
+	d.Set("priority", record.Priority)
+	d.Set("proxied", record.Proxied)
+	d.Set("zone_id", zone.ID)
 
 	return nil
 }
 
 func resourceCloudFlareRecordUpdate(d *schema.ResourceData, meta interface{}) error {
 	client := meta.(*cloudflare.Client)
 
-	// CloudFlare requires we send all values for an update request
-	updateRecord := &cloudflare.UpdateRecord{
-		Name:    d.Get("name").(string),
-		Type:    d.Get("type").(string),
-		Content: d.Get("value").(string),
+	updateRecord := &cloudflare.Record{
+		Content:  d.Get("value").(string),
+		ID:       d.Id(),
+		Name:     d.Get("name").(string),
+		Proxied:  false,
+		Type:     d.Get("type").(string),
+		ZoneName: d.Get("domain").(string),
+	}
+
+	if priority, ok := d.GetOk("priority"); ok {
+		updateRecord.Priority = priority.(int)
+	}
+
+	if proxied, ok := d.GetOk("proxied"); ok {
+		updateRecord.Proxied = proxied.(bool)
 	}
 
 	if ttl, ok := d.GetOk("ttl"); ok {
-		updateRecord.Ttl = ttl.(string)
+		updateRecord.TTL = ttl.(int)
 	}
 
-	if priority, ok := d.GetOk("priority"); ok {
-		updateRecord.Priority = priority.(string)
+	zone, err := retrieveZone(client, updateRecord.ZoneName)
+	if err != nil {
+		return err
 	}
 
+	updateRecord.ZoneID = zone.ID
+
 	log.Printf("[DEBUG] CloudFlare Record update configuration: %#v", updateRecord)
 
-	err := client.UpdateRecord(d.Get("domain").(string), d.Id(), updateRecord)
+	ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(time.Second*30))
+
+	err = client.Records.Patch(ctx, updateRecord)
 	if err != nil {
 		return fmt.Errorf("Failed to update CloudFlare Record: %s", err)
 	}
@@ -143,15 +187,79 @@ func resourceCloudFlareRecordUpdate(d *schema.ResourceData, meta interface{}) er
 }
 
 func resourceCloudFlareRecordDelete(d *schema.ResourceData, meta interface{}) error {
-	client := meta.(*cloudflare.Client)
+	var (
+		client = meta.(*cloudflare.Client)
+		domain = d.Get("domain").(string)
+		rName  = strings.Join([]string{d.Get("name").(string), domain}, ".")
+	)
+
+	zone, err := retrieveZone(client, domain)
+	if err != nil {
+		return err
+	}
 
-	log.Printf("[INFO] Deleting CloudFlare Record: %s, %s", d.Get("domain").(string), d.Id())
+	record, err := retrieveRecord(client, zone, rName)
+	if err != nil {
+		return err
+	}
 
-	err := client.DestroyRecord(d.Get("domain").(string), d.Id())
+	log.Printf("[INFO] Deleting CloudFlare Record: %s, %s", domain, d.Id())
 
+	ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(time.Second*30))
+
+	err = client.Records.Delete(ctx, zone.ID, record.ID)
 	if err != nil {
 		return fmt.Errorf("Error deleting CloudFlare Record: %s", err)
 	}
 
 	return nil
 }
+
+func retrieveRecord(
+	client *cloudflare.Client,
+	zone *cloudflare.Zone,
+	name string,
+) (*cloudflare.Record, error) {
+	ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(time.Second*30))
+
+	rs, err := client.Records.List(ctx, zone.ID)
+	if err != nil {
+		return nil, fmt.Errorf("Unable to retrieve records for (%s): %s", zone.Name, err)
+	}
+
+	var record *cloudflare.Record
+
+	for _, r := range rs {
+		if r.Name == name {
+			record = r
+		}
+	}
+	if record == nil {
+		return nil, fmt.Errorf("Unable to find Cloudflare record %s", name)
+	}
+
+	return record, nil
+}
+
+func retrieveZone(client *cloudflare.Client, domain string) (*cloudflare.Zone, error) {
+	ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(time.Second*30))
+
+	zs, err := client.Zones.List(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to fetch zone for %s: %s", domain, err)
+	}
+
+	var zone *cloudflare.Zone
+
+	for _, z := range zs {
+		if z.Name == domain {
+			zone = z
+		}
+	}
+
+	if zone == nil {
+		return nil, fmt.Errorf("Failed to find zone for: %s", domain)
+	}
+
+	return zone, nil
+}