httpprocprobed/main.go

/*
	httpprocwatchd provides HTTP interface to a list of process' statuses
	formatted as JSON.
	Copyright (c) 2021 Alexander "Arav" Andreev <me@arav.top>

	This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

package main

import (
	"flag"
	"fmt"
	. "httpprocwatchd/prog"
	"log"
	"os"
	"os/exec"
	"os/signal"
	"syscall"
)

// listWatchedProcesses prints a list of processes being watched.
func listWatchedProcesses(processes *[]string) {
	for _, v := range *processes {
		fmt.Printf("%s, ", v)
	}
	fmt.Println()
}

// version prints information about program.
func version() {
	fmt.Println("httpprocwatchd ver. 1.2")
	fmt.Println("Copyright (c) 2021 Alexander \"Arav\" Andreev <me@arav.top>")
	fmt.Println("License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>.")
	fmt.Println("This is free software, and you are welcome to change and redistribute it.")
	fmt.Println("There is NO WARRANTY, to the extent permitted by law.")
}

func main() {
	var oConfigPath string
	var oShowVersion bool
	var oListProcesses bool

	var oAddProcess string
	var oRemoveProcess string

	log.SetFlags(0)

	flag.StringVar(&oConfigPath, "config", "config.json", "path to configuration file")
	flag.StringVar(&oConfigPath, "c", "config.json", "path to configuration file (shorthand)")
	flag.BoolVar(&oShowVersion, "version", false, "show version")
	flag.BoolVar(&oShowVersion, "v", false, "show version (shorthand)")

	flag.BoolVar(&oListProcesses, "list", false, "list watched processes")
	flag.BoolVar(&oListProcesses, "l", false, "list watched processes (shorthand)")

	flag.StringVar(&oAddProcess, "add", "", "add process to list")
	flag.StringVar(&oAddProcess, "a", "", "add process to list (shorthand)")

	flag.StringVar(&oRemoveProcess, "remove", "", "remove process from list")
	flag.StringVar(&oRemoveProcess, "r", "", "remove process from list (shorthand)")

	flag.Parse()

	if oShowVersion {
		version()
		return
	}

	if _, err := exec.LookPath("pgrep"); err != nil {
		log.Fatalln(ErrPgrepNotFound)
	}

	conf, err := LoadConfiguration(oConfigPath)
	if err != nil {
		log.Fatalf("Cannot load configuration file: %s\n", err)
	}

	if oListProcesses {
		listWatchedProcesses(&conf.Processes)
		return
	}

	if oAddProcess != "" {
		err := AddProcessToList(oAddProcess, conf, oConfigPath)
		if err != nil {
			log.Fatalf("Cannot add process: %s\n", err)
		}
	}

	if oRemoveProcess != "" {
		err := RemoveProcessFromList(oRemoveProcess, conf, oConfigPath)
		if err != nil {
			log.Fatalf("Cannot remove process: %s\n", err)
		}
	}

	// If we modified a list then let's look for a running program and
	// send SIGHUP for it to reload a list.
	if oAddProcess != "" || oRemoveProcess != "" {
		isup, pid, _ := IsProcessUp("httpprocwatchd")
		if isup && pid != nil && len(pid) > 1 {
			var trgt_pid int
			if pid[0] == os.Getpid() {
				trgt_pid = pid[1]
			} else {
				trgt_pid = pid[0]
			}
			proc, err := os.FindProcess(trgt_pid)
			if err == nil {
				proc.Signal(syscall.SIGHUP)
			}
		}
		return
	}

	srv := CreateAndStartHTTPServer(conf)

	syssignal := make(chan os.Signal, 1)
	signal.Notify(syssignal, os.Interrupt, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

	log.Printf("httpprocwatchd is running on \"%s\".", conf.ListenAddress)

	for {
		switch <-syssignal {
		case os.Interrupt:
			fallthrough
		case syscall.SIGINT | syscall.SIGTERM:
			log.Println("Shutting down... ")
			ShutdownHTTPServer(srv)
			log.Println("Server shutted down.")
			os.Exit(0)
		case syscall.SIGHUP:
			newconf, err := LoadConfiguration(oConfigPath)
			if err != nil {
				log.Fatalf("Failed to reload configuration: %s\n", err)
			}
			conf.Processes = newconf.Processes
			log.Println("Successfully reloaded a list of watched processes.")
		}
	}
}