vendor/github.com/DreamItGetIT/statuscake/cmd/statuscake/main.go

   1 package main
   2
   3 import (
   4         "fmt"
   5         logpkg "log"
   6         "os"
   7         "strconv"
   8
   9         "github.com/DreamItGetIT/statuscake"
  10 )
  11
  12 var log *logpkg.Logger
  13
  14 type command func(*statuscake.Client, ...string) error
  15
  16 var commands map[string]command
  17
  18 func init() {
  19         log = logpkg.New(os.Stderr, "", 0)
  20         commands = map[string]command{
  21                 "list":   cmdList,
  22                 "detail": cmdDetail,
  23                 "delete": cmdDelete,
  24                 "create": cmdCreate,
  25                 "update": cmdUpdate,
  26         }
  27 }
  28
  29 func colouredStatus(s string) string {
  30         switch s {
  31         case "Up":
  32                 return fmt.Sprintf("\033[0;32m%s\033[0m", s)
  33         case "Down":
  34                 return fmt.Sprintf("\033[0;31m%s\033[0m", s)
  35         default:
  36                 return s
  37         }
  38 }
  39
  40 func getEnv(name string) string {
  41         v := os.Getenv(name)
  42         if v == "" {
  43                 log.Fatalf("`%s` env variable is required", name)
  44         }
  45
  46         return v
  47 }
  48
  49 func cmdList(c *statuscake.Client, args ...string) error {
  50         tt := c.Tests()
  51         tests, err := tt.All()
  52         if err != nil {
  53                 return err
  54         }
  55
  56         for _, t := range tests {
  57                 var paused string
  58                 if t.Paused {
  59                         paused = "yes"
  60                 } else {
  61                         paused = "no"
  62                 }
  63
  64                 fmt.Printf("* %d: %s\n", t.TestID, colouredStatus(t.Status))
  65                 fmt.Printf("  WebsiteName: %s\n", t.WebsiteName)
  66                 fmt.Printf("  TestType: %s\n", t.TestType)
  67                 fmt.Printf("  Paused: %s\n", paused)
  68                 fmt.Printf("  ContactID: %d\n", t.ContactID)
  69                 fmt.Printf("  Uptime: %f\n", t.Uptime)
  70         }
  71
  72         return nil
  73 }
  74
  75 func cmdDetail(c *statuscake.Client, args ...string) error {
  76         if len(args) != 1 {
  77                 return fmt.Errorf("command `detail` requires a single argument `TestID`")
  78         }
  79
  80         id, err := strconv.Atoi(args[0])
  81         if err != nil {
  82                 return err
  83         }
  84
  85         tt := c.Tests()
  86         t, err := tt.Detail(id)
  87         if err != nil {
  88                 return err
  89         }
  90
  91         var paused string
  92         if t.Paused {
  93                 paused = "yes"
  94         } else {
  95                 paused = "no"
  96         }
  97
  98         fmt.Printf("* %d: %s\n", t.TestID, colouredStatus(t.Status))
  99         fmt.Printf("  WebsiteName: %s\n", t.WebsiteName)
 100         fmt.Printf("  WebsiteURL: %s\n", t.WebsiteURL)
 101         fmt.Printf("  PingURL: %s\n", t.PingURL)
 102         fmt.Printf("  TestType: %s\n", t.TestType)
 103         fmt.Printf("  Paused: %s\n", paused)
 104         fmt.Printf("  ContactID: %d\n", t.ContactID)
 105         fmt.Printf("  Uptime: %f\n", t.Uptime)
 106
 107         return nil
 108 }
 109
 110 func cmdDelete(c *statuscake.Client, args ...string) error {
 111         if len(args) != 1 {
 112                 return fmt.Errorf("command `delete` requires a single argument `TestID`")
 113         }
 114
 115         id, err := strconv.Atoi(args[0])
 116         if err != nil {
 117                 return err
 118         }
 119
 120         return c.Tests().Delete(id)
 121 }
 122
 123 func askString(name string) string {
 124         var v string
 125
 126         fmt.Printf("%s: ", name)
 127         _, err := fmt.Scanln(&v)
 128         if err != nil {
 129                 log.Fatal(err)
 130         }
 131
 132         return v
 133 }
 134
 135 func askInt(name string) int {
 136         v := askString(name)
 137         i, err := strconv.Atoi(v)
 138         if err != nil {
 139                 log.Fatalf("Invalid number `%s`", v)
 140         }
 141
 142         return i
 143 }
 144
 145 func cmdCreate(c *statuscake.Client, args ...string) error {
 146         t := &statuscake.Test{
 147                 WebsiteName: askString("WebsiteName"),
 148                 WebsiteURL:  askString("WebsiteURL"),
 149                 TestType:    askString("TestType"),
 150                 CheckRate:   askInt("CheckRate"),
 151         }
 152
 153         t2, err := c.Tests().Update(t)
 154         if err != nil {
 155                 return err
 156         }
 157
 158         fmt.Printf("CREATED: \n%+v\n", t2)
 159
 160         return nil
 161 }
 162
 163 func cmdUpdate(c *statuscake.Client, args ...string) error {
 164         if len(args) != 1 {
 165                 return fmt.Errorf("command `update` requires a single argument `TestID`")
 166         }
 167
 168         id, err := strconv.Atoi(args[0])
 169         if err != nil {
 170                 return err
 171         }
 172
 173         tt := c.Tests()
 174         t, err := tt.Detail(id)
 175         if err != nil {
 176                 return err
 177         }
 178
 179         t.TestID = id
 180         t.WebsiteName = askString(fmt.Sprintf("WebsiteName [%s]", t.WebsiteName))
 181         t.WebsiteURL = askString(fmt.Sprintf("WebsiteURL [%s]", t.WebsiteURL))
 182         t.TestType = askString(fmt.Sprintf("TestType [%s]", t.TestType))
 183         t.CheckRate = askInt(fmt.Sprintf("CheckRate [%d]", t.CheckRate))
 184
 185         t2, err := c.Tests().Update(t)
 186         if err != nil {
 187                 return err
 188         }
 189
 190         fmt.Printf("UPDATED: \n%+v\n", t2)
 191
 192         return nil
 193 }
 194
 195 func usage() {
 196         fmt.Printf("Usage:\n")
 197         fmt.Printf("  %s COMMAND\n", os.Args[0])
 198         fmt.Printf("Available commands:\n")
 199         for k := range commands {
 200                 fmt.Printf("  %+v\n", k)
 201         }
 202 }
 203
 204 func main() {
 205         username := getEnv("STATUSCAKE_USERNAME")
 206         apikey := getEnv("STATUSCAKE_APIKEY")
 207
 208         if len(os.Args) < 2 {
 209                 usage()
 210                 os.Exit(1)
 211         }
 212
 213         var err error
 214
 215         c, err := statuscake.New(statuscake.Auth{Username: username, Apikey: apikey})
 216         if err != nil {
 217                 log.Fatal(err)
 218         }
 219
 220         if cmd, ok := commands[os.Args[1]]; ok {
 221                 err = cmd(c, os.Args[2:]...)
 222         } else {
 223                 err = fmt.Errorf("Unknown command `%s`", os.Args[1])
 224         }
 225
 226         if err != nil {
 227                 log.Fatalf("Error running command `%s`: %s", os.Args[1], err.Error())
 228         }
 229 }