resource_statuscaketest.go

   1 package statuscake
   2
   3 import (
   4         "fmt"
   5         "strconv"
   6
   7         "log"
   8
   9         "github.com/DreamItGetIT/statuscake"
  10         "github.com/hashicorp/terraform/helper/schema"
  11 )
  12
  13 func resourceStatusCakeTest() *schema.Resource {
  14         return &schema.Resource{
  15                 Create: CreateTest,
  16                 Update: UpdateTest,
  17                 Delete: DeleteTest,
  18                 Read:   ReadTest,
  19
  20                 Schema: map[string]*schema.Schema{
  21                         "test_id": &schema.Schema{
  22                                 Type:     schema.TypeString,
  23                                 Computed: true,
  24                         },
  25
  26                         "website_name": &schema.Schema{
  27                                 Type:     schema.TypeString,
  28                                 Required: true,
  29                         },
  30
  31                         "website_url": &schema.Schema{
  32                                 Type:     schema.TypeString,
  33                                 Required: true,
  34                         },
  35
  36                         "contact_id": &schema.Schema{
  37                                 Type:     schema.TypeInt,
  38                                 Optional: true,
  39                         },
  40
  41                         "check_rate": &schema.Schema{
  42                                 Type:     schema.TypeInt,
  43                                 Optional: true,
  44                                 Default:  300,
  45                         },
  46
  47                         "test_type": &schema.Schema{
  48                                 Type:     schema.TypeString,
  49                                 Required: true,
  50                         },
  51
  52                         "paused": &schema.Schema{
  53                                 Type:     schema.TypeBool,
  54                                 Optional: true,
  55                                 Default:  false,
  56                         },
  57
  58                         "timeout": &schema.Schema{
  59                                 Type:     schema.TypeInt,
  60                                 Optional: true,
  61                                 Default:  40,
  62                         },
  63
  64                         "confirmations": &schema.Schema{
  65                                 Type:     schema.TypeInt,
  66                                 Optional: true,
  67                         },
  68                 },
  69         }
  70 }
  71
  72 func CreateTest(d *schema.ResourceData, meta interface{}) error {
  73         client := meta.(*statuscake.Client)
  74
  75         newTest := &statuscake.Test{
  76                 WebsiteName:  d.Get("website_name").(string),
  77                 WebsiteURL:   d.Get("website_url").(string),
  78                 CheckRate:    d.Get("check_rate").(int),
  79                 TestType:     d.Get("test_type").(string),
  80                 Paused:       d.Get("paused").(bool),
  81                 Timeout:      d.Get("timeout").(int),
  82                 ContactID:    d.Get("contact_id").(int),
  83                 Confirmation: d.Get("confirmations").(int),
  84         }
  85
  86         log.Printf("[DEBUG] Creating new StatusCake Test: %s", d.Get("website_name").(string))
  87
  88         response, err := client.Tests().Update(newTest)
  89         if err != nil {
  90                 return fmt.Errorf("Error creating StatusCake Test: %s", err.Error())
  91         }
  92
  93         d.Set("test_id", fmt.Sprintf("%d", response.TestID))
  94         d.SetId(fmt.Sprintf("%d", response.TestID))
  95
  96         return ReadTest(d, meta)
  97 }
  98
  99 func UpdateTest(d *schema.ResourceData, meta interface{}) error {
 100         client := meta.(*statuscake.Client)
 101
 102         params := getStatusCakeTestInput(d)
 103
 104         log.Printf("[DEBUG] StatusCake Test Update for %s", d.Id())
 105         _, err := client.Tests().Update(params)
 106         if err != nil {
 107                 return fmt.Errorf("Error Updating StatusCake Test: %s", err.Error())
 108         }
 109         return nil
 110 }
 111
 112 func DeleteTest(d *schema.ResourceData, meta interface{}) error {
 113         client := meta.(*statuscake.Client)
 114
 115         testId, parseErr := strconv.Atoi(d.Id())
 116         if parseErr != nil {
 117                 return parseErr
 118         }
 119         log.Printf("[DEBUG] Deleting StatusCake Test: %s", d.Id())
 120         err := client.Tests().Delete(testId)
 121         if err != nil {
 122                 return err
 123         }
 124
 125         return nil
 126 }
 127
 128 func ReadTest(d *schema.ResourceData, meta interface{}) error {
 129         client := meta.(*statuscake.Client)
 130
 131         testId, parseErr := strconv.Atoi(d.Id())
 132         if parseErr != nil {
 133                 return parseErr
 134         }
 135         testResp, err := client.Tests().Detail(testId)
 136         if err != nil {
 137                 return fmt.Errorf("Error Getting StatusCake Test Details for %s: Error: %s", d.Id(), err)
 138         }
 139         d.Set("website_name", testResp.WebsiteName)
 140         d.Set("website_url", testResp.WebsiteURL)
 141         d.Set("check_rate", testResp.CheckRate)
 142         d.Set("test_type", testResp.TestType)
 143         d.Set("paused", testResp.Paused)
 144         d.Set("timeout", testResp.Timeout)
 145         d.Set("contact_id", testResp.ContactID)
 146         d.Set("confirmations", testResp.Confirmation)
 147
 148         return nil
 149 }
 150
 151 func getStatusCakeTestInput(d *schema.ResourceData) *statuscake.Test {
 152         testId, parseErr := strconv.Atoi(d.Id())
 153         if parseErr != nil {
 154                 log.Printf("[DEBUG] Error Parsing StatusCake TestID: %s", d.Id())
 155         }
 156         test := &statuscake.Test{
 157                 TestID: testId,
 158         }
 159         if v, ok := d.GetOk("website_name"); ok {
 160                 test.WebsiteName = v.(string)
 161         }
 162         if v, ok := d.GetOk("website_url"); ok {
 163                 test.WebsiteURL = v.(string)
 164         }
 165         if v, ok := d.GetOk("check_rate"); ok {
 166                 test.CheckRate = v.(int)
 167         }
 168         if v, ok := d.GetOk("contact_id"); ok {
 169                 test.ContactID = v.(int)
 170         }
 171         if v, ok := d.GetOk("test_type"); ok {
 172                 test.TestType = v.(string)
 173         }
 174         if v, ok := d.GetOk("paused"); ok {
 175                 test.Paused = v.(bool)
 176         }
 177         if v, ok := d.GetOk("timeout"); ok {
 178                 test.Timeout = v.(int)
 179         }
 180         if v, ok := d.GetOk("contact_id"); ok {
 181                 test.ContactID = v.(int)
 182         }
 183         if v, ok := d.GetOk("confirmations"); ok {
 184                 test.Confirmation = v.(int)
 185         }
 186         return test
 187 }