github.com/IBM-Cloud/terraform@v0.6.4-0.20170726051544-8872b87621df/builtin/providers/google/resource_dns_managed_zone.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/hashicorp/terraform/helper/schema"
     8  	"google.golang.org/api/dns/v1"
     9  )
    10  
    11  func resourceDnsManagedZone() *schema.Resource {
    12  	return &schema.Resource{
    13  		Create: resourceDnsManagedZoneCreate,
    14  		Read:   resourceDnsManagedZoneRead,
    15  		Delete: resourceDnsManagedZoneDelete,
    16  		Importer: &schema.ResourceImporter{
    17  			State: schema.ImportStatePassthrough,
    18  		},
    19  		Schema: map[string]*schema.Schema{
    20  			"dns_name": &schema.Schema{
    21  				Type:     schema.TypeString,
    22  				Required: true,
    23  				ForceNew: true,
    24  			},
    25  
    26  			"name": &schema.Schema{
    27  				Type:     schema.TypeString,
    28  				Required: true,
    29  				ForceNew: true,
    30  			},
    31  
    32  			"description": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Optional: true,
    35  				ForceNew: true,
    36  				Default:  "Managed by Terraform",
    37  			},
    38  
    39  			"name_servers": &schema.Schema{
    40  				Type:     schema.TypeList,
    41  				Computed: true,
    42  				Elem: &schema.Schema{
    43  					Type: schema.TypeString,
    44  				},
    45  			},
    46  
    47  			// Google Cloud DNS ManagedZone resources do not have a SelfLink attribute.
    48  
    49  			"project": &schema.Schema{
    50  				Type:     schema.TypeString,
    51  				Optional: true,
    52  				ForceNew: true,
    53  			},
    54  		},
    55  	}
    56  }
    57  
    58  func resourceDnsManagedZoneCreate(d *schema.ResourceData, meta interface{}) error {
    59  	config := meta.(*Config)
    60  
    61  	project, err := getProject(d, config)
    62  	if err != nil {
    63  		return err
    64  	}
    65  
    66  	// Build the parameter
    67  	zone := &dns.ManagedZone{
    68  		Name:    d.Get("name").(string),
    69  		DnsName: d.Get("dns_name").(string),
    70  	}
    71  	// Optional things
    72  	if v, ok := d.GetOk("description"); ok {
    73  		zone.Description = v.(string)
    74  	}
    75  	if v, ok := d.GetOk("dns_name"); ok {
    76  		zone.DnsName = v.(string)
    77  	}
    78  
    79  	log.Printf("[DEBUG] DNS ManagedZone create request: %#v", zone)
    80  	zone, err = config.clientDns.ManagedZones.Create(project, zone).Do()
    81  	if err != nil {
    82  		return fmt.Errorf("Error creating DNS ManagedZone: %s", err)
    83  	}
    84  
    85  	d.SetId(zone.Name)
    86  
    87  	return resourceDnsManagedZoneRead(d, meta)
    88  }
    89  
    90  func resourceDnsManagedZoneRead(d *schema.ResourceData, meta interface{}) error {
    91  	config := meta.(*Config)
    92  
    93  	project, err := getProject(d, config)
    94  	if err != nil {
    95  		return err
    96  	}
    97  
    98  	zone, err := config.clientDns.ManagedZones.Get(
    99  		project, d.Id()).Do()
   100  	if err != nil {
   101  		return handleNotFoundError(err, d, fmt.Sprintf("DNS Managed Zone %q", d.Get("name").(string)))
   102  	}
   103  
   104  	d.Set("name_servers", zone.NameServers)
   105  	d.Set("name", zone.Name)
   106  	d.Set("dns_name", zone.DnsName)
   107  	d.Set("description", zone.Description)
   108  
   109  	return nil
   110  }
   111  
   112  func resourceDnsManagedZoneDelete(d *schema.ResourceData, meta interface{}) error {
   113  	config := meta.(*Config)
   114  
   115  	project, err := getProject(d, config)
   116  	if err != nil {
   117  		return err
   118  	}
   119  
   120  	err = config.clientDns.ManagedZones.Delete(project, d.Id()).Do()
   121  	if err != nil {
   122  		return fmt.Errorf("Error deleting DNS ManagedZone: %s", err)
   123  	}
   124  
   125  	d.SetId("")
   126  	return nil
   127  }