fix cachet api returning bad response code

- extendable backends
- better project structure
- better cli interface

.gitignore

@@ -1,6 +1,5 @@
 /config.yml
 /config.json
 examples/
-/cachet-monitor
+vendor/
-/cli
+cachet-monitor
-build

api.go

@@ -1,85 +0,0 @@
-package cachet
-
-import (
-	"bytes"
-	"crypto/tls"
-	"encoding/json"
-	"errors"
-	"net/http"
-	"strconv"
-	"time"
-
-	"github.com/sirupsen/logrus"
-)
-
-type CachetAPI struct {
-	URL      string `json:"url"`
-	Token    string `json:"token"`
-	Insecure bool   `json:"insecure"`
-}
-
-type CachetResponse struct {
-	Data json.RawMessage `json:"data"`
-}
-
-// TODO: test
-func (api CachetAPI) Ping() error {
-	resp, _, err := api.NewRequest("GET", "/ping", nil)
-	if err != nil {
-		return err
-	}
-
-	if resp.StatusCode != 200 {
-		return errors.New("API Responded with non-200 status code")
-	}
-
-	defer resp.Body.Close()
-
-	return nil
-}
-
-// SendMetric adds a data point to a cachet monitor
-func (api CachetAPI) SendMetric(id int, lag int64) {
-	logrus.Debugf("Sending lag metric ID:%d RTT %vms", id, lag)
-
-	jsonBytes, _ := json.Marshal(map[string]interface{}{
-		"value":     lag,
-		"timestamp": time.Now().Unix(),
-	})
-
-	resp, _, err := api.NewRequest("POST", "/metrics/"+strconv.Itoa(id)+"/points", jsonBytes)
-	if err != nil || resp.StatusCode != 200 {
-		logrus.Warnf("Could not log metric! ID: %d, err: %v", id, err)
-	}
-
-	defer resp.Body.Close()
-}
-
-// TODO: test
-// NewRequest wraps http.NewRequest
-func (api CachetAPI) NewRequest(requestType, url string, reqBody []byte) (*http.Response, CachetResponse, error) {
-	req, err := http.NewRequest(requestType, api.URL+url, bytes.NewBuffer(reqBody))
-
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("X-Cachet-Token", api.Token)
-
-	transport := http.DefaultTransport.(*http.Transport)
-	transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: api.Insecure}
-	client := &http.Client{
-		Transport: transport,
-	}
-
-	res, err := client.Do(req)
-	if err != nil {
-		return nil, CachetResponse{}, err
-	}
-
-	var body struct {
-		Data json.RawMessage `json:"data"`
-	}
-	err = json.NewDecoder(res.Body).Decode(&body)
-
-	defer req.Body.Close()
-
-	return res, body, err
-}

backends/cachet/backend.go

@@ -0,0 +1,304 @@
+package cachetbackend
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/castawaylabs/cachet-monitor/monitors"
+	"github.com/sirupsen/logrus"
+)
+
+const DefaultTimeFormat = "15:04:05 Jan 2 MST"
+
+type CachetBackend struct {
+	URL        string `json:"url" yaml:"url"`
+	Token      string `json:"token" yaml:"token"`
+	Insecure   bool   `json:"insecure" yaml:"insecure"`
+	DateFormat string `json:"date_format" yaml:"date_format"`
+}
+
+type CachetResponse struct {
+	Data json.RawMessage `json:"data"`
+}
+
+func (api CachetBackend) ValidateMonitor(mon *monitors.AbstractMonitor) []string {
+	errs := []string{}
+
+	params := mon.Params
+
+	componentID, componentIDOk := params["component_id"]
+	metricID, metricIDOk := params["metric_id"]
+	if !componentIDOk && !metricIDOk {
+		errs = append(errs, "component_id and metric_id is unset")
+	}
+
+	if _, ok := componentID.(int); !ok && componentIDOk {
+		errs = append(errs, "component_id not integer")
+	}
+	if _, ok := metricID.(int); !ok && metricIDOk {
+		errs = append(errs, "metric_id not integer")
+	}
+
+	return errs
+}
+
+func (api CachetBackend) Validate() []string {
+	errs := []string{}
+
+	if len(api.URL) == 0 {
+		errs = append(errs, "Cachet API URL invalid")
+	}
+	if len(api.Token) == 0 {
+		errs = append(errs, "Cachet API Token invalid")
+	}
+
+	if len(api.DateFormat) == 0 {
+		api.DateFormat = DefaultTimeFormat
+	}
+
+	return errs
+}
+
+// TODO: test
+func (api CachetBackend) Ping() error {
+	resp, _, err := api.NewRequest("GET", "/ping", nil)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != 200 {
+		return errors.New("API Responded with non-200 status code")
+	}
+
+	defer resp.Body.Close()
+
+	return nil
+}
+
+// TODO: test
+// NewRequest wraps http.NewRequest
+func (api CachetBackend) NewRequest(requestType, url string, reqBody []byte) (*http.Response, interface{}, error) {
+	req, err := http.NewRequest(requestType, api.URL+url, bytes.NewBuffer(reqBody))
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Cachet-Token", api.Token)
+
+	transport := http.DefaultTransport.(*http.Transport)
+	transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: api.Insecure}
+	client := &http.Client{
+		Transport: transport,
+	}
+
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, CachetResponse{}, err
+	}
+	defer res.Body.Close()
+	defer req.Body.Close()
+
+	var body CachetResponse
+	err = json.NewDecoder(res.Body).Decode(&body)
+
+	return res, body, err
+}
+
+func (mon CachetBackend) Describe() []string {
+	features := []string{"Cachet API"}
+
+	return features
+}
+
+func (api CachetBackend) SendMetric(monitor monitors.MonitorInterface, lag int64) error {
+	mon := monitor.GetMonitor()
+	if _, ok := mon.Params["metric_id"]; !ok {
+		return nil
+	}
+
+	metricID := mon.Params["metric_id"].(int)
+
+	// report lag
+	logrus.Debugf("Sending lag metric ID: %d RTT %vms", metricID, lag)
+
+	jsonBytes, _ := json.Marshal(map[string]interface{}{
+		"value":     lag,
+		"timestamp": time.Now().Unix(),
+	})
+
+	resp, _, err := api.NewRequest("POST", "/metrics/"+strconv.Itoa(metricID)+"/points", jsonBytes)
+	if err != nil || resp.StatusCode != 200 {
+		logrus.Warnf("Could not log metric! ID: %d, err: %v", metricID, err)
+	}
+
+	if resp != nil && resp.Body != nil {
+		defer resp.Body.Close()
+	}
+
+	return nil
+}
+
+func (api CachetBackend) UpdateMonitor(mon monitors.MonitorInterface, status, previousStatus monitors.MonitorStatus, errs []error) error {
+	monitor := mon.GetMonitor()
+	l := logrus.WithFields(logrus.Fields{
+		"monitor": monitor.Name,
+		"time":    time.Now().Format(api.DateFormat),
+	})
+
+	errors := make([]string, len(errs))
+	for i, err := range errs {
+		errors[i] = err.Error()
+	}
+
+	fmt.Println("errs", errs)
+
+	componentID := monitor.Params["component_id"].(int)
+	incident, err := api.findIncident(componentID)
+	if err != nil {
+		l.Errorf("Couldn't find existing incidents: %v", err)
+	}
+
+	if incident == nil {
+		// create a new one
+		incident = &Incident{
+			Name:        "",
+			ComponentID: componentID,
+			Message:     "",
+			Notify:      true,
+		}
+	} else {
+		// find component status
+		component, err := api.getComponent(incident.ComponentID)
+		if err != nil {
+			panic(err)
+		}
+
+		incident.ComponentStatus = component.Status
+	}
+
+	tpls := monitor.Template
+	tplData := api.getTemplateData(monitor)
+	var tpl monitors.MessageTemplate
+
+	if status == monitors.MonitorStatusDown {
+		tpl = tpls.Investigating
+		tplData["FailReason"] = strings.Join(errors, "\n - ")
+		l.Warnf("updating component. Monitor is down: %v", tplData["FailReason"])
+	} else {
+		// was down, created an incident, its now ok, make it resolved.
+		tpl = tpls.Fixed
+		l.Warn("Resolving incident")
+	}
+
+	tplData["incident"] = incident
+	subject, message := tpl.Exec(tplData)
+
+	if incident.ID == 0 {
+		incident.Name = subject
+		incident.Message = message
+	} else {
+		incident.Message += "\n\n---\n\n" + subject + ":\n\n" + message
+	}
+
+	if status == monitors.MonitorStatusDown && (incident.ComponentStatus == 0 || incident.ComponentStatus > 2) {
+		incident.Status = 1
+		fmt.Println("incident status", incident.ComponentStatus)
+		if incident.ComponentStatus >= 3 {
+			// major outage
+			incident.ComponentStatus = 4
+		} else {
+			incident.ComponentStatus = 3
+		}
+	} else if status == monitors.MonitorStatusUp {
+		incident.Status = 4
+		incident.ComponentStatus = 1
+	}
+	incident.Notify = true
+
+	// create/update incident
+	if err := incident.Send(api); err != nil {
+		l.Errorf("Error sending incident: %v", err)
+		return err
+	}
+
+	return nil
+}
+
+func (api CachetBackend) Tick(monitor monitors.MonitorInterface, status monitors.MonitorStatus, errs []error, lag int64) {
+	mon := monitor.GetMonitor()
+	if mon.GetLastStatus() == status || status == monitors.MonitorStatusNotSaturated {
+		return
+	}
+
+	logrus.Infof("updating backend for monitor")
+	lastStatus := mon.UpdateLastStatus(status)
+
+	api.UpdateMonitor(monitor, status, lastStatus, errs)
+
+	if _, ok := mon.Params["metric_id"]; ok && lag > 0 {
+		api.SendMetric(monitor, lag)
+	}
+}
+
+func (api CachetBackend) getComponent(componentID int) (*Component, error) {
+	resp, body, err := api.NewRequest("GET", "/components/"+strconv.Itoa(componentID), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var data *Component
+	if err := json.Unmarshal(body.(CachetResponse).Data, &data); err != nil {
+		return nil, fmt.Errorf("Cannot decode component: %v", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("Could not get component! %v", err)
+	}
+
+	return data, nil
+}
+
+func (api CachetBackend) findIncident(componentID int) (*Incident, error) {
+	// fetch watching, identified & investigating
+	statuses := []int{3, 2, 1}
+	for _, status := range statuses {
+		incidents, err := api.findIncidents(componentID, status)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, incident := range incidents {
+			incident.Status = status
+			return incident, nil
+		}
+	}
+
+	return nil, nil
+}
+
+func (api CachetBackend) findIncidents(componentID int, status int) ([]*Incident, error) {
+	resp, body, err := api.NewRequest("GET", "/incidents?component_Id="+strconv.Itoa(componentID)+"&status="+strconv.Itoa(status), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("GET /incidents returned %d", resp.StatusCode)
+	}
+
+	var data []*Incident
+	if err := json.Unmarshal(body.(CachetResponse).Data, &data); err != nil {
+		return nil, fmt.Errorf("Cannot find incidents: %v", err)
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("Could not fetch incidents! %v", err)
+	}
+
+	return data, nil
+}

backends/cachet/component.go

@@ -0,0 +1,14 @@
+package cachetbackend
+
+// Incident Cachet data model
+type Component struct {
+	ID      int    `json:"id"`
+	Name    string `json:"name"`
+	Message string `json:"message"`
+	Status  int    `json:"status"`
+	Visible int    `json:"visible"`
+	Notify  bool   `json:"notify"`
+
+	ComponentID     int `json:"component_id"`
+	ComponentStatus int `json:"component_status"`
+}

backends/cachet/incident.go

@@ -0,0 +1,67 @@
+package cachetbackend
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/castawaylabs/cachet-monitor/backends"
+	"github.com/castawaylabs/cachet-monitor/monitors"
+)
+
+// "github.com/sirupsen/logrus"
+
+// Incident Cachet data model
+type Incident struct {
+	ID      int    `json:"id"`
+	Name    string `json:"name"`
+	Message string `json:"message"`
+	Status  int    `json:"status"`
+	Visible int    `json:"visible"`
+	Notify  bool   `json:"notify"`
+
+	ComponentID     int `json:"component_id"`
+	ComponentStatus int `json:"component_status"`
+}
+
+// Send - Create or Update incident
+func (incident *Incident) Send(backend backends.BackendInterface) error {
+	requestURL := "/incidents"
+	requestMethod := "POST"
+	jsonBytes, _ := json.Marshal(incident)
+
+	if incident.ID > 0 {
+		// create an incident update
+		requestMethod = "PUT"
+		requestURL += "/" + strconv.Itoa(incident.ID)
+	}
+
+	resp, body, err := backend.NewRequest(requestMethod, requestURL, jsonBytes)
+	if err != nil {
+		return err
+	}
+
+	var data struct {
+		ID int `json:"id"`
+	}
+	if err := json.Unmarshal(body.(CachetResponse).Data, &data); err != nil {
+		return fmt.Errorf("Cannot parse incident body: %v, %v", err, string(body.(CachetResponse).Data))
+	}
+
+	incident.ID = data.ID
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("Could not update/create incident!")
+	}
+
+	return nil
+}
+
+func (api *CachetBackend) getTemplateData(monitor *monitors.AbstractMonitor) map[string]interface{} {
+	return map[string]interface{}{
+		// "SystemName": monitor.config.SystemName,
+		"Monitor": monitor,
+		"now":     time.Now().Format(api.DateFormat),
+		// "incident":   monitor.incident,
+	}
+}

backends/interface.go

@@ -0,0 +1,19 @@
+package backends
+
+import (
+	"net/http"
+
+	"github.com/castawaylabs/cachet-monitor/monitors"
+)
+
+type BackendInterface interface {
+	Ping() error
+	Tick(monitor monitors.MonitorInterface, status monitors.MonitorStatus, errs []error, lag int64)
+	SendMetric(monitor monitors.MonitorInterface, lag int64) error
+	UpdateMonitor(monitor monitors.MonitorInterface, status, previousStatus monitors.MonitorStatus, errs []error) error
+	NewRequest(requestType, url string, reqBody []byte) (*http.Response, interface{}, error)
+
+	Describe() []string
+	Validate() []string
+	ValidateMonitor(monitor *monitors.AbstractMonitor) []string
+}

cli/Dockerfile

@@ -1,12 +0,0 @@
-# build stage
-FROM golang:alpine AS build-env
-RUN set -eux; \
-    apk add --no-cache --virtual .build-deps \
-    git gcc libc-dev;
-ENV GO111MODULE on
-WORKDIR /go/main
-ADD go.mod go.sum ./
-RUN go mod download
-# WORKDIR /go/src/status-monitor
-ADD main.go ./
-RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -a -installsuffix cgo -o main main.go

cli/Makefile

@@ -1,3 +0,0 @@
-build:
-	docker build .
-

cli/go.mod

@@ -1,12 +0,0 @@
-module main
-
-go 1.13
-
-require (
-	github.com/castawaylabs/cachet-monitor v1.1.0 // indirect
-	github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815
-	github.com/milkinteractive/cachet-monitor v1.1.0
-	github.com/mitchellh/mapstructure v1.1.2
-	github.com/sirupsen/logrus v1.4.2
-	gopkg.in/yaml.v2 v2.2.7
-)

cli/go.sum

@@ -1,20 +0,0 @@
-github.com/castawaylabs/cachet-monitor v1.1.0 h1:T8NshhwHjEIbdlWkeRBuYdnU2ktpBnZpwgh6nxrp62w=
-github.com/castawaylabs/cachet-monitor v1.1.0/go.mod h1:FBK1+4+fLd80wd/+U4Zy8YshPlpgWEvup79AoapOZ2E=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815 h1:bWDMxwH3px2JBh6AyO7hdCn/PkvCZXii8TGj7sbtEbQ=
-github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/milkinteractive/cachet-monitor v1.1.0 h1:IyX/gYVDfSEwO4kbNMs9W4hLt5FXIV/ig/4c1nFVlfU=
-github.com/milkinteractive/cachet-monitor v1.1.0/go.mod h1:Y+g0f0C8fAj2ub5RhfQgh/oU85pYx6QbL/56WMFkmVo=
-github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
-github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
-github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894 h1:Cz4ceDQGXuKRnVBDTS23GTn/pU5OE2C0WrNTOYK1Uuc=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.7 h1:VUgggvou5XRW9mHwD/yXxIYSMtY0zoKQf/v226p2nyo=
-gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

cli/main.go

@@ -1,212 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"os"
-	"os/signal"
-	"strings"
-	"sync"
-
-	docopt "github.com/docopt/docopt-go"
-	cachet "github.com/milkinteractive/cachet-monitor"
-	"github.com/mitchellh/mapstructure"
-	"github.com/sirupsen/logrus"
-	"gopkg.in/yaml.v2"
-)
-
-const usage = `cachet-monitor
-
-Usage:
-  cachet-monitor (-c PATH | --config PATH) [--log=LOGPATH] [--name=NAME] [--immediate] [--restarted]
-  cachet-monitor -h | --help | --version
-
-Arguments:
-  PATH     path to config.json
-  LOGPATH  path to log output (defaults to STDOUT)
-  NAME     name of this logger
-
-Examples:
-  cachet-monitor -c /root/cachet-monitor.json
-  cachet-monitor -c /root/cachet-monitor.json --log=/var/log/cachet-monitor.log --name="development machine"
-
-Options:
-  -c PATH.json --config PATH     Path to configuration file
-  -h --help                      Show this screen.
-  --version                      Show version
-  --immediate                    Tick immediately (by default waits for first defined interval)
-  --restarted                    Get open incidents before start monitoring (if monitor died or restarted)
-  
-Environment varaibles:
-  CACHET_API      override API url from configuration
-  CACHET_TOKEN    override API token from configuration
-  CACHET_DEV      set to enable dev logging`
-
-var version string
-
-func main() {
-	arguments, _ := docopt.Parse(usage, nil, true, version, false)
-
-	cfg, err := getConfiguration(arguments["--config"].(string))
-	if err != nil {
-		logrus.Panicf("Unable to start (reading config): %v", err)
-	}
-
-	if immediate, ok := arguments["--immediate"]; ok {
-		cfg.Immediate = immediate.(bool)
-	}
-
-	if restarted, ok := arguments["--restarted"]; ok {
-		cfg.Restarted = restarted.(bool)
-	}
-
-	if name := arguments["--name"]; name != nil {
-		cfg.SystemName = name.(string)
-	}
-	logrus.SetOutput(getLogger(arguments["--log"]))
-
-	if len(os.Getenv("CACHET_API")) > 0 {
-		cfg.API.URL = os.Getenv("CACHET_API")
-	}
-	if len(os.Getenv("CACHET_TOKEN")) > 0 {
-		cfg.API.Token = os.Getenv("CACHET_TOKEN")
-	}
-	if len(os.Getenv("CACHET_DEV")) > 0 {
-		logrus.SetLevel(logrus.DebugLevel)
-	}
-
-	if valid := cfg.Validate(); !valid {
-		logrus.Errorf("Invalid configuration")
-		os.Exit(1)
-	}
-
-	logrus.Debug("Configuration valid")
-	logrus.Infof("System: %s", cfg.SystemName)
-	logrus.Infof("API: %s", cfg.API.URL)
-	logrus.Infof("Monitors: %d\n", len(cfg.Monitors))
-
-	logrus.Infof("Pinging cachet")
-	if err := cfg.API.Ping(); err != nil {
-		logrus.Errorf("Cannot ping cachet!\n%v", err)
-		os.Exit(1)
-	}
-	logrus.Infof("Ping OK")
-
-	wg := &sync.WaitGroup{}
-	for index, monitor := range cfg.Monitors {
-		logrus.Infof("Starting Monitor #%d: ", index)
-		logrus.Infof("Features: \n - %v", strings.Join(monitor.Describe(), "\n - "))
-
-		go monitor.ClockStart(cfg, monitor, wg)
-	}
-
-	signals := make(chan os.Signal, 1)
-	signal.Notify(signals, os.Interrupt, os.Kill)
-	<-signals
-
-	logrus.Warnf("Abort: Waiting monitors to finish")
-	for _, mon := range cfg.Monitors {
-		mon.GetMonitor().ClockStop()
-	}
-
-	wg.Wait()
-}
-
-func getLogger(logPath interface{}) *os.File {
-	if logPath == nil || len(logPath.(string)) == 0 {
-		return os.Stdout
-	}
-
-	file, err := os.Create(logPath.(string))
-	if err != nil {
-		logrus.Errorf("Unable to open file '%v' for logging: \n%v", logPath, err)
-		os.Exit(1)
-	}
-
-	return file
-}
-
-func getConfiguration(path string) (*cachet.CachetMonitor, error) {
-	var cfg cachet.CachetMonitor
-	var data []byte
-
-	// test if its a url
-	url, err := url.ParseRequestURI(path)
-	if err == nil && len(url.Scheme) > 0 {
-		// download config
-		response, err := http.Get(path)
-		if err != nil {
-			logrus.Warn("Unable to download network configuration")
-			return nil, err
-		}
-
-		defer response.Body.Close()
-		data, _ = ioutil.ReadAll(response.Body)
-
-		logrus.Info("Downloaded network configuration.")
-	} else {
-		data, err = ioutil.ReadFile(path)
-		if err != nil {
-			return nil, errors.New("Unable to open file: '" + path + "'")
-		}
-	}
-
-	if strings.HasSuffix(path, ".yaml") || strings.HasSuffix(path, ".yml") {
-		err = yaml.Unmarshal(data, &cfg)
-	} else {
-		err = json.Unmarshal(data, &cfg)
-	}
-
-	if err != nil {
-		logrus.Warnf("Unable to parse configuration file")
-	}
-
-	cfg.Monitors = make([]cachet.MonitorInterface, len(cfg.RawMonitors))
-	for index, rawMonitor := range cfg.RawMonitors {
-		var t cachet.MonitorInterface
-		var err error
-
-		// get default type
-		monType := cachet.GetMonitorType("")
-		if t, ok := rawMonitor["type"].(string); ok {
-			monType = cachet.GetMonitorType(t)
-		}
-
-		switch monType {
-			case "http":
-				var s cachet.HTTPMonitor
-				err = mapstructure.Decode(rawMonitor, &s)
-				t = &s
-			case "dns":
-				var s cachet.DNSMonitor
-				err = mapstructure.Decode(rawMonitor, &s)
-				t = &s
-			case "tcp":
-				var s cachet.TCPMonitor
-				err = mapstructure.Decode(rawMonitor, &s)
-				t = &s
-			
-			case "icmp":
-				var s cachet.ICMPMonitor
-				err = mapstructure.Decode(rawMonitor, &s)
-				t = &s
-			default:
-				logrus.Errorf("Invalid monitor type (index: %d) %v", index, monType)
-				continue
-		}
-
-		t.GetMonitor().Type = monType
-
-		if err != nil {
-			logrus.Errorf("Unable to unmarshal monitor to type (index: %d): %v", index, err)
-			continue
-		}
-
-		cfg.Monitors[index] = t
-		}
-
-	return &cfg, err
-}

cli/root.go

@@ -0,0 +1,115 @@
+package main
+
+import (
+	"os"
+	"os/signal"
+	"strings"
+	"sync"
+
+	cachet "github.com/castawaylabs/cachet-monitor"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+var cfgFile string
+
+// rootCmd represents the base command when called without any subcommands
+var rootCmd = &cobra.Command{
+	Use:   "cmd",
+	Short: "cachet-monitor",
+	// Uncomment the following line if your bare application
+	// has an action associated with it:
+	Run: func(cmd *cobra.Command, args []string) {
+		Action(cmd, args)
+	},
+}
+
+func main() {
+	if err := rootCmd.Execute(); err != nil {
+		panic(err)
+	}
+}
+
+func init() {
+	// Here you will define your flags and configuration settings.
+	// Cobra supports persistent flags, which, if defined here,
+	// will be global for your application.
+	pf := rootCmd.PersistentFlags()
+	pf.StringVarP(&cfgFile, "config", "c", "", "config file (default is $(pwd)/config.yml)")
+	pf.String("log", "", "log output")
+	pf.String("format", "text", "log format [text/json]")
+	pf.String("name", "", "machine name")
+	pf.Bool("immediate", false, "Tick immediately (by default waits for first defined")
+}
+
+func Action(cmd *cobra.Command, args []string) {
+	cfg, err := cachet.New(cfgFile)
+	if err != nil {
+		logrus.Panicf("Unable to start (reading config): %v", err)
+	}
+
+	if immediate, err := cmd.Flags().GetBool("immediate"); err == nil && immediate {
+		cfg.Immediate = immediate
+	}
+	if name, err := cmd.Flags().GetString("name"); err == nil && len(name) > 0 {
+		cfg.SystemName = name
+	}
+
+	logrus.SetOutput(getLogger(cmd))
+	if format, err := cmd.Flags().GetString("format"); err == nil && format == "json" {
+		logrus.SetFormatter(&logrus.JSONFormatter{})
+	}
+
+	if valid := cfg.Validate(); !valid {
+		logrus.Errorf("Invalid configuration")
+		os.Exit(1)
+	}
+
+	logrus.Debug("Configuration valid")
+	logrus.Infof("System: %s", cfg.SystemName)
+	// logrus.Infof("API: %s", cfg.API.URL)
+	logrus.Infof("Monitors: %d", len(cfg.Monitors))
+	logrus.Infof("Backend: %v", strings.Join(cfg.Backend.Describe(), "\n - "))
+
+	logrus.Infof("Pinging backend")
+	if err := cfg.Backend.Ping(); err != nil {
+		logrus.Errorf("Cannot ping backend!\n%v", err)
+		// os.Exit(1)
+	}
+	logrus.Infof("Ping OK")
+	logrus.Warnf("Starting!")
+
+	wg := &sync.WaitGroup{}
+	for index, monitor := range cfg.Monitors {
+		logrus.Infof("Starting Monitor #%d: ", index)
+		logrus.Infof("Features: \n - %v", strings.Join(monitor.Describe(), "\n - "))
+
+		go monitor.Start(monitor.GetTestFunc(), wg, cfg.Backend.Tick, cfg.Immediate)
+	}
+
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, os.Interrupt, os.Kill)
+	<-signals
+
+	logrus.Warnf("Abort: Waiting for monitors to finish")
+	for _, mon := range cfg.Monitors {
+		mon.GetMonitor().Stop()
+	}
+
+	wg.Wait()
+}
+
+func getLogger(cmd *cobra.Command) *os.File {
+	logPath, _ := cmd.Flags().GetString("log")
+	if len(logPath) == 0 {
+		return os.Stdout
+	}
+
+	file, err := os.Create(logPath)
+	if err != nil {
+		logrus.Errorf("Unable to open file '%v' for logging: \n%v", logPath, err)
+		os.Exit(1)
+	}
+
+	return file
+}

config.go

@@ -1,24 +1,130 @@
 package cachet
 
 import (
+	"encoding/json"
+	"errors"
+	"io/ioutil"
 	"net"
+	"net/http"
+	"net/url"
 	"os"
 	"strings"
-	"time"
 
+	"github.com/castawaylabs/cachet-monitor/backends"
+	cachetbackend "github.com/castawaylabs/cachet-monitor/backends/cachet"
+	"github.com/castawaylabs/cachet-monitor/monitors"
+
+	"github.com/mitchellh/mapstructure"
 	"github.com/sirupsen/logrus"
+	yaml "gopkg.in/yaml.v2"
 )
 
 type CachetMonitor struct {
-	SystemName  string                   `json:"system_name" yaml:"system_name"`
-	DateFormat  string                   `json:"date_format" yaml:"date_format"`
-	SlackWebhook string                  `json:"slack_webhook" yaml:"slack_webhook"`
-	API         CachetAPI                `json:"api"`
 	RawMonitors []map[string]interface{} `json:"monitors" yaml:"monitors"`
+	RawBackend  map[string]interface{}   `json:"backend" yaml:"backend"`
 
-	Monitors  []MonitorInterface `json:"-" yaml:"-"`
+	SystemName string                      `json:"system_name" yaml:"system_name"`
+	Backend    backends.BackendInterface   `json:"-" yaml:"-"`
+	Monitors   []monitors.MonitorInterface `json:"-" yaml:"-"`
 	Immediate  bool                        `json:"-" yaml:"-"`
-	Restarted bool               `json:"-" yaml:"-"`
+}
+
+func New(path string) (*CachetMonitor, error) {
+	var cfg *CachetMonitor
+	var data []byte
+
+	// test if its a url
+	url, err := url.ParseRequestURI(path)
+	if err == nil && len(url.Scheme) > 0 {
+		// download config
+		response, err := http.Get(path)
+		if err != nil {
+			logrus.Warn("Unable to download network configuration")
+			return nil, err
+		}
+
+		defer response.Body.Close()
+		data, _ = ioutil.ReadAll(response.Body)
+
+		logrus.Info("Downloaded network configuration.")
+	} else {
+		data, err = ioutil.ReadFile(path)
+		if err != nil {
+			return nil, errors.New("Unable to open file: '" + path + "'")
+		}
+	}
+
+	if strings.HasSuffix(path, ".yaml") || strings.HasSuffix(path, ".yml") {
+		err = yaml.Unmarshal(data, &cfg)
+	} else {
+		err = json.Unmarshal(data, &cfg)
+	}
+
+	if err != nil {
+		logrus.Warnf("Unable to parse configuration file")
+		return nil, err
+	}
+
+	// get default type
+	if backend, ok := cfg.RawBackend["type"].(string); !ok {
+		err = errors.New("Cannot determine backend type")
+	} else {
+		switch backend {
+		case "cachet":
+			var backend cachetbackend.CachetBackend
+			err = mapstructure.Decode(cfg.RawBackend, &backend)
+			cfg.Backend = &backend
+			// backend.config = cfg
+		default:
+			err = errors.New("Invalid backend type: %v" + backend)
+		}
+	}
+
+	if errs := cfg.Backend.Validate(); len(errs) > 0 {
+		logrus.Errorf("Backend validation errors: %v", errs)
+		os.Exit(1)
+	}
+
+	if err != nil {
+		logrus.Errorf("Unable to unmarshal backend: %v", err)
+		return nil, err
+	}
+
+	cfg.Monitors = make([]monitors.MonitorInterface, len(cfg.RawMonitors))
+	for index, rawMonitor := range cfg.RawMonitors {
+		var t monitors.MonitorInterface
+
+		// get default type
+		monType := GetMonitorType("")
+		if t, ok := rawMonitor["type"].(string); ok {
+			monType = GetMonitorType(t)
+		}
+
+		switch monType {
+		case "http":
+			var mon monitors.HTTPMonitor
+			err = mapstructure.Decode(rawMonitor, &mon)
+			t = &mon
+		case "dns":
+			var mon monitors.DNSMonitor
+			err = mapstructure.Decode(rawMonitor, &mon)
+			t = &mon
+		default:
+			logrus.Errorf("Invalid monitor type (index: %d) %v", index, monType)
+			continue
+		}
+
+		if err != nil {
+			logrus.Errorf("Unable to unmarshal monitor to type (index: %d): %v", index, err)
+			continue
+		}
+
+		mon := t.GetMonitor()
+		mon.Type = monType
+		cfg.Monitors[index] = t
+	}
+
+	return cfg, err
 }
 
 // Validate configuration
@@ -30,22 +136,13 @@ func (cfg *CachetMonitor) Validate() bool {
 		cfg.SystemName = getHostname()
 	}
 
-	if len(cfg.DateFormat) == 0 {
-		cfg.DateFormat = DefaultTimeFormat
-	}
-
-	if len(cfg.API.Token) == 0 || len(cfg.API.URL) == 0 {
-		logrus.Warnf("API URL or API Token missing.\nGet help at https://github.com/castawaylabs/cachet-monitor")
-		valid = false
-	}
-
 	if len(cfg.Monitors) == 0 {
 		logrus.Warnf("No monitors defined!\nSee help for example configuration")
 		valid = false
 	}
 
 	for index, monitor := range cfg.Monitors {
-		if errs := monitor.Validate(); len(errs) > 0 {
+		if errs := monitor.Validate(cfg.Backend.ValidateMonitor); len(errs) > 0 {
 			logrus.Warnf("Monitor validation errors (index %d): %v", index, "\n - "+strings.Join(errs, "\n - "))
 			valid = false
 		}
@@ -69,10 +166,6 @@ func getHostname() string {
 	return addrs[0].String()
 }
 
-func getMs() int64 {
-	return time.Now().UnixNano() / int64(time.Millisecond)
-}
-
 func GetMonitorType(t string) string {
 	if len(t) == 0 {
 		return "http"
@@ -80,18 +173,3 @@ func GetMonitorType(t string) string {
 
 	return strings.ToLower(t)
 }
-
-func getTemplateData(monitor *AbstractMonitor) map[string]interface{} {
-	return map[string]interface{}{
-		"SystemName": monitor.config.SystemName,
-		"API":        monitor.config.API,
-		"Monitor":    monitor,
-		"now":        time.Now().Format(monitor.config.DateFormat),
-	}
-}
-
-func MainUrl(cfg *CachetMonitor) string {
-	var url = cfg.API.URL
-	var index = strings.Index(url,"/api/")
-	return url[0:index]
-}

example.config.json

@@ -7,7 +7,6 @@
   "date_format": "02/01/2006 15:04:05 MST",
   "monitors": [
     {
-      "active": false,
       "name": "google",
       "target": "https://google.com",
       "strict": true,
@@ -33,39 +32,28 @@
       "expected_body": "P.*NG"
     },
     {
-      "type": "dns",
-      "active": true,
       "name": "dns",
-      "target": "opnsense.bennetg.dev.",
+      "target": "matej.me.",
-      "question": "a",
+      "question": "mx",
+      "type": "dns",
       "component_id": 2,
       "interval": 1,
       "timeout": 1,
-      "dns": "10.0.0.60:53",
+      "dns": "8.8.4.4:53",
       "answers": [
         {
-          "exact": "10.0.0.1"
+          "regex": "[1-9] alt[1-9].aspmx.l.google.com."
-        }
-      ]
         },
         {
-      "type": "tcp",
+          "exact": "10 aspmx2.googlemail.com."
-      "name": "TCP",
-      "active": false,
-      "target": "10.0.0.1",
-      "interval": 10,
-      "timeout": 1,
-      "port": "443",
-      "component_id": 4
         },
         {
-      "active": true,
+          "exact": "1 aspmx.l.google.com."
-      "type": "icmp",
+        },
-      "name": "icmp",
+        {
-      "target": "10.0.0.1",
+          "exact": "10 aspmx3.googlemail.com."
-      "component_id": 4,
+        }
-      "interval": 10,
+      ]
-      "timeout": 3
     }
   ]
 }

example.config.yml

@@ -6,7 +6,6 @@ api:
   insecure: false
 # https://golang.org/src/time/format.go#L57
 date_format: 02/01/2006 15:04:05 MST
-slack_webhook: https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX
 monitors:
   # http monitor example
   - name: google
@@ -59,12 +58,8 @@ monitors:
     # custom DNS server (defaults to system)
     dns: 8.8.4.4:53
     answers:
+      # exact/regex check
       - regex: [1-9] alt[1-9].aspmx.l.google.com.
       - exact: 10 aspmx2.googlemail.com.
       - exact: 1 aspmx.l.google.com.
       - exact: 10 aspmx3.googlemail.com.
-  - name: smtpnine
-    target: smtp.nine.ch
-    type: tcp
-    port: 25
-    component_id: 4

go-executable-build.sh

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-
-package=$1
-if [[ -z "$package" ]]; then
-    echo "usage: $0 <package-name>"
-    exit 1
-fi
-package_name=$package
-
-#the full list of the platforms: https://golang.org/doc/install/source#environment
-platforms=(
-    # "darwin/386"
-    # "darwin/amd64"
-    # "darwin/arm"
-    # "darwin/arm64"
-    # "dragonfly/amd64"
-    # "freebsd/386"
-    # "freebsd/amd64"
-    # "freebsd/arm"
-    # "linux/386"
-    "linux/amd64"
-    # "linux/arm"
-    # "linux/arm64"
-    # "netbsd/386"
-    # "netbsd/amd64"
-    # "netbsd/arm"
-    # "openbsd/386"
-    # "openbsd/amd64"
-    # "openbsd/arm"
-    # "plan9/386"
-    # "plan9/amd64"
-    # "solaris/amd64"
-    # "windows/amd64"
-    # "windows/386"
-)
-
-for platform in "${platforms[@]}"; do
-    platform_split=(${platform//\// })
-    GOOS=${platform_split[0]}
-    GOARCH=${platform_split[1]}
-    output_name=build/$package_name'-'$GOOS'-'$GOARCH
-    if [ $GOOS = "windows" ]; then
-        output_name+='.exe'
-    fi
-
-    env CGO_ENABLED=1 GOOS=$GOOS GOARCH=$GOARCH go build -o $output_name $package
-done

go.mod

@@ -1,18 +1,17 @@
-module github.com/milkinteractive/cachet-monitor
+module github.com/castawaylabs/cachet-monitor
 
-go 1.13
+go 1.12
 
 require (
-	github.com/chenjiandongx/yap v0.2.0 // indirect
+	github.com/gizak/termui v2.3.0+incompatible // indirect
-	github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815
+	github.com/maruel/panicparse v1.2.1 // indirect
-	github.com/konsorten/go-windows-terminal-sequences v1.0.3 // indirect
+	github.com/mattn/go-runewidth v0.0.4 // indirect
-	github.com/miekg/dns v1.1.53
+	github.com/miekg/dns v1.1.13
+	github.com/mitchellh/go-wordwrap v1.0.0 // indirect
 	github.com/mitchellh/mapstructure v1.1.2
-	github.com/prometheus-community/pro-bing v0.1.0 // indirect
+	github.com/nsf/termbox-go v0.0.0-20190325093121-288510b9734e // indirect
-	github.com/sirupsen/logrus v1.9.0
+	github.com/sirupsen/logrus v1.4.2
-	github.com/stretchr/objx v0.1.1 // indirect
+	github.com/spf13/cobra v0.0.4
-	golang.org/x/crypto v0.8.0 // indirect
+	golang.org/x/net v0.0.0-20190522155817-f3200d17e092 // indirect
-	golang.org/x/tools v0.8.0 // indirect
+	gopkg.in/yaml.v2 v2.2.2
-	golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 // indirect
-	gopkg.in/yaml.v2 v2.2.7
 )

go.sum

@@ -1,146 +1,63 @@
-github.com/chenjiandongx/yap v0.2.0 h1:QggNKR8wJdvHGFCWAWwRgPb5O4oTG3BnTqg03ukrKvg=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/chenjiandongx/yap v0.2.0/go.mod h1:gCZjg9aqv/RcLpWictmDlDSUk+vBS/GAxoJbLJnSw48=
+github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815 h1:bWDMxwH3px2JBh6AyO7hdCn/PkvCZXii8TGj7sbtEbQ=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
+github.com/gizak/termui v2.3.0+incompatible h1:S8wJoNumYfc/rR5UezUM4HsPEo3RJh0LKdiuDWQpjqw=
-github.com/google/gopacket v1.1.19 h1:ves8RnFZPGiFnTS0uPQStjwru6uO6h+nlr9j6fL7kF8=
+github.com/gizak/termui v2.3.0+incompatible/go.mod h1:PkJoWUt/zacQKysNfQtcw1RW+eK2SxkieVBtl+4ovLA=
-github.com/google/gopacket v1.1.19/go.mod h1:iJ8V8n6KS+z2U1A8pUwu8bW5SyEMkXJB8Yo/Vo+TKTo=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3enTrPXyIXCl+2iCXH/aMAp9s=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/maruel/panicparse v1.2.1 h1:mNlHGiakrixj+AwF/qRpTwnj+zsWYPRLQ7wRqnJsfO0=
-github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/maruel/panicparse v1.2.1/go.mod h1:vszMjr5QQ4F5FSRfraldcIA/BCw5xrdLL+zEcU2nRBs=
-github.com/miekg/dns v1.1.27 h1:aEH/kqUzUxGJ/UHcEKdJY+ugH6WEzsEBBSPa8zuy1aM=
+github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
-github.com/miekg/dns v1.1.27/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
+github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/miekg/dns v1.1.29 h1:xHBEhR+t5RzcFJjBLJlax2daXOrTYtr9z4WdKEfWFzg=
+github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/miekg/dns v1.1.29/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
+github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y=
-github.com/miekg/dns v1.1.34 h1:SgTzfkN+oLoIHF1bgUP+C71mzuDl3AhLApHzCCIAMWM=
+github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
-github.com/miekg/dns v1.1.34/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
+github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
-github.com/miekg/dns v1.1.53 h1:ZBkuHr5dxHtB1caEOlZTLPo7D3L3TWckgUUs/RHfDxw=
+github.com/miekg/dns v1.1.13 h1:x7DQtkU0cedzeS8TD36tT/w1Hm4rDtfCaYYAHE7TTBI=
-github.com/miekg/dns v1.1.53/go.mod h1:uInx36IzPl7FYnDcMeVWxj9byh7DutNykX4G9Sj60FY=
+github.com/miekg/dns v1.1.13/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-wordwrap v1.0.0 h1:6GlHJ/LTGMrIJbwgdqdl2eEH8o+Exx/0m8ir9Gns0u4=
+github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
 github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/nsf/termbox-go v0.0.0-20190325093121-288510b9734e h1:Vbib8wJAaMEF9jusI/kMSYMr/LtRzM7+F9MJgt/nH8k=
+github.com/nsf/termbox-go v0.0.0-20190325093121-288510b9734e/go.mod h1:IuKpRQcYE1Tfu+oAQqaLisqDeXgjyyltCfsaoYN18NQ=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus-community/pro-bing v0.1.0 h1:zjzLGhfNPP0bP1OlzGB+SJcguOViw7df12LPg2vUJh8=
+github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
-github.com/prometheus-community/pro-bing v0.1.0/go.mod h1:BpWlHurD9flHtzq8wrh8QGWYz9ka9z9ZJAyOel8ej58=
 github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/sirupsen/logrus v1.5.0 h1:1N5EYkVAPEywqZRJd7cwnRtCb6xJx7NH3T3WUTF980Q=
+github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
-github.com/sirupsen/logrus v1.5.0/go.mod h1:+F7Ogzej0PZc/94MaYx/nvG9jOFMD2osvC3s+Squfpo=
+github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
-github.com/sirupsen/logrus v1.7.0 h1:ShrD1U9pZB12TX0cVy0DtePoCH97K8EtX+mg7ZARUtM=
+github.com/spf13/cobra v0.0.4 h1:S0tLZ3VOKl2Te0hpq8+ke0eSJPfCnNTPiDlsfwi1/NE=
-github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/spf13/cobra v0.0.4/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
-github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
+github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
-github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9 h1:mKdxBk7AujPs8kU4m80U72y/zjbZ3UcXC7dClwKbUI0=
+golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 h1:ObdrDkeb4kJdCP557AjRjq69pTHfNouLtWZG7j9rPN8=
+golang.org/x/net v0.0.0-20190522155817-f3200d17e092 h1:4QSRKanuywn15aTZvI/mIDEgPQpswuFndXpOj3rKEco=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/crypto v0.0.0-20200108215511-5d647ca15757 h1:pJ9H8lzdBh301qPX4VpwJ8TRpLt1IhNK1PxVOICyP54=
+golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/crypto v0.0.0-20200108215511-5d647ca15757/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200117160349-530e935923ad h1:Jh8cai0fqIK+f6nG0UgPW5wFk8wmiMhM3AyciDBdtQg=
-golang.org/x/crypto v0.0.0-20200117160349-530e935923ad/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200323165209-0ec3e9974c59 h1:3zb4D3T4G8jdExgVU/95+vQXfpEPiMdCaZgmGVxjNHM=
-golang.org/x/crypto v0.0.0-20200323165209-0ec3e9974c59/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
-golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.8.0 h1:pd9TJtTueMTVQXzk8E2XESSMQDj/U7OUu0PqJqPXQjQ=
-golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
-golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk=
-golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190923162816-aa69164e4478 h1:l5EDrHhldLYb3ZRHDUhXF7Om7MvYXnkV9/iQNo1lX6g=
-golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553 h1:efeOvDhwQ29Dj3SdAV/MJf8oukgn+8D8WgaCaRMchF8=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa h1:F+8P+gmewFQYRk6JoLQLwjBCTu3mcIURZfNkVweuRKA=
-golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k=
-golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20201016165138-7b1cca2348c0 h1:5kGOVHlq0euqwzgTC9Vu15p6fV1Wi0ArVi8da2urnVg=
-golang.org/x/net v0.0.0-20201016165138-7b1cca2348c0/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20220615171555-694bf12d69de/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894 h1:Cz4ceDQGXuKRnVBDTS23GTn/pU5OE2C0WrNTOYK1Uuc=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe h1:6fAMxZRR6sl1Uq8U61gxU+kPTs2tR8uOySCbBP7BN/M=
-golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200107162124-548cf772de50 h1:YvQ10rzcqWXLlJZ3XCUoO25savxmscf4+SC+ZqiCHhA=
-golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9 h1:1/DFK4b7JH8DmkqhUk48onnSfrPzImPoVxuomtbT2nk=
-golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200327173247-9dae0f8f5775 h1:TC0v2RSO1u2kn1ZugjrFXkRZAEaqMN/RW+OTZkBzmLE=
-golang.org/x/sys v0.0.0-20200327173247-9dae0f8f5775/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201018230417-eeed37f84f13 h1:5jaG59Zhd+8ZXe8C+lgiAGqkOaZBruqrWclLkgAww34=
-golang.org/x/sys v0.0.0-20201018230417-eeed37f84f13/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.8.0 h1:vSDcovVPld282ceKgDimkRSC8kpaH1dgyc9UMzlt84Y=
-golang.org/x/tools v0.8.0/go.mod h1:JxBZ99ISMI5ViVkT1tr6tdNmXeTrcpVSD3vZ1RsRdN4=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.7 h1:VUgggvou5XRW9mHwD/yXxIYSMtY0zoKQf/v226p2nyo=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
-gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

icmp.go

@@ -1,77 +0,0 @@
-// Thanks go to https://github.com/Soontao/cachet-monitor/blob/master/tcp.go
-package cachet
-
-import (
-	"fmt"
-
-	"github.com/chenjiandongx/yap"
-)
-
-// Investigating template
-var defaultICMPInvestigatingTpl = MessageTemplate{
-	Subject: `{{ .Monitor.Name }} - {{ .SystemName }}`,
-	Message: `{{ .Monitor.Name }} check **failed** (server time: {{ .now }})
-
-{{ .FailReason }}`,
-}
-
-// Fixed template
-var defaultICMPFixedTpl = MessageTemplate{
-	Subject: `{{ .Monitor.Name }} - {{ .SystemName }}`,
-	Message: `**Resolved** - {{ .now }}
-
-Down seconds: {{ .downSeconds }}s`,
-}
-
-// ICMPMonitor struct
-type ICMPMonitor struct {
-	AbstractMonitor `mapstructure:",squash"`
-}
-
-// CheckICMPAlive func
-func CheckICMPAlive(ip string, timeout int) (bool, error) {
-
-	pg, err := yap.NewPinger()
-	if err != nil {
-		defer pg.Close()
-	}
-
-	response := pg.Call(yap.Request{
-		Target:  ip,
-		Count:   1,
-		Timeout: timeout * 1000})
-
-	if response.Error != nil {
-		return false, response.Error
-	} else {
-		return true, nil
-	}
-
-}
-
-// test if it available
-func (m *ICMPMonitor) test() bool {
-	if alive, e := CheckICMPAlive(m.Target, int(m.Timeout)); alive {
-		return true
-	} else {
-		m.lastFailReason = fmt.Sprintf("ICMP check failed: %v", e)
-		return false
-	}
-}
-
-// Validate configuration
-func (m *ICMPMonitor) Validate() []string {
-
-	// set incident temp
-	m.Template.Investigating.SetDefault(defaultICMPInvestigatingTpl)
-	m.Template.Fixed.SetDefault(defaultICMPFixedTpl)
-
-	// super.Validate()
-	errs := m.AbstractMonitor.Validate()
-
-	if m.Target == "" {
-		errs = append(errs, "Target is required")
-	}
-
-	return errs
-}

incident.go

@@ -1,169 +0,0 @@
-package cachet
-
-import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-	"time"
-
-	"github.com/sirupsen/logrus"
-)
-
-// Incident Cachet data model
-type Incident struct {
-	ID      int    `json:"id"`
-	Name    string `json:"name"`
-	Message string `json:"message"`
-	Status  int    `json:"status"`
-	Visible int    `json:"visible"`
-	Notify  bool   `json:"notify"`
-
-	ComponentID     int `json:"component_id"`
-	ComponentStatus int `json:"component_status"`
-}
-
-//Get the last still open incident
-func (mon *AbstractMonitor) Get(cfg *CachetMonitor) (*Incident, error) {
-	requestType := "GET"
-	requestURL := fmt.Sprintf("/incidents?component_id=%d", mon.ComponentID)
-	_, body, err := cfg.API.NewRequest(requestType, requestURL, nil)
-	if err != nil {
-		return nil, err
-	}
-	data := make([]Incident, 0)
-	if err := json.Unmarshal(body.Data, &data); err != nil {
-		return nil, fmt.Errorf("Cannot parse incident body: %v, %v", err, string(body.Data))
-	}
-	//filter out resolved incidents
-	openIncidents := make([]Incident, 0)
-	for _, i := range data {
-		if i.Status < 4 {
-			openIncidents = append(openIncidents, i)
-		}
-	}
-	if len(openIncidents) == 0 {
-		return nil, nil
-	}
-	return &openIncidents[0], nil
-
-}
-
-// Send - Create or Update incident
-func (incident *Incident) Send(cfg *CachetMonitor) error {
-	switch incident.Status {
-	case 1, 2, 3:
-		// partial outage
-		incident.ComponentStatus = 3
-
-		componentStatus, err := incident.GetComponentStatus(cfg)
-		if componentStatus == 3 {
-			// major outage
-			incident.ComponentStatus = 4
-		}
-
-		if err != nil {
-			logrus.Warnf("cannot fetch component: %v", err)
-		}
-	case 4:
-		// fixed
-		incident.ComponentStatus = 1
-	}
-
-	requestType := "POST"
-	requestURL := "/incidents"
-	if incident.ID > 0 {
-		requestType = "PUT"
-		requestURL += "/" + strconv.Itoa(incident.ID)
-	}
-
-	jsonBytes, _ := json.Marshal(incident)
-
-	resp, body, err := cfg.API.NewRequest(requestType, requestURL, jsonBytes)
-	if err != nil {
-		return err
-	}
-
-	var data struct {
-		ID int `json:"id"`
-	}
-	if err := json.Unmarshal(body.Data, &data); err != nil {
-		return fmt.Errorf("Cannot parse incident body: %v, %v", err, string(body.Data))
-	}
-
-	incident.ID = data.ID
-	if resp.StatusCode != 200 {
-		return fmt.Errorf("Could not create/update incident")
-	}
-	// send slack message
-	if cfg.SlackWebhook != "" {
-		incident.sendSlack(cfg)
-	}
-	return nil
-}
-
-func (incident *Incident) GetComponentStatus(cfg *CachetMonitor) (int, error) {
-	resp, body, err := cfg.API.NewRequest("GET", "/components/"+strconv.Itoa(incident.ComponentID), nil)
-	if err != nil {
-		return 0, err
-	}
-
-	if resp.StatusCode != 200 {
-		return 0, fmt.Errorf("Invalid status code. Received %d", resp.StatusCode)
-	}
-
-	var data struct {
-		Status int `json:"status"`
-	}
-	if err := json.Unmarshal(body.Data, &data); err != nil {
-		return 0, fmt.Errorf("Cannot parse component body: %v. Err = %v", string(body.Data), err)
-	}
-
-	return data.Status, nil
-}
-
-// SetInvestigating sets status to Investigating
-func (incident *Incident) SetInvestigating() {
-	incident.Status = 1
-}
-
-// SetIdentified sets status to Identified
-func (incident *Incident) SetIdentified() {
-	incident.Status = 2
-}
-
-// SetWatching sets status to Watching
-func (incident *Incident) SetWatching() {
-	incident.Status = 3
-}
-
-// SetFixed sets status to Fixed
-func (incident *Incident) SetFixed() {
-	incident.Status = 4
-}
-
-// Send slack message
-func (incident *Incident) sendSlack(cfg *CachetMonitor) {
-	color := "#bf1932" //red
-	if incident.ComponentStatus == 1 {
-		color = "#36a64f" //green
-	}
-	titleLink := MainUrl(cfg) + "/dashboard/incidents/" + strconv.Itoa(incident.ID)
-	slack := Slack{
-		WebhookURL: cfg.SlackWebhook,
-		Attachments: []Attachments{
-			Attachments{
-				Fallback:   incident.Name,
-				Color:      color,
-				Title:      incident.Name,
-				TitleLink:  titleLink,
-				Text:       incident.Message,
-				Footer:     "Cachet Monitor",
-				FooterIcon: "https://i.imgur.com/spck1w6.png",
-				Ts:         time.Now().Unix(),
-			},
-		}}
-	err := slack.SendSlackNotification()
-	if err != nil {
-		fmt.Errorf("Cannot send slack message. Err = %v", err)
-	}
-}

make.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -e
+
+if [ "$1" == "test" ]; then
+  reflex -r '\.go$' -s -d none -- sh -c 'go test ./...'
+fi
+
+reflex -r '\.go$' -s -d none -- sh -c 'go build -o ./cachet-monitor ./cli/ && ./cachet-monitor -c config.yml'
+exit 0

monitor.go

@@ -1,270 +0,0 @@
-package cachet
-
-import (
-	"sync"
-	"time"
-
-	"github.com/sirupsen/logrus"
-)
-
-const DefaultInterval = time.Second * 60
-const DefaultTimeout = time.Second
-const DefaultTimeFormat = "15:04:05 Jan 2 MST"
-const HistorySize = 10
-
-type MonitorInterface interface {
-	ClockStart(*CachetMonitor, MonitorInterface, *sync.WaitGroup)
-	ClockStop()
-	tick(MonitorInterface)
-	test() bool
-
-	Validate() []string
-	GetMonitor() *AbstractMonitor
-	Describe() []string
-}
-
-// AbstractMonitor data model
-type AbstractMonitor struct {
-	Name   string
-	Target string
-	Active bool
-
-	// (default)http / dns
-	Type   string
-	Strict bool
-
-	Interval time.Duration
-	Timeout  time.Duration
-
-	MetricID    int `mapstructure:"metric_id"`
-	ComponentID int `mapstructure:"component_id"`
-
-	// Templating stuff
-	Template struct {
-		Investigating MessageTemplate
-		Fixed         MessageTemplate
-	}
-
-	// Threshold = percentage / number of down incidents
-	Threshold      float32
-	ThresholdCount bool `mapstructure:"threshold_count"`
-
-	// lag / average(lagHistory) * 100 = percentage above average lag
-	// PerformanceThreshold sets the % limit above which this monitor will trigger degraded-performance
-	// PerformanceThreshold float32
-
-	history []bool
-	// lagHistory     []float32
-	lastFailReason string
-	incident       *Incident
-	config         *CachetMonitor
-
-	// Closed when mon.Stop() is called
-	stopC chan bool
-}
-
-func (mon *AbstractMonitor) Validate() []string {
-	errs := []string{}
-
-	if len(mon.Name) == 0 {
-		errs = append(errs, "Name is required")
-	}
-
-	if mon.Interval < 1 {
-		mon.Interval = DefaultInterval
-	}
-	if mon.Timeout < 1 {
-		mon.Timeout = DefaultTimeout
-	}
-
-	if mon.Timeout > mon.Interval {
-		errs = append(errs, "Timeout greater than interval")
-	}
-
-	if mon.ComponentID == 0 && mon.MetricID == 0 {
-		errs = append(errs, "component_id & metric_id are unset")
-	}
-
-	if mon.Threshold <= 0 {
-		mon.Threshold = 100
-	}
-
-	if err := mon.Template.Fixed.Compile(); err != nil {
-		errs = append(errs, "Could not compile \"fixed\" template: "+err.Error())
-	}
-	if err := mon.Template.Investigating.Compile(); err != nil {
-		errs = append(errs, "Could not compile \"investigating\" template: "+err.Error())
-	}
-
-	return errs
-}
-func (mon *AbstractMonitor) GetMonitor() *AbstractMonitor {
-	return mon
-}
-func (mon *AbstractMonitor) Describe() []string {
-	features := []string{"Type: " + mon.Type}
-
-	if len(mon.Name) > 0 {
-		features = append(features, "Name: "+mon.Name)
-	}
-
-	if !mon.Active {
-		features = append(features, "Active: No")
-	}
-
-	return features
-}
-
-func (mon *AbstractMonitor) ClockStart(cfg *CachetMonitor, iface MonitorInterface, wg *sync.WaitGroup) {
-	if !mon.Active {
-		return
-	};
-	wg.Add(1)
-	mon.config = cfg
-	mon.stopC = make(chan bool)
-	if cfg.Immediate {
-		mon.tick(iface)
-	}
-
-	if cfg.Restarted {
-		initialIncident, err := mon.Get(cfg)
-		if err != nil {
-			logrus.Warn("could not fetch initial incident: %v", err)
-		}
-		if initialIncident != nil {
-			mon.incident = initialIncident
-		}
-	}
-
-	ticker := time.NewTicker(mon.Interval * time.Second)
-	for {
-		select {
-		case <-ticker.C:
-			mon.tick(iface)
-		case <-mon.stopC:
-			wg.Done()
-			return
-		}
-	}
-}
-
-func (mon *AbstractMonitor) ClockStop() {
-	select {
-	case <-mon.stopC:
-		return
-	default:
-		close(mon.stopC)
-	}
-}
-
-func (mon *AbstractMonitor) test() bool { return false }
-
-func (mon *AbstractMonitor) tick(iface MonitorInterface) {
-	reqStart := getMs()
-	up := iface.test()
-	lag := getMs() - reqStart
-
-	histSize := HistorySize
-	if mon.ThresholdCount {
-		histSize = int(mon.Threshold)
-	}
-
-	if len(mon.history) == histSize-1 {
-		logrus.Warnf("%v is now saturated", mon.Name)
-	}
-	if len(mon.history) >= histSize {
-		mon.history = mon.history[len(mon.history)-(histSize-1):]
-	}
-	mon.history = append(mon.history, up)
-	mon.AnalyseData()
-
-	// report lag
-	if mon.MetricID > 0 {
-		go mon.config.API.SendMetric(mon.MetricID, lag)
-	}
-}
-
-// TODO: test
-// AnalyseData decides if the monitor is statistically up or down and creates / resolves an incident
-func (mon *AbstractMonitor) AnalyseData() {
-	// look at the past few incidents
-	numDown := 0
-	for _, wasUp := range mon.history {
-		if wasUp == false {
-			numDown++
-		}
-	}
-
-	t := (float32(numDown) / float32(len(mon.history))) * 100
-	l := logrus.WithFields(logrus.Fields{
-		"monitor": mon.Name,
-		"time":    time.Now().Format(mon.config.DateFormat),
-	})
-	if numDown == 0 {
-		l.Printf("monitor is up")
-	} else if mon.ThresholdCount {
-		l.Printf("monitor down %d/%d", numDown, int(mon.Threshold))
-	} else {
-		l.Printf("monitor down %.2f%%/%.2f%%", t, mon.Threshold)
-	}
-
-	histSize := HistorySize
-	if mon.ThresholdCount {
-		histSize = int(mon.Threshold)
-	}
-
-	if len(mon.history) != histSize {
-		// not saturated
-		return
-	}
-
-	triggered := (mon.ThresholdCount && numDown == int(mon.Threshold)) || (!mon.ThresholdCount && t > mon.Threshold)
-
-	if triggered && mon.incident == nil {
-		// create incident
-		tplData := getTemplateData(mon)
-		tplData["FailReason"] = mon.lastFailReason
-
-		subject, message := mon.Template.Investigating.Exec(tplData)
-		mon.incident = &Incident{
-			Name:        subject,
-			ComponentID: mon.ComponentID,
-			Message:     message,
-			Notify:      true,
-		}
-
-		// is down, create an incident
-		l.Warnf("creating incident. Monitor is down: %v", mon.lastFailReason)
-		// set investigating status
-		mon.incident.SetInvestigating()
-		// create/update incident
-		if err := mon.incident.Send(mon.config); err != nil {
-			l.Printf("Error sending incident: %v", err)
-		}
-
-		return
-	}
-
-	// still triggered or no incident
-	if triggered || mon.incident == nil {
-		return
-	}
-
-	// was down, created an incident, its now ok, make it resolved.
-	l.Warn("Resolving incident")
-
-	// resolve incident
-	tplData := getTemplateData(mon)
-	tplData["incident"] = mon.incident
-
-	subject, message := mon.Template.Fixed.Exec(tplData)
-	mon.incident.Name = subject
-	mon.incident.Message = message
-	mon.incident.SetFixed()
-	if err := mon.incident.Send(mon.config); err != nil {
-		l.Printf("Error sending incident: %v", err)
-	}
-
-	mon.lastFailReason = ""
-	mon.incident = nil
-}

monitor_test.go

@@ -1,7 +0,0 @@
-package cachet
-
-import (
-	"testing"
-)
-
-func TestAnalyseData(t *testing.T) {}

monitors/dns.go

@@ -1,14 +1,33 @@
-package cachet
+package monitors
 
 import (
+	"errors"
 	"net"
 	"regexp"
 	"strings"
 
-	"github.com/sirupsen/logrus"
 	"github.com/miekg/dns"
+	"github.com/sirupsen/logrus"
 )
 
+// Investigating template
+var defaultDNSInvestigatingTpl = MessageTemplate{
+	Subject: `{{ .Monitor.Name }} - {{ .SystemName }}`,
+	Message: `{{ .Monitor.Name }} DNS check **failed** (server time: {{ .now }})
+
+{{ .FailReason }}`,
+}
+
+// Fixed template
+var defaultDNSFixedTpl = MessageTemplate{
+	Subject: `{{ .Monitor.Name }} - {{ .SystemName }}`,
+	Message: `**Resolved** - {{ .now }}
+
+- - -
+
+{{ .incident.Message }}`,
+}
+
 type DNSAnswer struct {
 	Regex  string
 	regexp *regexp.Regexp
@@ -28,8 +47,11 @@ type DNSMonitor struct {
 	Answers []DNSAnswer
 }
 
-func (monitor *DNSMonitor) Validate() []string {
+func (monitor *DNSMonitor) Validate(validate backendValidateFunc) []string {
-	errs := monitor.AbstractMonitor.Validate()
+	monitor.Template.Investigating.SetDefault(defaultDNSInvestigatingTpl)
+	monitor.Template.Fixed.SetDefault(defaultDNSFixedTpl)
+
+	errs := monitor.AbstractMonitor.Validate(validate)
 
 	if len(monitor.DNS) == 0 {
 		config, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
@@ -61,7 +83,7 @@ func (monitor *DNSMonitor) Validate() []string {
 	return errs
 }
 
-func (monitor *DNSMonitor) test() bool {
+func (monitor *DNSMonitor) test() (bool, []error) {
 	m := new(dns.Msg)
 	m.SetQuestion(dns.Fqdn(monitor.Target), monitor.question)
 	m.RecursionDesired = true
@@ -70,11 +92,11 @@ func (monitor *DNSMonitor) test() bool {
 	r, _, err := c.Exchange(m, monitor.DNS)
 	if err != nil {
 		logrus.Warnf("DNS error: %v", err)
-		return false
+		return false, []error{err}
 	}
 
 	if r.Rcode != dns.RcodeSuccess {
-		return false
+		return false, []error{errors.New("Invalid status code returned")}
 	}
 
 	for _, check := range monitor.Answers {
@@ -88,11 +110,11 @@ func (monitor *DNSMonitor) test() bool {
 
 		if !found {
 			logrus.Warnf("DNS check failed: %v. Not found in any of %v", check, r.Answer)
-			return false
+			return false, []error{errors.New("Record not found")}
 		}
 	}
 
-	return true
+	return true, nil
 }
 
 func findDNSType(t string) uint16 {

monitors/http.go

@@ -1,9 +1,8 @@
-package cachet
+package monitors
 
 import (
-	"crypto/md5"
 	"crypto/tls"
-	"fmt"
+	"errors"
 	"io/ioutil"
 	"net/http"
 	"regexp"
@@ -15,7 +14,7 @@ import (
 // Investigating template
 var defaultHTTPInvestigatingTpl = MessageTemplate{
 	Subject: `{{ .Monitor.Name }} - {{ .SystemName }}`,
-	Message: `{{ .Monitor.Name }} check **failed** (server time: {{ .now }})
+	Message: `{{ .Monitor.Name }} HTTP check **failed** (server time: {{ .now }})
 
 {{ .FailReason }}`,
 }
@@ -40,33 +39,19 @@ type HTTPMonitor struct {
 	// compiled to Regexp
 	ExpectedBody string `mapstructure:"expected_body"`
 	bodyRegexp   *regexp.Regexp
-
-	// content check
-	ExpectedMd5Sum string `mapstructure:"expected_md5sum"`
-	ExpectedLength int    `mapstructure:"expected_length"`
-
-	// data
-	Data string `mapstructure:"data"`
 }
 
 // TODO: test
-func (monitor *HTTPMonitor) test() bool {
+func (monitor *HTTPMonitor) test() (bool, []error) {
-	var req *http.Request
+	req, err := http.NewRequest(monitor.Method, monitor.Target, nil)
-	var err error
-
-	if monitor.Data != "" {
-		dataBuffer := strings.NewReader(monitor.Data)
-		req, err = http.NewRequest(monitor.Method, monitor.Target, dataBuffer)
-	} else {
-		req, err = http.NewRequest(monitor.Method, monitor.Target, nil)
-	}
-
 	for k, v := range monitor.Headers {
 		req.Header.Add(k, v)
 	}
 
 	transport := http.DefaultTransport.(*http.Transport)
-	transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: monitor.Strict == false}
+	transport.TLSClientConfig = &tls.Config{
+		InsecureSkipVerify: monitor.Strict == false,
+	}
 	client := &http.Client{
 		Timeout:   time.Duration(monitor.Timeout * time.Second),
 		Transport: transport,
@@ -74,53 +59,38 @@ func (monitor *HTTPMonitor) test() bool {
 
 	resp, err := client.Do(req)
 	if err != nil {
-		monitor.lastFailReason = err.Error()
+		return false, []error{err}
-		return false
 	}
 
 	defer resp.Body.Close()
 
 	if monitor.ExpectedStatusCode > 0 && resp.StatusCode != monitor.ExpectedStatusCode {
-		monitor.lastFailReason = "Expected HTTP response status: " + strconv.Itoa(monitor.ExpectedStatusCode) + ", got: " + strconv.Itoa(resp.StatusCode)
+		fail := "Expected HTTP response status: " + strconv.Itoa(monitor.ExpectedStatusCode) + ", got: " + strconv.Itoa(resp.StatusCode)
-		return false
+		return false, []error{errors.New(fail)}
-	}
-
-	responseBody, err := ioutil.ReadAll(resp.Body)
-	responseLength := len(string(responseBody))
-	if err != nil {
-		monitor.lastFailReason = err.Error()
-		return false
-	}
-
-	if monitor.ExpectedLength > 0 && responseLength != monitor.ExpectedLength {
-		monitor.lastFailReason = "Expected response body length: " + strconv.Itoa(monitor.ExpectedLength) + ", got: " + strconv.Itoa(responseLength)
-		return false
-	}
-
-	if monitor.ExpectedMd5Sum != "" {
-		sum := fmt.Sprintf("%x", (md5.Sum(responseBody)))
-		if strings.Compare(sum, monitor.ExpectedMd5Sum) != 0 {
-			monitor.lastFailReason = "Expected respsone body MD5 checksum: " + monitor.ExpectedMd5Sum + ", got: " + sum
-			return false
-		}
 	}
 
 	if monitor.bodyRegexp != nil {
+		// check response body
+		responseBody, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return false, []error{err}
+		}
+
 		if !monitor.bodyRegexp.Match(responseBody) {
-			monitor.lastFailReason = "Unexpected body: " + string(responseBody) + ".\nExpected to match: " + monitor.ExpectedBody
+			fail := "Unexpected body: " + string(responseBody) + ".\nExpected to match: " + monitor.ExpectedBody
-			return false
+			return false, []error{errors.New(fail)}
 		}
 	}
 
-	return true
+	return true, nil
 }
 
 // TODO: test
-func (mon *HTTPMonitor) Validate() []string {
+func (mon *HTTPMonitor) Validate(validate backendValidateFunc) []string {
 	mon.Template.Investigating.SetDefault(defaultHTTPInvestigatingTpl)
 	mon.Template.Fixed.SetDefault(defaultHTTPFixedTpl)
 
-	errs := mon.AbstractMonitor.Validate()
+	errs := mon.AbstractMonitor.Validate(validate)
 
 	if len(mon.ExpectedBody) > 0 {
 		exp, err := regexp.Compile(mon.ExpectedBody)

monitors/monitor.go

@@ -0,0 +1,257 @@
+package monitors
+
+import (
+	"sync"
+	"time"
+
+	"github.com/sirupsen/logrus"
+)
+
+const DefaultInterval = time.Second * 60
+const DefaultTimeout = time.Second
+const HistorySize = 10
+
+type MonitorStatus string
+
+const (
+	MonitorStatusUp           = "up"
+	MonitorStatusDown         = "down"
+	MonitorStatusNotSaturated = "unsaturated"
+)
+
+type backendValidateFunc = func(monitor *AbstractMonitor) []string
+type MonitorTestFunc func() (up bool, errs []error)
+type MonitorTickFunc func(monitor MonitorInterface, status MonitorStatus, errs []error, lag int64)
+
+type MonitorInterface interface {
+	Start(MonitorTestFunc, *sync.WaitGroup, MonitorTickFunc, bool)
+	Stop()
+
+	tick(MonitorTestFunc) (status MonitorStatus, errors []error, lag int64)
+	test() (bool, []error)
+
+	Validate(validate backendValidateFunc) []string
+	Describe() []string
+
+	GetMonitor() *AbstractMonitor
+	GetTestFunc() MonitorTestFunc
+	GetLastStatus() MonitorStatus
+	UpdateLastStatus(status MonitorStatus) (old MonitorStatus)
+}
+
+// AbstractMonitor data model
+type AbstractMonitor struct {
+	Name   string
+	Target string
+
+	// (default)http / dns
+	Type   string
+	Strict bool
+
+	Interval time.Duration
+	Timeout  time.Duration
+	Params   map[string]interface{}
+
+	// Templating stuff
+	Template MonitorTemplates
+
+	// Threshold = percentage / number of down incidents
+	Threshold      float32
+	ThresholdCount bool `mapstructure:"threshold_count"`
+
+	// lag / average(lagHistory) * 100 = percentage above average lag
+	// PerformanceThreshold sets the % limit above which this monitor will trigger degraded-performance
+	// PerformanceThreshold float32
+
+	history    []bool
+	lastStatus MonitorStatus
+
+	// Closed when mon.Stop() is called
+	stopC chan bool
+}
+
+func (mon *AbstractMonitor) Validate(validate backendValidateFunc) []string {
+	errs := []string{}
+
+	if len(mon.Name) == 0 {
+		errs = append(errs, "Name is required")
+	}
+
+	if mon.Interval < 1 {
+		mon.Interval = DefaultInterval
+	}
+	if mon.Timeout < 1 {
+		mon.Timeout = DefaultTimeout
+	}
+
+	if mon.Timeout > mon.Interval {
+		errs = append(errs, "Timeout greater than interval")
+	}
+
+	// get the backend to validate the monitor
+	errs = append(errs, validate(mon)...)
+
+	if mon.Threshold <= 0 {
+		mon.Threshold = 100
+	}
+
+	// if len(mon.Template.Fixed.Message) == 0 || len(mon.Template.Fixed.Subject) == 0 {
+	// 	errs = append(errs, "\"fixed\" template empty/missing")
+	// }
+	// if len(mon.Template.Investigating.Message) == 0 || len(mon.Template.Investigating.Subject) == 0 {
+	// 	errs = append(errs, "\"investigating\" template empty/missing")
+	// }
+	if err := mon.Template.Fixed.Compile(); err != nil {
+		errs = append(errs, "Could not compile \"fixed\" template: "+err.Error())
+	}
+	if err := mon.Template.Investigating.Compile(); err != nil {
+		errs = append(errs, "Could not compile \"investigating\" template: "+err.Error())
+	}
+
+	return errs
+}
+
+func (mon *AbstractMonitor) GetMonitor() *AbstractMonitor {
+	return mon
+}
+
+func (mon *AbstractMonitor) Describe() []string {
+	features := []string{"Type: " + mon.Type}
+
+	if len(mon.Name) > 0 {
+		features = append(features, "Name: "+mon.Name)
+	}
+
+	return features
+}
+
+func (mon *AbstractMonitor) Start(testFunc MonitorTestFunc, wg *sync.WaitGroup, tickFunc MonitorTickFunc, immediate bool) {
+	wg.Add(1)
+
+	mon.stopC = make(chan bool)
+	if immediate {
+		status, errs, lag := mon.tick(testFunc)
+		tickFunc(mon, status, errs, lag)
+	}
+
+	ticker := time.NewTicker(mon.Interval * time.Second)
+	for {
+		select {
+		case <-ticker.C:
+			status, errs, lag := mon.tick(testFunc)
+			tickFunc(mon, status, errs, lag)
+		case <-mon.stopC:
+			wg.Done()
+			return
+		}
+	}
+}
+
+func (mon *AbstractMonitor) Stop() {
+	select {
+	case <-mon.stopC:
+		return
+	default:
+		close(mon.stopC)
+	}
+}
+
+func (mon *AbstractMonitor) tick(testFunc MonitorTestFunc) (status MonitorStatus, errors []error, lag int64) {
+	reqStart := getMs()
+	up, errs := testFunc()
+	lag = getMs() - reqStart
+
+	histSize := HistorySize
+	if mon.ThresholdCount {
+		histSize = int(mon.Threshold)
+	}
+
+	if len(mon.history) == histSize-1 {
+		logrus.WithFields(logrus.Fields{
+			"monitor": mon.Name,
+		}).Warn("monitor saturated")
+	}
+	if len(mon.history) >= histSize {
+		mon.history = mon.history[len(mon.history)-(histSize-1):]
+	}
+	mon.history = append(mon.history, up)
+	status = mon.GetStatus()
+	errors = errs
+
+	return
+}
+
+// TODO: test
+// AnalyseData decides if the monitor is statistically up or down and creates / resolves an incident
+func (mon *AbstractMonitor) GetStatus() MonitorStatus {
+	numDown := 0
+	for _, wasUp := range mon.history {
+		if wasUp == false {
+			numDown++
+		}
+	}
+
+	t := (float32(numDown) / float32(len(mon.history))) * 100
+	logFields := logrus.Fields{"monitor": mon.Name}
+	// stop reporting time for jsonformatter, it's there by default
+	if _, ok := logrus.StandardLogger().Formatter.(*logrus.JSONFormatter); !ok {
+		logFields["t"] = time.Now()
+	}
+	l := logrus.WithFields(logFields)
+
+	symbol := "⚠️"
+	if t == 100 {
+		symbol = "❌"
+	}
+	if numDown == 0 {
+		l.Printf("👍 up")
+	} else if mon.ThresholdCount {
+		l.Printf("%v down (%d/%d)", symbol, numDown, int(mon.Threshold))
+	} else {
+		l.Printf("%v down %.0f%%/%.0f%%", symbol, t, mon.Threshold)
+	}
+
+	histSize := HistorySize
+	if mon.ThresholdCount {
+		histSize = int(mon.Threshold)
+	}
+
+	if len(mon.history) != histSize {
+		// not saturated
+		return MonitorStatusNotSaturated
+	}
+
+	var down bool
+	if mon.ThresholdCount {
+		down = numDown >= int(mon.Threshold)
+	} else {
+		down = t >= mon.Threshold
+	}
+
+	if !down {
+		return MonitorStatusUp
+	}
+
+	return MonitorStatusDown
+}
+
+func (mon *AbstractMonitor) GetTestFunc() MonitorTestFunc {
+	return mon.test
+}
+
+func (mon *AbstractMonitor) GetLastStatus() MonitorStatus {
+	return mon.lastStatus
+}
+
+func (mon *AbstractMonitor) UpdateLastStatus(status MonitorStatus) (old MonitorStatus) {
+	old = mon.lastStatus
+	mon.lastStatus = status
+
+	return
+}
+
+func (mon *AbstractMonitor) test() (bool, []error) { return false, nil }
+
+func getMs() int64 {
+	return time.Now().UnixNano() / int64(time.Millisecond)
+}

monitors/template.go

@@ -1,10 +1,15 @@
-package cachet
+package monitors
 
 import (
 	"bytes"
 	"text/template"
 )
 
+type MonitorTemplates struct {
+	Investigating MessageTemplate
+	Fixed         MessageTemplate
+}
+
 type MessageTemplate struct {
 	Subject string `json:"subject"`
 	Message string `json:"message"`

readme.md

@@ -1,69 +1,94 @@
-# cachet-monitor
+![screenshot](https://castawaylabs.github.io/cachet-monitor/screenshot.png)
-
-a fork of the cachet-monitor project originally developed by CastawayLabs but abandoned. Extended with new features needed by the people.
 
 ## Features
 
-:heavy_check_mark: Interval based checking of predefined Resources  
+- [x] Creates & Resolves Incidents
-:heavy_check_mark: Posts monitor lag to cachet graphs  
+- [x] Posts monitor lag to cachet graphs
-:heavy_check_mark: Creates & Resolves Incidents  
+- [x] HTTP Checks (body/status code)
-:heavy_check_mark: Updates Component to Partial Outage  
+- [x] DNS Checks
-:heavy_check_mark: Updates Component to Major Outage if already in Partial Outage (works with distributed monitors)  
+- [x] Updates Component to Partial Outage
-:heavy_check_mark: Can be run on multiple servers and geo regions  
+- [x] Updates Component to Major Outage if already in Partial Outage (works with distributed monitors)
-:heavy_check_mark: HTTP Checks (body/status code)  
+- [x] Can be run on multiple servers and geo regions
-:heavy_check_mark: DNS Checks  
-:heavy_check_mark: TCP Checks  
-:heavy_check_mark: ICMP Checks
 
-## Quick Start
+## Example Configuration
 
-Configuration can be done in either yaml or json format. An example JSON-File would look something like this:
+**Note:** configuration can be in json or yaml format. [`example.config.json`](https://github.com/CastawayLabs/cachet-monitor/blob/master/example.config.json), [`example.config.yaml`](https://github.com/CastawayLabs/cachet-monitor/blob/master/example.config.yml) files.
 
-```json
+```yaml
-{
+api:
-  "api": {
+  # cachet url
-    "url": "https://demo.cachethq.io/api/v1",
+  url: https://demo.cachethq.io/api/v1
-    "token": "9yMHsdioQosnyVK4iCVR",
+  # cachet api token
-    "insecure": false
+  token: 9yMHsdioQosnyVK4iCVR
-  },
+  insecure: false
-  "date_format": "02/01/2006 15:04:05 MST",
+# https://golang.org/src/time/format.go#L57
-  "monitors": [
+date_format: 02/01/2006 15:04:05 MST
-    {
+monitors:
-      "active": false,
+  # http monitor example
-      "name": "google",
+  - name: google
-      "target": "https://google.com",
+    # test url
-      "strict": true,
+    target: https://google.com
-      "method": "POST",
+    # strict certificate checking for https
-      "component_id": 1,
+    strict: true
-      "metric_id": 4,
+    # HTTP method
-      "template": {
+    method: POST
-        "investigating": {
+    
-          "subject": "{{ .Monitor.Name }} - {{ .SystemName }}",
+    # set to update component (either component_id or metric_id are required)
-          "message": "{{ .Monitor.Name }} check **failed** (server time: {{ .now }})\n\n{{ .FailReason }}"
+    component_id: 1
-        },
+    # set to post lag to cachet metric (graph)
-        "fixed": {
+    metric_id: 4
-          "subject": "I HAVE BEEN FIXED"
+
-        }
+    # custom templates (see readme for details)
-      },
+    # leave empty for defaults
-      "interval": 1,
+    template:
-      "timeout": 1,
+      investigating:
-      "threshold": 80,
+        subject: "{{ .Monitor.Name }} - {{ .SystemName }}"
-      "headers": {
+        message: "{{ .Monitor.Name }} check **failed** (server time: {{ .now }})\n\n{{ .FailReason }}"
-        "Authorization": "Basic <hash>"
+      fixed:
-      },
+        subject: "I HAVE BEEN FIXED"
-      "expected_status_code": 200,
+    
-      "expected_body": "P.*NG"
+    # seconds between checks
-    }
+    interval: 1
-  ]
+    # seconds for timeout
-}
+    timeout: 1
+    # If % of downtime is over this threshold, open an incident
+    threshold: 80
+
+    # custom HTTP headers
+    headers:
+      Authorization: Basic <hash>
+    # expected status code (either status code or body must be supplied)
+    expected_status_code: 200
+    # regex to match body
+    expected_body: "P.*NG"
+  # dns monitor example
+  - name: dns
+    # fqdn
+    target: matej.me.
+    # question type (A/AAAA/CNAME/...)
+    question: mx
+    type: dns
+    # set component_id/metric_id
+    component_id: 2
+    # poll every 1s
+    interval: 1
+    timeout: 1
+    # custom DNS server (defaults to system)
+    dns: 8.8.4.4:53
+    answers:
+      # exact/regex check
+      - regex: [1-9] alt[1-9].aspmx.l.google.com.
+      - exact: 10 aspmx2.googlemail.com.
+      - exact: 1 aspmx.l.google.com.
+      - exact: 10 aspmx3.googlemail.com.
 ```
 
 ## Installation
 
-1. Download binary from [release page](https://github.com/bennetgallein/cachet-monitor/releases)
+1. Download binary from [release page](https://github.com/CastawayLabs/cachet-monitor/releases)
 2. Add the binary to an executable path (/usr/bin, etc.)
 3. Create a configuration following provided examples
-4. `cachet-monitor -c /etc/cachet-monitor.json`
+4. `cachet-monitor -c /etc/cachet-monitor.yaml`
 
 pro tip: run in background using `nohup cachet-monitor 2>&1 > /var/log/cachet-monitor.log &`, or use a tmux/screen session
 
@@ -86,7 +111,6 @@ Options:
   -h --help                      Show this screen.
   --version                      Show version
   --immediate                    Tick immediately (by default waits for first defined interval)
-  --restarted                    Get open incidents before start monitoring (if monitor died or restarted)
   
 Environment varaibles:
   CACHET_API      override API url from configuration
@@ -96,7 +120,7 @@ Environment varaibles:
 
 ## Init script
 
-If your system is running systemd (like Debian, Ubuntu 16.04, Fedora, RHEL7, or Archlinux) you can use the provided example file: [example.cachet-monitor.service](https://github.com/bennetgallein/cachet-monitor/blob/master/example.cachet-monitor.service).
+If your system is running systemd (like Debian, Ubuntu 16.04, Fedora, RHEL7, or Archlinux) you can use the provided example file: [example.cachet-monitor.service](https://github.com/CastawayLabs/cachet-monitor/blob/master/example.cachet-monitor.service).
 
 1. Simply put it in the right place with `cp example.cachet-monitor.service /etc/systemd/system/cachet-monitor.service`
 2. Then do a `systemctl daemon-reload` in your terminal to update Systemd configuration
@@ -109,14 +133,14 @@ This package makes use of [`text/template`](https://godoc.org/text/template). [D
 The following variables are available:
 
 | Root objects  | Description                         |
-| ------------- | ----------------------------------- |
+| ------------- | ------------------------------------|
 | `.SystemName` | system name                         | 
 | `.API`        | `api` object from configuration     |
 | `.Monitor`    | `monitor` object from configuration |
 | `.now`        | formatted date string               |
 
 | Monitor variables  |
-| ----------------- |
+| ------------------ |
 | `.Name`            |
 | `.Target`          |
 | `.Type`            |
@@ -126,66 +150,6 @@ The following variables are available:
 
 All monitor variables are available from `monitor.go`
 
-## Monitor Types
-
-We support a variety of monitor-types. Here are the configuration parameters for each of them
-
-Also, the following parameters are shared for all monitors.
-
-| Key                     | Description                                                                    |
-| ----------------------- | ------------------------------------------------------------------------------ |
-| name                    | a friendly name for the monitor                                                |
-| target                  | target for the check (e.g. a domain or IP)                                     |
-| active                  | a boolean wether or not this test is currently active                          |
-| type                    | type type of the check, see supported types above or below                     |
-| interval                | the interval in seconds in which to check the monitor                          |
-| timeout                 | the timeout for each check. Needs to be smaller than the interval              |
-| metric_id               | the ID of the metric. Metrics are used for graphing values                     |
-| component_id            | the ID of the component inside of Cachet. Used for creating incidents          |
-| templates.investigating | template to use as a message for when the check enters the investigating stage |
-| templates.fixed         | template to use as a message for when the check enters the fixed stage         |
-| threshold               | If % of downtime is over this threshold, open an incident                      |
-| threshold_count         | the number of checks that count into the threshold (defaults to 10)            |
-
-### HTTP
-
-Either expected_body or expected_status_code needs to be set.
-
-| Key                  | Description                                                                                 |
-| -------------------- | ------------------------------------------------------------------------------------------- |
-| method               | the HTTP Request method to use (Defaults to GET)                                            |
-| headers              | a key-value array of additional headers to use for the request                              |
-| expected_status_code | the expected status-code returned from the request                                          |
-| expected_body        | a regex or normal string that will be used to test against the returned body of the request |
-| expected_md5sum      | a md5 checksum of the body, which will be checked against                                   |
-| expected_length      | the length of the string of the response body                                               |
-| data                 | body-data for a post request                                                                |
-
-### DNS
-
-| Key      | Description                                                                                          |
-| -------- | ---------------------------------------------------------------------------------------------------- |
-| dns      | set a custom DNS-Resolver (IP:Port format)                                                           |
-| question | the type of DNS-Request to execute (e.g. A, MX, CNAME...). Can also be a List (['A', 'MX', 'CNAME']) |
-| answers  | an array of response objects. see below                                                              |
-
-#### Answer Object
-
-| Key   | Description                                                           |
-| ----- | --------------------------------------------------------------------- |
-| regex | if you want to use a regexp, use this key and the regexp as the value |
-| exact | exact match for the response value                                    |
-
-### TCP
-
-| Key  | Description                        |
-| ---- | ---------------------------------- |
-| port | the port to do a tcp connection to |
-
-### ICMP
-
-_No special variables needed_
-
 ## Vision and goals
 
 We made this tool because we felt the need to have our own monitoring software (leveraging on Cachet).
@@ -201,12 +165,9 @@ When using `cachet-monitor` as a package in another program, you should follow w
 
 # Contributions welcome
 
-We'll happily accept contributions for anything usefull.
+We'll happily accept contributions for the following (non exhaustive list).
 
-# Build on Linux/MacOS
+- Implement ICMP check
-
+- Implement TCP check
-1. Read and install with https://ahmadawais.com/install-go-lang-on-macos-with-homebrew/
+- Any bug fixes / code improvements
-2. Test in console with `go get -u` and `go build cli/main.go`
+- Test cases
-3. Run `./go-executable-build.sh cli/main.go`
-4. This will create a `build/cli/main.go-linux-amd64`-file, which is the executable binary
-5. `mv build/cli/main.go-linux-amd64 /usr/bin/cachet-monitor`

slack.go

@@ -1,80 +0,0 @@
-package cachet
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"log"
-	"net/http"
-	"time"
-)
-
-type Slack struct {
-	WebhookURL  string
-	Attachments []Attachments `json:"attachments"`
-}
-type Fields struct {
-	Title string `json:"title"`
-	Value string `json:"value"`
-	Short bool   `json:"short"`
-}
-type Attachments struct {
-	Fallback   string   `json:"fallback"`
-	Color      string   `json:"color"`
-	Pretext    string   `json:"pretext"`
-	Title      string   `json:"title"`
-	TitleLink  string   `json:"title_link"`
-	Text       string   `json:"text"`
-	Fields     []Fields `json:"fields"`
-	ThumbURL   string   `json:"thumb_url"`
-	Footer     string   `json:"footer"`
-	FooterIcon string   `json:"footer_icon"`
-	Ts         int64    `json:"ts"`
-}
-
-func test() {
-	slack := Slack{
-		Attachments: []Attachments{
-			Attachments{
-				Fallback:   "Required plain-text summary of the attachment.",
-				Color:      "#36a64f",
-				Title:      "Slack API Documentation",
-				TitleLink:  "https://status.easyship.com",
-				Text:       "Optional text that appears within the attachment",
-				Footer:     "Cachet Monitor",
-				FooterIcon: "https://i.imgur.com/spck1w6.png",
-				Ts:         time.Now().Unix(),
-			},
-		}}
-	slack.WebhookURL = "https://hooks.slack.com/services/0000000/00000000/xxxxxxxxxxxxxxxxxxx"
-	err := slack.SendSlackNotification()
-	if err != nil {
-		log.Fatal(err)
-	}
-}
-
-// SendSlackNotification will post to an 'Incoming Webook' url setup in Slack Apps. It accepts
-// some text and the slack channel is saved within Slack.
-func (slack *Slack) SendSlackNotification() error {
-
-	slackBody, _ := json.Marshal(slack)
-	req, err := http.NewRequest(http.MethodPost, slack.WebhookURL, bytes.NewBuffer(slackBody))
-	if err != nil {
-		return err
-	}
-
-	req.Header.Add("Content-Type", "application/json")
-
-	client := &http.Client{Timeout: 10 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return err
-	}
-
-	buf := new(bytes.Buffer)
-	buf.ReadFrom(resp.Body)
-	if buf.String() != "ok" {
-		return errors.New("Non-ok response returned from Slack")
-	}
-	return nil
-}

tcp.go

@@ -1,76 +0,0 @@
-// Thanks go to https://github.com/Soontao/cachet-monitor/blob/master/tcp.go
-package cachet
-
-import (
-	"fmt"
-	"net"
-	"time"
-)
-
-// Investigating template
-var defaultTCPInvestigatingTpl = MessageTemplate{
-	Subject: `{{ .Monitor.Name }} - {{ .SystemName }}`,
-	Message: `{{ .Monitor.Name }} check **failed** (server time: {{ .now }})
-
-{{ .FailReason }}`,
-}
-
-// Fixed template
-var defaultTCPFixedTpl = MessageTemplate{
-	Subject: `{{ .Monitor.Name }} - {{ .SystemName }}`,
-	Message: `**Resolved** - {{ .now }}
-
-Down seconds: {{ .downSeconds }}s`,
-}
-
-// TCPMonitor struct
-type TCPMonitor struct {
-	AbstractMonitor `mapstructure:",squash"`
-	Port            string
-}
-
-// CheckTCPPortAlive func
-func CheckTCPPortAlive(ip, port string, timeout int64) (bool, error) {
-
-	conn, err := net.DialTimeout("tcp", net.JoinHostPort(ip, port), time.Duration(timeout)*time.Second)
-	if conn != nil {
-		defer conn.Close()
-	}
-	if err != nil {
-		return false, err
-	} else {
-		return true, nil
-	}
-
-}
-
-// test if it available
-func (m *TCPMonitor) test() bool {
-	if alive, e := CheckTCPPortAlive(m.Target, m.Port, int64(m.Timeout)); alive {
-		return true
-	} else {
-		m.lastFailReason = fmt.Sprintf("TCP check failed: %v", e)
-		return false
-	}
-}
-
-// Validate configuration
-func (m *TCPMonitor) Validate() []string {
-
-	// set incident temp
-	m.Template.Investigating.SetDefault(defaultTCPInvestigatingTpl)
-	m.Template.Fixed.SetDefault(defaultTCPFixedTpl)
-
-	// super.Validate()
-	errs := m.AbstractMonitor.Validate()
-
-	if m.Target == "" {
-		errs = append(errs, "Target is required")
-	}
-
-	if m.Port == "" {
-		errs = append(errs, "Port is required")
-	}
-
-	return errs
-}