165 lines
3.4 KiB
Go
165 lines
3.4 KiB
Go
package main
|
|
|
|
import "fmt"
|
|
import "net/http"
|
|
import "io"
|
|
import "io/ioutil"
|
|
import "log"
|
|
import "gopkg.in/yaml.v3"
|
|
import "time"
|
|
import "sync"
|
|
import "os/signal"
|
|
import "os"
|
|
|
|
type Check struct {
|
|
Type string `yaml:"type"`
|
|
Port int `yaml:"port"`
|
|
Uri string `yaml:"uri"`
|
|
Method string `yaml:"method"`
|
|
Timeout int `yaml:"timeout"`
|
|
Interval int `yaml:"interval"`
|
|
}
|
|
|
|
type Group struct {
|
|
Name string `yaml:"group"`
|
|
Tables []string `yaml:"tables"`
|
|
Hosts []string `yaml:"hosts"`
|
|
Check Check `yaml:"check"`
|
|
}
|
|
|
|
func main() {
|
|
log.Println("Starting")
|
|
|
|
var waitGroup sync.WaitGroup
|
|
|
|
var conf map[string]Group
|
|
yamlFile, err := ioutil.ReadFile("conf.yaml")
|
|
if err != nil {
|
|
log.Fatalf("Configuration open error #%v ", err)
|
|
}
|
|
err = yaml.Unmarshal(yamlFile, &conf)
|
|
if err != nil {
|
|
log.Fatalf("Configuration read error #%v", err)
|
|
}
|
|
|
|
stopChannel := make(chan bool)
|
|
for name, group := range conf {
|
|
log.Println("Checking group", name, group)
|
|
waitGroup.Add(1)
|
|
go checkGroup(name, group, &waitGroup, stopChannel)
|
|
}
|
|
|
|
exit := make(chan os.Signal, 1)
|
|
|
|
signal.Notify(exit, os.Interrupt)
|
|
|
|
s := <-exit
|
|
log.Println("Received signal", s)
|
|
log.Println("main closing stopChannel")
|
|
close(stopChannel)
|
|
waitGroup.Wait()
|
|
}
|
|
|
|
func checkGroup(name string, group Group, waitGroup *sync.WaitGroup, stopChannel chan bool) {
|
|
channels := make(map[string]chan int)
|
|
for _, host := range group.Hosts {
|
|
channel := make(chan int, 1)
|
|
channels[host] = channel
|
|
waitGroup.Add(1)
|
|
go checkHost(channels[host], name, host, group.Check, waitGroup, stopChannel)
|
|
}
|
|
|
|
for {
|
|
select {
|
|
case <-stopChannel:
|
|
log.Println("checkGroup", name, "stopChannel")
|
|
waitGroup.Done()
|
|
return
|
|
break
|
|
default:
|
|
for host, channel := range channels {
|
|
select {
|
|
case stop := <-stopChannel:
|
|
log.Println("checkGroup", name, "stopChannel", stop)
|
|
break
|
|
case status := <-channel:
|
|
log.Println("Status for ", host, "is", status)
|
|
default:
|
|
time.Sleep(100 * time.Millisecond)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func checkHost(status chan<- int, group string, host string, check Check, waitGroup *sync.WaitGroup, stopChannel chan bool) {
|
|
|
|
if check.Timeout == 0 {
|
|
check.Timeout = 5
|
|
}
|
|
if check.Interval == 0 {
|
|
check.Interval = 60
|
|
}
|
|
if len(check.Method) == 0 {
|
|
check.Method = "HEAD"
|
|
}
|
|
if len(check.Uri) == 0 {
|
|
check.Uri = "/"
|
|
}
|
|
if check.Port == 0 {
|
|
check.Port = 80
|
|
}
|
|
for {
|
|
select {
|
|
case <-stopChannel:
|
|
log.Println("checkHost", host, "group", group, "stopChannel")
|
|
waitGroup.Done()
|
|
return
|
|
default:
|
|
var err error
|
|
|
|
err = nil
|
|
switch check.Type {
|
|
case "http":
|
|
err = CheckHTTP(host, check)
|
|
case "tcp":
|
|
err = CheckTCP(host, check)
|
|
case "smtp":
|
|
err = CheckSMTP(host, check)
|
|
default:
|
|
err = CheckHTTP(host, check)
|
|
}
|
|
if err != nil {
|
|
status <- 1
|
|
log.Println("checkHost", host, "group", group, "error", err)
|
|
} else {
|
|
status <- 0
|
|
}
|
|
time.Sleep(time.Duration(check.Interval) * time.Second)
|
|
}
|
|
}
|
|
}
|
|
|
|
func CheckHTTP(host string, check Check) error {
|
|
|
|
client := &http.Client{
|
|
Timeout: time.Second * time.Duration(check.Timeout),
|
|
}
|
|
resp, err := client.Head(fmt.Sprintf("http://%s", host))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, _ = io.ReadAll(resp.Body)
|
|
resp.Body.Close()
|
|
|
|
return nil
|
|
}
|
|
|
|
func CheckTCP(host string, check Check) error {
|
|
return nil
|
|
}
|
|
|
|
func CheckSMTP(host string, check Check) error {
|
|
return nil
|
|
}
|