.gitignore

@@ -1,2 +0,0 @@
-.*.vim
-/build

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "vendor/gopkg.in/mcuadros/go-syslog.v2"]
-	path = vendor/gopkg.in/mcuadros/go-syslog.v2
-	url = https://github.com/boyska/go-syslog

cmd/circolog-tail/main.go

@@ -54,8 +54,8 @@ func (b *BoolAuto) Set(s string) error {
 }
 
 func main() {
-	queryAddr := flag.String("addr", "", "http service address")
-	querySocket := flag.String("socket", "/tmp/circologd-query.sock", "Path to a unix domain socket for the HTTP server")
+	addr := flag.String("addr", "localhost:9080", "http service address")
+	querySocket := flag.String("socket", "", "Path to a unix domain socket for the HTTP server")
 	backlogLimit := flag.Int("n", -1, "Limit the backlog length, defaults to no limit (-1)")
 	var format formatter.Format
 	format = formatter.FormatSyslog
@@ -75,7 +75,7 @@ func main() {
 	signal.Notify(interrupt, os.Interrupt)
 	var d *websocket.Dialer
 	u := url.URL{Scheme: "ws",
-		Host: *queryAddr, // ignored in case of -socket; see the Dialer below
+		Host: *addr, // ignored in case of -socket; see the Dialer below
 		Path: "/ws",
 	}
 	q := u.Query()
@@ -84,7 +84,7 @@ func main() {
 		q.Set("l", strconv.Itoa(*backlogLimit))
 	}
 	u.RawQuery = q.Encode()
-	if *queryAddr == "" {
+	if *querySocket != "" {
 		d = &websocket.Dialer{
 			NetDial: func(network, addr string) (net.Conn, error) {
 				return net.Dial("unix", *querySocket)
@@ -95,7 +95,7 @@ func main() {
 		log.Printf("connecting to %s", *querySocket)
 	} else {
 		d = websocket.DefaultDialer
-		log.Printf("connecting to %s", *queryAddr)
+		log.Printf("connecting to %s", *addr)
 	}
 
 	c, _, err := d.Dial(u.String(), nil)
@@ -149,7 +149,7 @@ func main() {
 			select {
 			case <-done:
 				log.Println("Successfully close")
-			case <-time.After(5 * time.Second):
+			case <-time.After(1 * time.Second):
 				log.Println("Forced close")
 			}
 			return

cmd/circologd/activation.go

@@ -1,39 +0,0 @@
-package main
-
-import (
-	"net"
-
-	"github.com/coreos/go-systemd/activation"
-)
-
-func Listeners() ([]net.Listener, error) {
-	files := activation.Files(false)
-	listeners := make([]net.Listener, len(files))
-
-	for i, f := range files {
-		if pc, err := net.FileListener(f); err == nil {
-			listeners[i] = pc
-			f.Close()
-		}
-	}
-	return listeners, nil
-}
-
-// PacketConns returns a slice containing a net.PacketConn for each matching socket type
-// passed to this process.
-//
-// The order of the file descriptors is preserved in the returned slice.
-// Nil values are used to fill any gaps. For example if systemd were to return file descriptors
-// corresponding with "udp, tcp, udp", then the slice would contain {net.PacketConn, nil, net.PacketConn}
-func PacketConns() ([]net.PacketConn, error) {
-	files := activation.Files(false)
-	conns := make([]net.PacketConn, len(files))
-
-	for i, f := range files {
-		if pc, err := net.FilePacketConn(f); err == nil {
-			conns[i] = pc
-			f.Close()
-		}
-	}
-	return conns, nil
-}

cmd/circologd/http_log.go

@@ -153,15 +153,6 @@ func getWSHandler(hub circolog.Hub) http.HandlerFunc {
 				hub.Unregister <- c
 				conn.Close()
 			}()
-			go func() {
-				for {
-					_, _, err := conn.ReadMessage()
-					if err != nil {
-						conn.Close()
-						return
-					}
-				}
-			}()
 			for {
 				select {
 				case message, ok := <-c.Messages:

cmd/circologd/main.go

@@ -12,36 +12,25 @@ import (
 	"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")
+	syslogSocketPath := flag.String("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!")
+	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()
@@ -54,33 +43,20 @@ func main() {
 	go hub.Run()
 
 	server := syslog.NewServer()
-	server.SetFormat(logFmt.Format)
-	fmt.Printf("Syslog format set to: %s\n", logFmt.String())
+	server.SetFormat(syslog.Automatic)
 	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)
+	if *syslogSocketPath != "" {
+		if err = server.ListenUnixgram(*syslogSocketPath); err != nil {
+			fmt.Fprintln(os.Stderr, "argh", err)
+			os.Exit(1)
 		}
+		defer cleanSocket(*syslogSocketPath)
+		fmt.Printf("Binding socket `%s` [syslog]\n", *syslogSocketPath)
 	} 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)
-			}
+		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 {
@@ -89,14 +65,14 @@ func main() {
 	}
 
 	httpQueryServer := http.Server{Handler: setupHTTP(hub)}
-	if *queryAddr == "" {
+	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)
+		defer cleanSocket(*querySocket)
 		go func() {
 			if err := httpQueryServer.Serve(unixListener); err != nil && err != http.ErrServerClosed {
 				fmt.Fprintln(os.Stderr, "error binding", *querySocket, ":", err)
@@ -121,7 +97,7 @@ func main() {
 			fmt.Fprintln(os.Stderr, "Error binding HTTP unix domain socket", err)
 			return
 		}
-		removeAtExit(*ctlSocket)
+		defer cleanSocket(*ctlSocket)
 		go func() {
 			if err := httpCtlServer.Serve(unixListener); err != nil && err != http.ErrServerClosed {
 				fmt.Fprintln(os.Stderr, "error binding:", err)
@@ -171,9 +147,6 @@ func main() {
 				if err := httpCtlServer.Shutdown(nil); err != nil {
 					fmt.Fprintln(os.Stderr, "Error closing control server:", err)
 				}
-				for _, socket := range socketsToRemove {
-					cleanSocket(socket)
-				}
 				return
 			}
 		}

cmd/circologd/sockets.go

@@ -1,50 +0,0 @@
-package main
-
-import (
-	"net"
-)
-
-// SyslogSocket is a struct eventually containing a net.Listener
-// ready with messages, and a Path in case the Listener is not present.
-type SyslogSocket struct {
-	Listener          net.Listener
-	Conn              net.PacketConn
-	Path              string
-	isSocketActivated bool
-}
-
-// Set from command-line
-func (s *SyslogSocket) Set(v string) error {
-	err := s.getActivationSocket()
-	if err == nil && (s.Conn != nil || s.Listener != nil) {
-		s.isSocketActivated = true
-	}
-	if !s.isSocketActivated {
-		s.Path = v
-	}
-	return nil
-}
-
-func (s *SyslogSocket) String() string {
-	if s.isSocketActivated {
-		return "systemd-provided"
-	}
-	return s.Path
-}
-
-func (s *SyslogSocket) getActivationSocket() error {
-	conns, err := PacketConns()
-	if err == nil && len(conns) > 0 && conns[0] != nil {
-		s.Conn = conns[0]
-		return nil
-	}
-	listeners, err := Listeners()
-	if err != nil {
-		return err
-	}
-	if len(listeners) == 0 {
-		return nil
-	}
-	s.Listener = listeners[0]
-	return nil
-}

data/data_test.go

@@ -7,36 +7,35 @@ import (
 	"gopkg.in/mcuadros/go-syslog.v2/format"
 )
 
-var timeNow = time.Now()
-
-var returnValues = map[string]interface{}{
-	"prog":   "test_app",
-	"client": "test_client",
-	"host":   "my_machine",
-	"msg":    "test message",
-	"sev":    3,
-	"time":   timeNow,
+var mandatoryKeys = []string{
+	"prog",
+	"client",
+	"host",
+	"msg",
+	"sev",
+	"time",
+	"proc_id",
 }
 
 var msgRFC5424 = format.LogParts{
 	"version":   1,
-	"app_name":  returnValues["prog"],
-	"client":    returnValues["client"],
-	"hostname":  returnValues["host"],
+	"app_name":  "test_app",
+	"client":    "test_client",
+	"hostname":  "my_machine",
 	"proc_id":   "spam_process",
-	"message":   returnValues["msg"],
+	"message":   "test message",
 	"facility":  "hell",
-	"timestamp": returnValues["time"],
-	"severity":  returnValues["sev"],
+	"timestamp": time.Now(),
+	"severity":  3,
 }
 
 var msgRFC3164 = format.LogParts{
-	"tag":       returnValues["prog"],
-	"client":    returnValues["client"],
-	"hostname":  returnValues["host"],
-	"content":   returnValues["msg"],
-	"severity":  returnValues["sev"],
-	"timestamp": returnValues["time"],
+	"tag":       "test_tag",
+	"client":    "test_client",
+	"hostname":  "my_machine",
+	"content":   "test message",
+	"severity":  3,
+	"timestamp": time.Now(),
 	"proc_id":   "spam_process",
 }
 
@@ -49,9 +48,9 @@ func TestLogEntryToMessage(t *testing.T) {
 	for _, msg := range testMessages {
 		parsedMsg := LogEntryToMessage(msg)
 
-		for key, value := range returnValues {
-			if data, ok := parsedMsg[key]; !ok || data != value {
-				t.Errorf("Missing/wrong key: %s\nmsg: %s\nparsed msg: %s\n", key, value, data)
+		for _, key := range mandatoryKeys {
+			if data, ok := parsedMsg[key]; !ok || data == nil {
+				t.Errorf("Missing key: %s\nmsg: %s\nparsed msg: %s\n", key, msg, parsedMsg)
 			}
 		}
 	}

docs/docs/install.md

@@ -27,41 +27,6 @@ endless, we tried to document some common setups.
 
 #### Use Case: circologd receiving messages from syslog-ng
 
-Put this in `/etc/syslog-ng/conf.d/circolog.conf`
-
-```
-destination d_circolog {
-	unix-dgram("/run/circolog/syslog.sock"
-			flags(syslog-protocol)
-		   );
-};
-log { source(s_src); destination(d_circolog); };
-```
-
-This doesn't tell syslog-ng not to log to disk.
-
-Change `/etc/syslog-ng.conf` according to your need.
-
-#### Use Case: circologd receiving messages from rsyslog
-
-rsyslogd can easily be configured to send every message to circolog:
-
-```
-$ModLoad omuxsock
-$OMUxSockSocket /tmp/circolog.sock
-*.* :omuxsock:
-```
-
-If you want to force messages of level `debug` and `info` not to be logged to disk, you can put this snippet
-at the **top** of the rules
-
-```
-$ModLoad omuxsock
-$OMUxSockSocket /tmp/circolog.sock
-*.* :omuxsock:
-*.=debug;*.=info stop
-```
-
 #### Use Case: circologd receiving messages from journald
 
 [TODO: il codice va ancora scritto: bisogna bindare /run/systemd/journal/syslog

docs/docs/systemd.md

@@ -69,26 +69,4 @@ Here is a working unit for this:
 ### journald with socket activation
 
 To run circologd as non-root, while listening on a root-owned socket (`/run/systemd/journal/syslog`) use
-socket activation. Create a unit in `/etc/systemd/system/circolog.service`:
-
-    [Unit]
-    Description=In-memory logging
-
-    [Service]
-    User=nobody
-    Group=nogroup
-    ExecStart=/usr/local/sbin/circologd -syslogd-socket "" -buffer-size 2000 -query-socket /run/circolog/query.sock
-
-    [Install]
-    WantedBy=multi-user.target
-
-Then symlink the `syslog.service` unit to the newly created one:
-
-    ln -sf /etc/systemd/system/circolog.service /etc/systemd/system/syslog.service
-
-and restart the service:
-
-    systemctl daemon-reload
-    systemctl restart syslog.service
-
-Now circolog is activated and receives messages from `journald`.
+socket activation

docs/mkdocs.yml

@@ -4,6 +4,5 @@ nav:
     - Install: install.md
     - Queries: query.md
     - Hacking: hacking.md
-    - Systemd: systemd.md
 repo_url: https://git.lattuga.net/boyska/circolog
 repo_name: 'Repository'

formatter/rfc.go

@@ -1,49 +0,0 @@
-package formatter
-
-import (
-	"errors"
-
-	syslog "gopkg.in/mcuadros/go-syslog.v2"
-	"gopkg.in/mcuadros/go-syslog.v2/format"
-)
-
-// SyslogRFC is the formatter that the server should use
-type SyslogRFC struct{ format.Format }
-
-func (rfc *SyslogRFC) Set(v string) error {
-	newval, err := parseRFCValue(v)
-	if err != nil {
-		return err
-	}
-	rfc.Format = newval
-	return nil
-}
-
-func (rfc *SyslogRFC) String() string {
-	switch {
-	case rfc.Format == syslog.Automatic:
-		return "auto"
-	case rfc.Format == syslog.RFC3164:
-		return "rfc3164"
-	case rfc.Format == syslog.RFC5424:
-		return "rfc5424"
-	}
-	return ""
-}
-
-func parseRFCValue(v string) (format.Format, error) {
-	switch {
-	case v == "rfc3164":
-		return syslog.RFC3164, nil
-	case v == "rfc5424":
-		return syslog.RFC5424, nil
-	case v == "auto":
-		return syslog.Automatic, nil
-	default:
-		return nil, ErrRFCNotSupported
-	}
-}
-
-// ErrRFCNotSupported is raised if the supplied rfc string is
-// not recognized.
-var ErrRFCNotSupported = errors.New("RFC not known")

release.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-set -u
-
-for goosarch in $(go tool dist list | grep -vw -e aix -e js/wasm -e plan9 -e solaris -e android -e nacl)
-do
-    mkdir -p "build/$goosarch"
-    goos=$(cut -d/ -f 1 <<<$goosarch)
-    goarch=$(cut -d/ -f 2 <<<$goosarch)
-    for cmd in cmd/*; do
-        GOOS=${goos} GOARCH=${goarch} go build -o "build/$goos/$goarch/$(basename $cmd)" ./$cmd
-    done
-done
-
-find build/ -type f|cut -d/ -f 1-3|uniq|while read -r dir; do
-    find $dir/ -type f -executable | xargs sha1sum > $dir/SHA1SUMS.txt
-    # TODO: touch to last commit date maybe
-    find build -exec touch -d @1234567890 {} \;
-    zip -q -X -j -r "circolog-$(git describe --tags --always)-$(cut -d/ -f 2-3 <<<"$dir"|tr / -)" "$dir"
-done

vendor/gopkg.in/mcuadros/go-syslog.v2

@@ -1 +0,0 @@
-Subproject commit 166aad3f993ce4a67bf486e62d637c834c8a8fe6