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", "", "Address:port where to bind the query service") querySocket := flag.String("query-socket", "/tmp/circologd-query.sock", "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 *queryAddr == "" { 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 } } } }