Exemplo n.º 1
0
//Init ializes the configuration
func Init(configfile string) {
	var configContent []byte
	var tempContent []byte
	var err error

	tempContent, err = ioutil.ReadFile(configfile)
	if err == nil {
		configContent = tempContent
	} else {
		tempContent, err = ioutil.ReadFile("config.yaml")
		if err == nil {
			configContent = tempContent
		} else {
			panic("Not found in folder! Panic!")
		}
	}

	m := Configuration{}
	err = yaml.Unmarshal(configContent, &m)

	errUnmarshal := yaml.Unmarshal(configContent, &C)

	if errUnmarshal != nil {
		log.Error("Cannot load configuration! Make sure the configuration file matches your version of monitoring.")
		panic(errUnmarshal.Error())
	}

	name, err := os.Hostname()
	if err != nil {
		panic(err)
	} else {
		C.Hostname = name
	}

	if len(C.Actions.Telegram.Target) > 2 {
		log.Notice("Telegram enabled.")
		C.Actions.Telegram.Enabled = true
	} else {
		log.Error("Telegram is disabled.")
	}

	IsLoaded = true
	log.Notice("Services: ", C.Paths.Services)
	log.Notice("Checks: ", C.Paths.Checks)
}
Exemplo n.º 2
0
func init() {
	log.Notice("Initializing..")
	flag.BoolVar(&debug, "debug", false, "Enable debugging")
	flag.BoolVar(&testConfig, "test", false, "Test configuration instead of running")
	flag.BoolVar(&apiEnabled, "api", true, "Enable Web API")
	flag.BoolVar(&autoStart, "autostart", true, "Autostart service checking")
	flag.BoolVar(&noActionHandling, "no-action-handling", false, "Do not do anything when services are down")
	flag.StringVar(&config, "config", "/etc/monitoring/config.yaml", "Path to config file")
	flag.Parse()
}
Exemplo n.º 3
0
func readServiceFiles(searchDir string) []model.Service {
	findingList := []string{}
	var allServices []model.Service
	err := filepath.Walk(searchDir, func(path string, f os.FileInfo, err error) error {
		findingList = append(findingList, path)
		if strings.HasSuffix(path, ".yaml") || strings.HasSuffix(path, ".yml") {
			log.Notice("Loaded ", path)
			allServices = append(allServices, servicesBuilder(path)...)
		}
		return nil
	})
	if err != nil {
		panic(err)
	}
	return allServices
}
Exemplo n.º 4
0
//Handle dispatches the correct action handling
func Handle(service model.Service) {
	if configuration.C.NoActionHandling == false {
		if service.Acknowledged != true {
			switch service.Action.Name {
			case "telegram":
				handleTelegram(service)
			case "none":
				log.Notice("Skipping action for ", service.Identifier)
			default:
				handleTelegram(service)
			}

		}
	} else {
		fmt.Println("Silenced.")
	}
}
Exemplo n.º 5
0
//Setup initializes routers, login and services.
func Setup() {

	if configuration.Debug {
		gin.SetMode(gin.DebugMode)
	} else {
		gin.SetMode(gin.ReleaseMode)
	}

	r := gin.New()

	r.Use(cors.Middleware(cors.Config{
		Origins:         "*",
		Methods:         "GET, PUT, POST, DELETE",
		RequestHeaders:  "Origin, Authorization, Content-Type",
		ExposedHeaders:  "",
		MaxAge:          50 * time.Second,
		Credentials:     true,
		ValidateHeaders: false,
	}))

	r.SetHTMLTemplate(pages.Template)
	r.GET("/", pages.Homepage)

	serviceGroup := r.Group("/api/", AuthRequired())
	{
		serviceGroup.GET("/services/:identifier/update", services.Update)
		serviceGroup.GET("/services/:identifier/reschedule", services.Reschedule)
		serviceGroup.GET("/services/:identifier", services.Show)
		serviceGroup.GET("/services", services.List)
	}

	systemAPI := r.Group("/api/system/", AuthRequired())
	{
		systemAPI.GET("/start", system.Start)
		systemAPI.GET("/stop", system.Stop)
		systemAPI.GET("/reload", system.Reload)
	}

	log.Notice("Starting webserver..")
	log.Info("API listening on http://" + configuration.C.API.Address)

	r.Run(configuration.C.API.Address)
}
Exemplo n.º 6
0
//Start daemon's checking
func Start() {
	log.Notice("Starting..")
	IsActive = true
}
Exemplo n.º 7
0
//Execute a command by specifying executable and arguments, returns statuscode and output summary
func Execute(timeout int, cmdName string, cmdArgs ...string) (status int, output string) {
	// TODO: Check if cmdName file exists
	cmd := exec.Command(cmdName, cmdArgs...)

	cmdOutput := &bytes.Buffer{}
	errOutput := &bytes.Buffer{}

	fail := false
	killed := false

	cmd.Stdout = cmdOutput
	cmd.Stderr = errOutput

	var waitStatus syscall.WaitStatus

	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
	cmd.Start()

	timer := time.AfterFunc(time.Duration(timeout+1)*time.Second, func() {
		if cmd.Process != nil {
			pgid, err := syscall.Getpgid(cmd.Process.Pid)
			if err == nil {
				syscall.Kill(-pgid, 9) // note the minus sign
				log.Notice("Killed PID", pgid, "because of timeout of ", timeout, "seconds while running", cmdName)
				killed = true
			}
		} else {
			log.Error("Tried to kill but it didn't exist (anymore).", cmdName, cmdArgs)
		}
	})

	if err := cmd.Wait(); err != nil {
		if err != nil {
			fail = true
		}
		if exitError, ok := err.(*exec.ExitError); ok {
			waitStatus = exitError.Sys().(syscall.WaitStatus)
		}
	} else {
		// Success
		waitStatus = cmd.ProcessState.Sys().(syscall.WaitStatus)
	}

	if killed {
		return killedStatus()
	}

	timer.Stop()

	outputString := string(cmdOutput.Bytes())
	shortOutputStrings := strings.Split(outputString, "\n")
	statusCode := waitStatus.ExitStatus()

	if waitStatus.ExitStatus() == -1 {
		return killedStatus()
	}

	if waitStatus.ExitStatus() == 0 && fail {
		statusCode = 420
	}

	return statusCode, shortOutputStrings[0]
}