github.com/leeprovoost/terraform@v0.6.10-0.20160119085442-96f3f76118e7/builtin/providers/mailgun/resource_mailgun_domain.go (about)

     1  package mailgun
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/hashicorp/terraform/helper/schema"
     8  	"github.com/pearkes/mailgun"
     9  )
    10  
    11  func resourceMailgunDomain() *schema.Resource {
    12  	return &schema.Resource{
    13  		Create: resourceMailgunDomainCreate,
    14  		Read:   resourceMailgunDomainRead,
    15  		Delete: resourceMailgunDomainDelete,
    16  
    17  		Schema: map[string]*schema.Schema{
    18  			"name": &schema.Schema{
    19  				Type:     schema.TypeString,
    20  				Required: true,
    21  				ForceNew: true,
    22  			},
    23  
    24  			"spam_action": &schema.Schema{
    25  				Type:     schema.TypeString,
    26  				Computed: true,
    27  				ForceNew: true,
    28  				Optional: true,
    29  			},
    30  
    31  			"smtp_password": &schema.Schema{
    32  				Type:     schema.TypeString,
    33  				ForceNew: true,
    34  				Required: true,
    35  			},
    36  
    37  			"smtp_login": &schema.Schema{
    38  				Type:     schema.TypeString,
    39  				Computed: true,
    40  				Optional: true,
    41  			},
    42  
    43  			"wildcard": &schema.Schema{
    44  				Type:     schema.TypeBool,
    45  				Computed: true,
    46  				ForceNew: true,
    47  				Optional: true,
    48  			},
    49  
    50  			"receiving_records": &schema.Schema{
    51  				Type:     schema.TypeList,
    52  				Computed: true,
    53  				Elem: &schema.Resource{
    54  					Schema: map[string]*schema.Schema{
    55  						"priority": &schema.Schema{
    56  							Type:     schema.TypeString,
    57  							Computed: true,
    58  						},
    59  						"record_type": &schema.Schema{
    60  							Type:     schema.TypeString,
    61  							Computed: true,
    62  						},
    63  						"valid": &schema.Schema{
    64  							Type:     schema.TypeString,
    65  							Computed: true,
    66  						},
    67  						"value": &schema.Schema{
    68  							Type:     schema.TypeString,
    69  							Computed: true,
    70  						},
    71  					},
    72  				},
    73  			},
    74  
    75  			"sending_records": &schema.Schema{
    76  				Type:     schema.TypeList,
    77  				Computed: true,
    78  				Elem: &schema.Resource{
    79  					Schema: map[string]*schema.Schema{
    80  						"name": &schema.Schema{
    81  							Type:     schema.TypeString,
    82  							Computed: true,
    83  						},
    84  						"record_type": &schema.Schema{
    85  							Type:     schema.TypeString,
    86  							Computed: true,
    87  						},
    88  						"valid": &schema.Schema{
    89  							Type:     schema.TypeString,
    90  							Computed: true,
    91  						},
    92  						"value": &schema.Schema{
    93  							Type:     schema.TypeString,
    94  							Computed: true,
    95  						},
    96  					},
    97  				},
    98  			},
    99  		},
   100  	}
   101  }
   102  
   103  func resourceMailgunDomainCreate(d *schema.ResourceData, meta interface{}) error {
   104  	client := meta.(*mailgun.Client)
   105  
   106  	opts := mailgun.CreateDomain{}
   107  
   108  	opts.Name = d.Get("name").(string)
   109  	opts.SmtpPassword = d.Get("smtp_password").(string)
   110  	opts.SpamAction = d.Get("spam_action").(string)
   111  	opts.Wildcard = d.Get("wildcard").(bool)
   112  
   113  	log.Printf("[DEBUG] Domain create configuration: %#v", opts)
   114  
   115  	domain, err := client.CreateDomain(&opts)
   116  
   117  	if err != nil {
   118  		return err
   119  	}
   120  
   121  	d.SetId(domain)
   122  
   123  	log.Printf("[INFO] Domain ID: %s", d.Id())
   124  
   125  	// Retrieve and update state of domain
   126  	_, err = resourceMailginDomainRetrieve(d.Id(), client, d)
   127  
   128  	if err != nil {
   129  		return err
   130  	}
   131  
   132  	return nil
   133  }
   134  
   135  func resourceMailgunDomainDelete(d *schema.ResourceData, meta interface{}) error {
   136  	client := meta.(*mailgun.Client)
   137  
   138  	log.Printf("[INFO] Deleting Domain: %s", d.Id())
   139  
   140  	// Destroy the domain
   141  	err := client.DestroyDomain(d.Id())
   142  	if err != nil {
   143  		return fmt.Errorf("Error deleting domain: %s", err)
   144  	}
   145  
   146  	return nil
   147  }
   148  
   149  func resourceMailgunDomainRead(d *schema.ResourceData, meta interface{}) error {
   150  	client := meta.(*mailgun.Client)
   151  
   152  	_, err := resourceMailginDomainRetrieve(d.Id(), client, d)
   153  
   154  	if err != nil {
   155  		return err
   156  	}
   157  
   158  	return nil
   159  }
   160  
   161  func resourceMailginDomainRetrieve(id string, client *mailgun.Client, d *schema.ResourceData) (*mailgun.DomainResponse, error) {
   162  	resp, err := client.RetrieveDomain(id)
   163  
   164  	if err != nil {
   165  		return nil, fmt.Errorf("Error retrieving domain: %s", err)
   166  	}
   167  
   168  	d.Set("name", resp.Domain.Name)
   169  	d.Set("smtp_password", resp.Domain.SmtpPassword)
   170  	d.Set("smtp_login", resp.Domain.SmtpLogin)
   171  	d.Set("wildcard", resp.Domain.Wildcard)
   172  	d.Set("spam_action", resp.Domain.SpamAction)
   173  
   174  	receivingRecords := make([]map[string]interface{}, len(resp.ReceivingRecords))
   175  	for i, r := range resp.ReceivingRecords {
   176  		receivingRecords[i] = make(map[string]interface{})
   177  		receivingRecords[i]["priority"] = r.Priority
   178  		receivingRecords[i]["valid"] = r.Valid
   179  		receivingRecords[i]["value"] = r.Value
   180  		receivingRecords[i]["record_type"] = r.RecordType
   181  	}
   182  	d.Set("receiving_records", receivingRecords)
   183  
   184  	sendingRecords := make([]map[string]interface{}, len(resp.SendingRecords))
   185  	for i, r := range resp.SendingRecords {
   186  		sendingRecords[i] = make(map[string]interface{})
   187  		sendingRecords[i]["name"] = r.Name
   188  		sendingRecords[i]["valid"] = r.Valid
   189  		sendingRecords[i]["value"] = r.Value
   190  		sendingRecords[i]["record_type"] = r.RecordType
   191  	}
   192  	d.Set("sending_records", sendingRecords)
   193  
   194  	return &resp, nil
   195  }