Revert "fix(logger): properly parse incoming syslog messages"

Author: Matthew Fisher

logger/Dockerfile

@@ -1,13 +1,6 @@
 FROM deis/base:latest
 MAINTAINER OpDemand <info@opdemand.com>
 
-# install go dependencies
-RUN apt-get update && apt-get install -yq \
-    git \
-    bzr \
-    mercurial \
-    --no-install-recommends
-
 # install go runtime
 RUN wget -qO- https://storage.googleapis.com/golang/go1.3.1.linux-amd64.tar.gz | tar -C /usr/local -xz
 
@@ -20,13 +13,12 @@ ENV PATH /usr/local/bin:/usr/bin:/bin:/sbin:/usr/local/go/bin
 RUN mkdir -p /var/log/deis
 
 # prepare execution environment
-WORKDIR /go/src/github.com/deis/deis/logger
+WORKDIR /app
 CMD ["/app/bin/boot"]
 EXPOSE 514
 
-ADD bin/ /app/bin/
+ADD . /app
 ADD . /go/src/github.com/deis/deis/logger
 
-# install dependencies
-RUN go get ./syslog
-RUN go install -v ./syslogd
+# compile the binary
+RUN cd /go/src/github.com/deis/deis/logger/syslogd && go install -v .

logger/Makefile

@@ -42,7 +42,7 @@ test-style:
 	-golint .
 
 test-unit: test-style
-	GOPATH=$(CURDIR)/../tests/_vendor:$(GOPATH) go test -v -cover ./syslog
+	go test -v -cover ./syslog
 
 test-functional:
 	GOPATH=$(CURDIR)/../tests/_vendor:$(GOPATH) go test -v -timeout 20m ./tests/...

logger/syslog/filehandler.go

@@ -81,6 +81,11 @@ func (h *FileHandler) checkErr(err error) bool {
 	if err == nil {
 		return false
 	}
+	if h.l == nil {
+		log.Print(h.filename, ": ", err)
+	} else {
+		h.l.Print(h.filename, ": ", err)
+	}
 	return true
 }
 

logger/syslog/filehandler_test.go

@@ -29,7 +29,7 @@ func TestSetLogger(t *testing.T) {
 
 func TestHandle(t *testing.T) {
 	fh := NewFileHandler("/tmp/test", 1, func(m *Message) bool { return true }, true)
-	handle := fh.Handle(&Message{time.Now(), 0, time.Now(), "localhost", "test", "message"})
+	handle := fh.Handle(&Message{time.Now(), nil, 0, 0, time.Now(), "localhost", "test", "message", "", ""})
 	if handle == nil {
 		t.Errorf("expected a handle, got nil")
 	}

logger/syslog/message.go

@@ -2,27 +2,46 @@ package syslog
 
 import (
 	"fmt"
-	"log/syslog"
+	"net"
 	"time"
 )
 
 // Message defines an RFC 3164 syslog message.
 type Message struct {
-	Time      time.Time
-	Priority  syslog.Priority
-	Timestamp time.Time
-	Hostname  string
-	Tag       string
-	Content   string
+	Time      time.Time // time the message was logged
+	Source    net.Addr  // source address of the log message
+	Facility            // facility tag (see type Facility)
+	Severity            // severity tag (see type Severity)
+	Timestamp time.Time // optional
+	Hostname  string    // optional
+	Tag       string    // message tag as defined in RFC 3164
+	Content   string    // message content as defined in RFC 3164
+	Tag1      string    // alternate message tag (white rune as separator)
+	Content1  string    // alternate message content (white rune as separator)
+}
+
+// NetSrc only network part of Source as string (IP for UDP or Name for UDS)
+func (m *Message) NetSrc() string {
+	switch a := m.Source.(type) {
+	case *net.UDPAddr:
+		return a.IP.String()
+	case *net.UnixAddr:
+		return a.Name
+	case *net.TCPAddr:
+		return a.IP.String()
+	}
+	// Unknown type
+	return m.Source.String()
 }
 
 // String returns the Message in a string format. This satisfies the fmt.Stringer
 // interface.
 func (m *Message) String() string {
 	timeLayout := "2006-01-02 15:04:05"
 	return fmt.Sprintf(
-		"%s %s: %s",
+		"%s %s %s%s",
 		m.Time.Format(timeLayout),
+		m.Hostname,
 		m.Tag,
 		m.Content,
 	)

logger/syslog/message_test.go

@@ -1,15 +1,79 @@
 package syslog
 
 import (
+	"net"
 	"testing"
 	"time"
 )
 
+func TestMessageNetSrc(t *testing.T) {
+	tcpAddress, err := net.ResolveTCPAddr("tcp", "localhost:1234")
+
+	if err != nil {
+		t.Error("could not resolve TCP address")
+	}
+
+	m := &Message{time.Now(), tcpAddress, 0, 0, time.Now(), "", "", "", "", ""}
+	if m.NetSrc() != "127.0.0.1" {
+		t.Errorf("expected 127.0.0.1, got %s", m.NetSrc())
+	}
+
+	udpAddress, err := net.ResolveUDPAddr("udp", "localhost:1234")
+
+	if err != nil {
+		t.Error("could not resolve UDP address")
+	}
+
+	m.Source = udpAddress
+	if m.NetSrc() != "127.0.0.1" {
+		t.Errorf("expected 127.0.0.1, got %s", m.NetSrc())
+	}
+
+	unixAddress, err := net.ResolveUnixAddr("unix", "/tmp/str")
+
+	if err != nil {
+		t.Error("could not resolve unix address")
+	}
+
+	m.Source = unixAddress
+	if m.NetSrc() != "/tmp/str" {
+		t.Errorf("expected /tmp/str, got %s", m.NetSrc())
+	}
+
+	unknownAddress, err := net.ResolveIPAddr("ip4", "localhost")
+
+	if err != nil {
+		t.Error("could not resolve unknown address")
+	}
+
+	m.Source = unknownAddress
+	if m.NetSrc() != "127.0.0.1" {
+		t.Errorf("expected 127.0.0.1, got %s", m.NetSrc())
+	}
+}
+
 func TestMessageFormat(t *testing.T) {
-	m := &Message{time.Now(), 34, time.Now(), "localhost", "test", "hello world"}
+	tcpAddress, err := net.ResolveTCPAddr("tcp", "localhost:1234")
+
+	if err != nil {
+		t.Errorf("could not resolve TCP address")
+	}
+
+	m := &Message{
+		time.Now(),
+		tcpAddress,
+		0,
+		0,
+		time.Now(),
+		"localhost",
+		"TEST",
+		"hello world",
+		"",
+		"",
+	}
 
 	timeLayout := "2006-01-02 15:04:05"
-	expectedOutput := m.Time.Format(timeLayout) + " test: hello world"
+	expectedOutput := m.Time.Format(timeLayout) + " localhost TESThello world"
 	if m.String() != expectedOutput {
 		t.Errorf("expected '" + expectedOutput + "', got '" + m.String() + "'.")
 	}

logger/syslog/priority.go

@@ -0,0 +1,110 @@
+package syslog
+
+// Facility represents a message source as defined by RFC 3164.
+type Facility byte
+
+// The following is a list of Facilities as defined by RFC 3164.
+const (
+	Kern     Facility = iota // kernel messages
+	User                     // user-level messages
+	Mail                     // mail system
+	Daemon                   // system daemons
+	Auth                     // security/authorization messages
+	Syslog                   // messages internal to syslogd
+	Lpr                      // line printer subsystem
+	News                     // newtork news subsystem
+	Uucp                     // UUCP subsystem
+	Cron                     // cron messages
+	Authpriv                 // security/authorization messages
+	System0                  // historically FTP daemon
+	System1                  // historically NTP subsystem
+	System2                  // historically log audit
+	System3                  // historically log alert
+	System4                  // historically clock daemon, some operating systems use this for cron
+	Local0                   // local use 0
+	Local1                   // local use 1
+	Local2                   // local use 2
+	Local3                   // local use 3
+	Local4                   // local use 4
+	Local5                   // local use 5
+	Local6                   // local use 6
+	Local7                   // local use 7
+)
+
+var facToStr = [...]string{
+	"kern",
+	"user",
+	"mail",
+	"daemon",
+	"auth",
+	"syslog",
+	"lpr",
+	"news",
+	"uucp",
+	"cron",
+	"authpriv",
+	"system0",
+	"system1",
+	"system2",
+	"system3",
+	"system4",
+	"local0",
+	"local1",
+	"local2",
+	"local3",
+	"local4",
+	"local5",
+	"local6",
+	"local7",
+}
+
+// String returns a string representation of the Facility. This satisfies the
+// fmt.Stringer interface.
+func (f Facility) String() string {
+	if f > Local7 {
+		return "unknown"
+	}
+	return facToStr[f]
+}
+
+// Severity represents a level of messsage importance.
+type Severity byte
+
+const (
+	// Emerg - system is unusable
+	Emerg Severity = iota
+	// Alert - immediate action required
+	Alert
+	// Crit - critical conditions
+	Crit
+	// Err - error conditions
+	Err
+	// Warning - warning conditions
+	Warning
+	// Notice - normal but significant condition
+	Notice
+	// Info - information message
+	Info
+	// Debug - debug-level message
+	Debug
+)
+
+var sevToStr = [...]string{
+	"emerg",
+	"alert",
+	"crit",
+	"err",
+	"waining",
+	"notice",
+	"info",
+	"debug",
+}
+
+// String returns a string representation of the Severity. This satisfies the
+// fmt.Stringer interface.
+func (s Severity) String() string {
+	if s > Debug {
+		return "unknown"
+	}
+	return sevToStr[s]
+}

logger/syslog/priority_test.go

@@ -0,0 +1,27 @@
+package syslog
+
+import (
+	"testing"
+)
+
+func TestFacilityToString(t *testing.T) {
+	var fac Facility = 100
+	if fac.String() != "unknown" {
+		t.Errorf("facility != unknown; got %s", fac.String())
+	}
+	fac = 20
+	if fac.String() != "local4" {
+		t.Errorf("facility != local4; got %s", fac.String())
+	}
+}
+
+func TestSeverityToString(t *testing.T) {
+	var sev Severity = 100
+	if sev.String() != "unknown" {
+		t.Errorf("severity != unknown; got %s", sev.String())
+	}
+	sev = 5
+	if sev.String() != "notice" {
+		t.Errorf("severity != local4; got %s", sev.String())
+	}
+}