github.com/nicgrayson/terraform@v0.4.3-0.20150415203910-c4de50829380/builtin/providers/aws/resource_aws_route53_zone.go (about)

     1  package aws
     2  
     3  import (
     4  	"log"
     5  	"strings"
     6  	"time"
     7  
     8  	"github.com/hashicorp/terraform/helper/resource"
     9  	"github.com/hashicorp/terraform/helper/schema"
    10  
    11  	"github.com/hashicorp/aws-sdk-go/aws"
    12  	"github.com/hashicorp/aws-sdk-go/gen/route53"
    13  )
    14  
    15  func resourceAwsRoute53Zone() *schema.Resource {
    16  	return &schema.Resource{
    17  		Create: resourceAwsRoute53ZoneCreate,
    18  		Read:   resourceAwsRoute53ZoneRead,
    19  		Update: resourceAwsRoute53ZoneUpdate,
    20  		Delete: resourceAwsRoute53ZoneDelete,
    21  
    22  		Schema: map[string]*schema.Schema{
    23  			"name": &schema.Schema{
    24  				Type:     schema.TypeString,
    25  				Required: true,
    26  				ForceNew: true,
    27  			},
    28  
    29  			"zone_id": &schema.Schema{
    30  				Type:     schema.TypeString,
    31  				Computed: true,
    32  			},
    33  
    34  			"tags": tagsSchema(),
    35  		},
    36  	}
    37  }
    38  
    39  func resourceAwsRoute53ZoneCreate(d *schema.ResourceData, meta interface{}) error {
    40  	r53 := meta.(*AWSClient).r53conn
    41  
    42  	comment := &route53.HostedZoneConfig{Comment: aws.String("Managed by Terraform")}
    43  	req := &route53.CreateHostedZoneRequest{
    44  		Name:             aws.String(d.Get("name").(string)),
    45  		HostedZoneConfig: comment,
    46  		CallerReference:  aws.String(time.Now().Format(time.RFC3339Nano)),
    47  	}
    48  
    49  	log.Printf("[DEBUG] Creating Route53 hosted zone: %s", *req.Name)
    50  	resp, err := r53.CreateHostedZone(req)
    51  	if err != nil {
    52  		return err
    53  	}
    54  
    55  	// Store the zone_id
    56  	zone := cleanZoneID(*resp.HostedZone.ID)
    57  	d.Set("zone_id", zone)
    58  	d.SetId(zone)
    59  
    60  	// Wait until we are done initializing
    61  	wait := resource.StateChangeConf{
    62  		Delay:      30 * time.Second,
    63  		Pending:    []string{"PENDING"},
    64  		Target:     "INSYNC",
    65  		Timeout:    10 * time.Minute,
    66  		MinTimeout: 2 * time.Second,
    67  		Refresh: func() (result interface{}, state string, err error) {
    68  			changeRequest := &route53.GetChangeRequest{
    69  				ID: aws.String(cleanChangeID(*resp.ChangeInfo.ID)),
    70  			}
    71  			return resourceAwsGoRoute53Wait(r53, changeRequest)
    72  		},
    73  	}
    74  	_, err = wait.WaitForState()
    75  	if err != nil {
    76  		return err
    77  	}
    78  	return resourceAwsRoute53ZoneUpdate(d, meta)
    79  }
    80  
    81  func resourceAwsRoute53ZoneRead(d *schema.ResourceData, meta interface{}) error {
    82  	r53 := meta.(*AWSClient).r53conn
    83  	_, err := r53.GetHostedZone(&route53.GetHostedZoneRequest{ID: aws.String(d.Id())})
    84  	if err != nil {
    85  		// Handle a deleted zone
    86  		if r53err, ok := err.(aws.APIError); ok && r53err.Code == "NoSuchHostedZone" {
    87  			d.SetId("")
    88  			return nil
    89  		}
    90  		return err
    91  	}
    92  
    93  	// get tags
    94  	req := &route53.ListTagsForResourceRequest{
    95  		ResourceID:   aws.String(d.Id()),
    96  		ResourceType: aws.String("hostedzone"),
    97  	}
    98  
    99  	resp, err := r53.ListTagsForResource(req)
   100  	if err != nil {
   101  		return err
   102  	}
   103  
   104  	var tags []route53.Tag
   105  	if resp.ResourceTagSet != nil {
   106  		tags = resp.ResourceTagSet.Tags
   107  	}
   108  
   109  	if err := d.Set("tags", tagsToMapR53(tags)); err != nil {
   110  		return err
   111  	}
   112  
   113  	return nil
   114  }
   115  
   116  func resourceAwsRoute53ZoneUpdate(d *schema.ResourceData, meta interface{}) error {
   117  	conn := meta.(*AWSClient).r53conn
   118  
   119  	if err := setTagsR53(conn, d); err != nil {
   120  		return err
   121  	} else {
   122  		d.SetPartial("tags")
   123  	}
   124  
   125  	return resourceAwsRoute53ZoneRead(d, meta)
   126  }
   127  
   128  func resourceAwsRoute53ZoneDelete(d *schema.ResourceData, meta interface{}) error {
   129  	r53 := meta.(*AWSClient).r53conn
   130  
   131  	log.Printf("[DEBUG] Deleting Route53 hosted zone: %s (ID: %s)",
   132  		d.Get("name").(string), d.Id())
   133  	_, err := r53.DeleteHostedZone(&route53.DeleteHostedZoneRequest{ID: aws.String(d.Id())})
   134  	if err != nil {
   135  		return err
   136  	}
   137  
   138  	return nil
   139  }
   140  
   141  func resourceAwsGoRoute53Wait(r53 *route53.Route53, ref *route53.GetChangeRequest) (result interface{}, state string, err error) {
   142  
   143  	status, err := r53.GetChange(ref)
   144  	if err != nil {
   145  		return nil, "UNKNOWN", err
   146  	}
   147  	return true, *status.ChangeInfo.Status, nil
   148  }
   149  
   150  // cleanChangeID is used to remove the leading /change/
   151  func cleanChangeID(ID string) string {
   152  	return cleanPrefix(ID, "/change/")
   153  }
   154  
   155  // cleanZoneID is used to remove the leading /hostedzone/
   156  func cleanZoneID(ID string) string {
   157  	return cleanPrefix(ID, "/hostedzone/")
   158  }
   159  
   160  // cleanPrefix removes a string prefix from an ID
   161  func cleanPrefix(ID, prefix string) string {
   162  	if strings.HasPrefix(ID, prefix) {
   163  		ID = strings.TrimPrefix(ID, prefix)
   164  	}
   165  	return ID
   166  }