317 lines
8.1 KiB
Go
317 lines
8.1 KiB
Go
package ultradns
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
|
|
"github.com/Ensighten/udnssdk"
|
|
"github.com/hashicorp/terraform/helper/schema"
|
|
)
|
|
|
|
func resourceUltradnsProbeHTTP() *schema.Resource {
|
|
return &schema.Resource{
|
|
Create: resourceUltradnsProbeHTTPCreate,
|
|
Read: resourceUltradnsProbeHTTPRead,
|
|
Update: resourceUltradnsProbeHTTPUpdate,
|
|
Delete: resourceUltradnsProbeHTTPDelete,
|
|
|
|
Schema: map[string]*schema.Schema{
|
|
// Key
|
|
"zone": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
ForceNew: true,
|
|
},
|
|
"name": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
ForceNew: true,
|
|
},
|
|
"pool_record": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Optional: true,
|
|
ForceNew: true,
|
|
},
|
|
// Required
|
|
"agents": &schema.Schema{
|
|
Type: schema.TypeSet,
|
|
Set: schema.HashString,
|
|
Required: true,
|
|
Elem: &schema.Schema{Type: schema.TypeString},
|
|
},
|
|
"threshold": &schema.Schema{
|
|
Type: schema.TypeInt,
|
|
Required: true,
|
|
},
|
|
// Optional
|
|
"interval": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Optional: true,
|
|
Default: "FIVE_MINUTES",
|
|
},
|
|
"http_probe": &schema.Schema{
|
|
Type: schema.TypeList,
|
|
Optional: true,
|
|
Elem: schemaHTTPProbe(),
|
|
},
|
|
// Computed
|
|
"id": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Computed: true,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func schemaHTTPProbe() *schema.Resource {
|
|
return &schema.Resource{
|
|
Schema: map[string]*schema.Schema{
|
|
"transaction": &schema.Schema{
|
|
Type: schema.TypeList,
|
|
Optional: true,
|
|
Elem: &schema.Resource{
|
|
Schema: map[string]*schema.Schema{
|
|
"method": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
},
|
|
"url": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Required: true,
|
|
},
|
|
"transmitted_data": &schema.Schema{
|
|
Type: schema.TypeString,
|
|
Optional: true,
|
|
},
|
|
"follow_redirects": &schema.Schema{
|
|
Type: schema.TypeBool,
|
|
Optional: true,
|
|
Default: false,
|
|
},
|
|
"limit": &schema.Schema{
|
|
Type: schema.TypeSet,
|
|
Optional: true,
|
|
Set: hashLimits,
|
|
Elem: resourceProbeLimits(),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"total_limits": &schema.Schema{
|
|
Type: schema.TypeList,
|
|
Optional: true,
|
|
Elem: &schema.Resource{
|
|
Schema: map[string]*schema.Schema{
|
|
"warning": &schema.Schema{
|
|
Type: schema.TypeInt,
|
|
Optional: true,
|
|
},
|
|
"critical": &schema.Schema{
|
|
Type: schema.TypeInt,
|
|
Optional: true,
|
|
},
|
|
"fail": &schema.Schema{
|
|
Type: schema.TypeInt,
|
|
Optional: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func resourceUltradnsProbeHTTPCreate(d *schema.ResourceData, meta interface{}) error {
|
|
client := meta.(*udnssdk.Client)
|
|
|
|
r, err := makeHTTPProbeResource(d)
|
|
if err != nil {
|
|
return fmt.Errorf("Could not load ultradns_probe_http configuration: %v", err)
|
|
}
|
|
|
|
log.Printf("[INFO] ultradns_probe_http create: %#v, detail: %#v", r, r.Details.Detail)
|
|
resp, err := client.Probes.Create(r.Key().RRSetKey(), r.ProbeInfoDTO())
|
|
if err != nil {
|
|
return fmt.Errorf("create failed: %v", err)
|
|
}
|
|
|
|
uri := resp.Header.Get("Location")
|
|
d.Set("uri", uri)
|
|
d.SetId(uri)
|
|
log.Printf("[INFO] ultradns_probe_http.id: %v", d.Id())
|
|
|
|
return resourceUltradnsProbeHTTPRead(d, meta)
|
|
}
|
|
|
|
func resourceUltradnsProbeHTTPRead(d *schema.ResourceData, meta interface{}) error {
|
|
client := meta.(*udnssdk.Client)
|
|
|
|
r, err := makeHTTPProbeResource(d)
|
|
if err != nil {
|
|
return fmt.Errorf("Could not load ultradns_probe_http configuration: %v", err)
|
|
}
|
|
|
|
log.Printf("[DEBUG] ultradns_probe_http read: %#v", r)
|
|
probe, _, err := client.Probes.Find(r.Key())
|
|
log.Printf("[DEBUG] ultradns_probe_http response: %#v", probe)
|
|
|
|
if err != nil {
|
|
uderr, ok := err.(*udnssdk.ErrorResponseList)
|
|
if ok {
|
|
for _, r := range uderr.Responses {
|
|
// 70002 means Probes Not Found
|
|
if r.ErrorCode == 70002 {
|
|
d.SetId("")
|
|
return nil
|
|
}
|
|
return fmt.Errorf("not found: %s", err)
|
|
}
|
|
}
|
|
return fmt.Errorf("not found: %s", err)
|
|
}
|
|
|
|
return populateResourceDataFromHTTPProbe(probe, d)
|
|
}
|
|
|
|
func resourceUltradnsProbeHTTPUpdate(d *schema.ResourceData, meta interface{}) error {
|
|
client := meta.(*udnssdk.Client)
|
|
|
|
r, err := makeHTTPProbeResource(d)
|
|
if err != nil {
|
|
return fmt.Errorf("Could not load ultradns_probe_http configuration: %v", err)
|
|
}
|
|
|
|
log.Printf("[INFO] ultradns_probe_http update: %+v", r)
|
|
_, err = client.Probes.Update(r.Key(), r.ProbeInfoDTO())
|
|
if err != nil {
|
|
return fmt.Errorf("update failed: %s", err)
|
|
}
|
|
|
|
return resourceUltradnsProbeHTTPRead(d, meta)
|
|
}
|
|
|
|
func resourceUltradnsProbeHTTPDelete(d *schema.ResourceData, meta interface{}) error {
|
|
client := meta.(*udnssdk.Client)
|
|
|
|
r, err := makeHTTPProbeResource(d)
|
|
if err != nil {
|
|
return fmt.Errorf("Could not load ultradns_probe_http configuration: %s", err)
|
|
}
|
|
|
|
log.Printf("[INFO] ultradns_probe_http delete: %+v", r)
|
|
_, err = client.Probes.Delete(r.Key())
|
|
if err != nil {
|
|
return fmt.Errorf("delete failed: %s", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Resource Helpers
|
|
|
|
func makeHTTPProbeResource(d *schema.ResourceData) (probeResource, error) {
|
|
p := probeResource{}
|
|
p.Zone = d.Get("zone").(string)
|
|
p.Name = d.Get("name").(string)
|
|
p.ID = d.Id()
|
|
p.Interval = d.Get("interval").(string)
|
|
p.PoolRecord = d.Get("pool_record").(string)
|
|
p.Threshold = d.Get("threshold").(int)
|
|
for _, a := range d.Get("agents").(*schema.Set).List() {
|
|
p.Agents = append(p.Agents, a.(string))
|
|
}
|
|
|
|
p.Type = udnssdk.HTTPProbeType
|
|
hps := d.Get("http_probe").([]interface{})
|
|
if len(hps) >= 1 {
|
|
if len(hps) > 1 {
|
|
return p, fmt.Errorf("http_probe: only 0 or 1 blocks alowed, got: %#v", len(hps))
|
|
}
|
|
p.Details = makeHTTPProbeDetails(hps[0])
|
|
}
|
|
|
|
return p, nil
|
|
}
|
|
|
|
func makeHTTPProbeDetails(configured interface{}) *udnssdk.ProbeDetailsDTO {
|
|
data := configured.(map[string]interface{})
|
|
// Convert limits from flattened set format to mapping.
|
|
d := udnssdk.HTTPProbeDetailsDTO{}
|
|
|
|
ts := []udnssdk.Transaction{}
|
|
for _, rt := range data["transaction"].([]interface{}) {
|
|
mt := rt.(map[string]interface{})
|
|
ls := make(map[string]udnssdk.ProbeDetailsLimitDTO)
|
|
for _, limit := range mt["limit"].(*schema.Set).List() {
|
|
l := limit.(map[string]interface{})
|
|
name := l["name"].(string)
|
|
ls[name] = *makeProbeDetailsLimit(l)
|
|
}
|
|
t := udnssdk.Transaction{
|
|
Method: mt["method"].(string),
|
|
URL: mt["url"].(string),
|
|
TransmittedData: mt["transmitted_data"].(string),
|
|
FollowRedirects: mt["follow_redirects"].(bool),
|
|
Limits: ls,
|
|
}
|
|
ts = append(ts, t)
|
|
}
|
|
d.Transactions = ts
|
|
rawLims := data["total_limits"].([]interface{})
|
|
if len(rawLims) >= 1 {
|
|
// TODO: validate 0 or 1 total_limits
|
|
// if len(rawLims) > 1 {
|
|
// return nil, fmt.Errorf("total_limits: only 0 or 1 blocks alowed, got: %#v", len(rawLims))
|
|
// }
|
|
d.TotalLimits = makeProbeDetailsLimit(rawLims[0])
|
|
}
|
|
res := udnssdk.ProbeDetailsDTO{
|
|
Detail: d,
|
|
}
|
|
return &res
|
|
}
|
|
|
|
func populateResourceDataFromHTTPProbe(p udnssdk.ProbeInfoDTO, d *schema.ResourceData) error {
|
|
d.SetId(p.ID)
|
|
d.Set("pool_record", p.PoolRecord)
|
|
d.Set("interval", p.Interval)
|
|
d.Set("agents", makeSetFromStrings(p.Agents))
|
|
d.Set("threshold", p.Threshold)
|
|
|
|
hp := map[string]interface{}{}
|
|
hd, err := p.Details.HTTPProbeDetails()
|
|
if err != nil {
|
|
return fmt.Errorf("ProbeInfo.details could not be unmarshalled: %v, Details: %#v", err, p.Details)
|
|
}
|
|
ts := make([]map[string]interface{}, 0, len(hd.Transactions))
|
|
for _, rt := range hd.Transactions {
|
|
t := map[string]interface{}{
|
|
"method": rt.Method,
|
|
"url": rt.URL,
|
|
"transmitted_data": rt.TransmittedData,
|
|
"follow_redirects": rt.FollowRedirects,
|
|
"limit": makeSetFromLimits(rt.Limits),
|
|
}
|
|
ts = append(ts, t)
|
|
}
|
|
hp["transaction"] = ts
|
|
|
|
tls := []map[string]interface{}{}
|
|
rawtl := hd.TotalLimits
|
|
if rawtl != nil {
|
|
tl := map[string]interface{}{
|
|
"warning": rawtl.Warning,
|
|
"critical": rawtl.Critical,
|
|
"fail": rawtl.Fail,
|
|
}
|
|
tls = append(tls, tl)
|
|
}
|
|
hp["total_limits"] = tls
|
|
|
|
err = d.Set("http_probe", []map[string]interface{}{hp})
|
|
if err != nil {
|
|
return fmt.Errorf("http_probe set failed: %v, from %#v", err, hp)
|
|
}
|
|
return nil
|
|
}
|