circolog/cmd/circologd/main.go

package main

import (
	"flag"
	"fmt"
	"log"
	"net"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"git.lattuga.net/boyska/circolog"
	"git.lattuga.net/boyska/circolog/formatter"
	"github.com/coreos/go-systemd/daemon"
	syslog "gopkg.in/mcuadros/go-syslog.v2"
)

var socketsToRemove []string

func cleanSocket(socket string) {
	if err := os.Remove(socket); err != nil {
		fmt.Fprintln(os.Stderr, "Error cleaning", socket, ":", err)
	}
}

func removeAtExit(socket string) {
	socketsToRemove = append(socketsToRemove, socket)
}

func main() {
	var err error
	var syslogSocket SyslogSocket
	var logFmt formatter.SyslogRFC
	logFmt.Format = syslog.Automatic
	flag.Var(&syslogSocket, "syslogd-socket", "The socket to listen to syslog addresses")
	// dumpSocketPath := flag.String("dump-socket", "/run/buffer.sock", "The socket that user will connect to in order to receive logs")
	bufsize := flag.Int("buffer-size", 1000, "Number of messages to keep")
	syslogAddr := flag.String("syslog-addr", "127.0.0.1:9514", "Address:port where to listen for syslog messages")
	queryAddr := flag.String("query-addr", "127.0.0.1:9080", "Address:port where to bind the query service")
	querySocket := flag.String("query-socket", "", "Path to a unix domain socket for the HTTP server; recommended for security reasons!")
	ctlSocket := flag.String("ctl-socket", "/tmp/circologd-ctl.sock", "Path to a unix domain socket for the control server; leave empty to disable")
	flag.Var(&logFmt, "log-fmt", "Log messages format. If not set, defaults to automatic choice. Allowed values: rfc3164, rfc5424, auto.")
	verbose := flag.Bool("verbose", false, "Print more output executing the daemon")
	debug := flag.Bool("debug", false, "Print debugging info executing the daemon")
	flag.Parse()

	interrupt := make(chan os.Signal, 1)
	signal.Notify(interrupt, syscall.SIGINT, syscall.SIGUSR1, syscall.SIGUSR2, syscall.SIGTERM)

	hub := circolog.NewHub(*bufsize)
	handler := syslog.NewChannelHandler(hub.LogMessages)
	go hub.Run()

	server := syslog.NewServer()
	server.SetFormat(logFmt.Format)
	fmt.Printf("Syslog format set to: %s\n", logFmt.String())
	server.SetHandler(handler)
	if syslogSocket.isSocketActivated {
		fmt.Printf("Binding to socket `%s` [syslog]\n", syslogSocket.String())
		if syslogSocket.Listener != nil {
			fmt.Println("(stream)")
			server.Listen(syslogSocket.Listener)
		} else {
			fmt.Println("(datagram)", syslogSocket.Conn)
			server.ListenDgram(syslogSocket.Conn)
		}
	} else {
		syslogSocketPath := syslogSocket.Path
		if syslogSocketPath != "" {
			if err = server.ListenUnixgram(syslogSocketPath); err != nil {
				fmt.Fprintln(os.Stderr, "argh", err)
				os.Exit(1)
			}
			fmt.Printf("Binding socket `%s` [syslog]\n", syslogSocketPath)
			removeAtExit(syslogSocketPath)
		} else {
			fmt.Printf("Binding address `%s` [syslog]\n", *syslogAddr)
			if err = server.ListenUDP(*syslogAddr); err != nil {
				fmt.Fprintln(os.Stderr, "argh", err)
				os.Exit(1)
			}
		}
	}
	if err = server.Boot(); err != nil {
		fmt.Fprintln(os.Stderr, "argh", err)
		os.Exit(1)
	}

	httpQueryServer := http.Server{Handler: setupHTTP(hub)}
	if *querySocket != "" {
		fmt.Printf("Binding address `%s` [http]\n", *querySocket)
		unixListener, err := net.Listen("unix", *querySocket)
		if err != nil {
			fmt.Fprintln(os.Stderr, "Error binding HTTP unix domain socket", err)
			return
		}
		removeAtExit(*querySocket)
		go func() {
			if err := httpQueryServer.Serve(unixListener); err != nil && err != http.ErrServerClosed {
				fmt.Fprintln(os.Stderr, "error binding", *querySocket, ":", err)
			}
		}()
	} else {
		httpQueryServer.Addr = *queryAddr
		fmt.Printf("Binding address `%s` [http]\n", *queryAddr)
		go func() {
			err := httpQueryServer.ListenAndServe()
			if err != nil && err != http.ErrServerClosed {
				fmt.Fprintln(os.Stderr, "error binding", *queryAddr, ":", err)
			}
		}()
	}

	httpCtlServer := http.Server{Handler: setupHTTPCtl(hub, *verbose, *debug)}
	if *ctlSocket != "" {
		fmt.Printf("Binding address `%s` [http]\n", *ctlSocket)
		unixListener, err := net.Listen("unix", *ctlSocket)
		if err != nil {
			fmt.Fprintln(os.Stderr, "Error binding HTTP unix domain socket", err)
			return
		}
		removeAtExit(*ctlSocket)
		go func() {
			if err := httpCtlServer.Serve(unixListener); err != nil && err != http.ErrServerClosed {
				fmt.Fprintln(os.Stderr, "error binding:", err)
			}
		}()
	}

	daemon.SdNotify(false, daemon.SdNotifyReady)

	var wdTick <-chan time.Time
	if watchdogTime, err := daemon.SdWatchdogEnabled(false); err == nil && watchdogTime != 0 {
		fmt.Println("systemd watchdog enabled")
		wdTick = time.Tick(watchdogTime / 2) // much less than systemd default of 30s; TODO: make it configurable
	}
	for {
		select {
		case <-wdTick:
			daemon.SdNotify(false, daemon.SdNotifyWatchdog)
		case sig := <-interrupt:
			if sig == syscall.SIGUSR1 {
				response := make(chan circolog.CommandResponse)
				hub.Commands <- circolog.HubFullCommand{Command: circolog.CommandPauseToggle, Response: response}
				resp := <-response
				if resp.Value.(bool) {
					log.Println("resumed")
				} else {
					log.Println("paused")
				}
			}
			if sig == syscall.SIGUSR2 {
				response := make(chan circolog.CommandResponse)
				hub.Commands <- circolog.HubFullCommand{Command: circolog.CommandClear, Response: response}
				resp := <-response
				if resp.Value.(bool) {
					log.Println("buffer cleaned")
				} else {
					log.Println("buffer NOT cleaned")
				}
			}
			if sig == syscall.SIGTERM || sig == syscall.SIGINT {
				log.Println("Quitting because of signal", sig)
				daemon.SdNotify(false, daemon.SdNotifyStopping)
				server.Kill()
				if err := httpQueryServer.Shutdown(nil); err != nil {
					fmt.Fprintln(os.Stderr, "Error closing http server:", err)
				}
				if err := httpCtlServer.Shutdown(nil); err != nil {
					fmt.Fprintln(os.Stderr, "Error closing control server:", err)
				}
				for _, socket := range socketsToRemove {
					cleanSocket(socket)
				}
				return
			}
		}
	}
}