Introduce logger

- go routine safe stdout/stderr
- move config to ./etc/
- cleanup

Author: mblaschke

Dockerfile.develop

@@ -20,6 +20,6 @@ WORKDIR /go/src/go-syslogd
 # Build and install
 RUN go build \
     && cp -a go-syslogd /usr/local/bin \
-    && cp /go/src/go-syslogd/go-syslog.yml /etc/go-syslog.yml
+    && cp /go/src/go-syslogd/etc/go-syslog.yml /etc/go-syslog.yml
 
 CMD ["./go-syslogd"]

go-syslog.yml renamed to etc/go-syslog.yml

@@ -1,23 +1,15 @@
 package main
 
 import (
-    "fmt"
-    "os"
-    "strings"
+    "log"
 )
 
-
-// Log error object as message
-func logError(err error) {
-    fmt.Fprintln(os.Stderr, fmt.Sprintf("Error: %s\n", err))
+type SyslogLogger struct {
+    *log.Logger
 }
 
-// Log error object as message
-func logFatalErrorAndExit(err error, exitCode int) {
-    cmdline := fmt.Sprintf("%s %s", argparser.Command.Name, strings.Join(os.Args[1:], " "))
-
-    fmt.Fprintln(os.Stderr, fmt.Sprintf("Error: %s", err))
-    fmt.Fprintln(os.Stderr, fmt.Sprintf("Command: %s", cmdline))
-
-    os.Exit(exitCode)
+func (SyslogLogger SyslogLogger) Verbose(message string) {
+    if opts.Verbose {
+        SyslogLogger.Println(message)
+    }
 }

log.go

@@ -6,19 +6,23 @@ import (
     "io/ioutil"
     "sync"
     "strings"
+    "log"
     flags "github.com/jessevdk/go-flags"
     yaml "gopkg.in/yaml.v2"
 )
 
 const (
-    Name    = "go-syslogd"
-    Author  = "webdevops.io"
-    Version = "0.1.0"
+    Name      = "go-syslogd"
+    Author    = "webdevops.io"
+    Version   = "0.1.0"
+    LogPrefix = ""
 )
 
 var (
     argparser *flags.Parser
     configuration ConfigurationDefinition
+    LoggerStdout SyslogLogger
+    LoggerStderr SyslogLogger
 )
 
 type ConfigurationDefinition struct {
@@ -28,6 +32,7 @@ type ConfigurationDefinition struct {
 
 var opts struct {
     Configuration           string   `short:"c"  long:"configuration"                 description:"Configuration file (yml)" default:"/etc/go-syslog.yml"`
+    Verbose                 bool     `short:"v"  long:"verbose"                       description:"verbose mode"`
     ShowVersion             bool     `short:"V"  long:"version"                       description:"show version and exit"`
     ShowOnlyVersion         bool     `           long:"dumpversion"                   description:"show only version number and exit"`
 }
@@ -76,20 +81,25 @@ func parseConfiguration() {
     }
 }
 
-func printMessage(dest *os.File, msg string) {
-    fmt.Fprint(dest, msg)
-}
-
 // Prints help
 func printHelp() {
     argparser.WriteHelp(os.Stdout)
     os.Exit(1)
 }
 
+// Init system loggers
+func initLogger() {
+    LoggerStdout = SyslogLogger{log.New(os.Stdout, LogPrefix, 0)}
+    LoggerStderr = SyslogLogger{log.New(os.Stderr, LogPrefix, 0)}
+}
+
 // Main function
 func main() {
     var wg sync.WaitGroup
 
+    // init logger
+    initLogger()
+
     // init argument parser
     argparser = flags.NewParser(&opts, flags.Default)
     args, err := argparser.Parse()
@@ -108,7 +118,7 @@ func main() {
     // parse yml configuration
     parseConfiguration()
 
-    fmt.Println(fmt.Sprintf("Starting %s version %s", Name, Version))
+    LoggerStdout.Println(fmt.Sprintf("Starting %s version %s", Name, Version))
 
     // init pipes
     for _, pipe := range configuration.Pipes {

main.go

@@ -17,23 +17,16 @@ type Pipe struct {
 
 // Create and handle log data from pipe
 func handlePipe(pipe Pipe) {
-    var pipeOutput *os.File
     pipeExists := false
 
+    LoggerStdout.Verbose(fmt.Sprintf(" -> Starting named pipe (%s)", pipe.Path))
+
     // get pipe permissions
     if pipe.Perms == "" {
         pipe.Perms = "0600"
     }
     pipePerms, _ := strconv.ParseUint(pipe.Perms, 8, 32)
 
-    // get pipe output destination
-    switch pipe.Type {
-    case "stdout":
-        pipeOutput = os.Stdout
-    case "stderr":
-        pipeOutput = os.Stderr
-    }
-
     // check for existing file
     fileInfo, err := os.Stat(pipe.Path)
 
@@ -50,26 +43,32 @@ func handlePipe(pipe Pipe) {
     if !pipeExists {
         err := syscall.Mkfifo(pipe.Path, uint32(pipePerms))
         if err != nil {
-            panic(fmt.Sprintf("Creation of pipe %s failed: %v", pipe.Path, err.Error()))
+            panic(fmt.Sprintf("Creation of named pipe %s failed: %v", pipe.Path, err.Error()))
         }
     }
 
     // Open pipe for reading
     fd, err := os.Open(pipe.Path)
     if err != nil {
-        panic(fmt.Sprintf("Failed opening pipe %s: %v", pipe.Path, err.Error()))
+        panic(fmt.Sprintf("Failed opening named pipe %s: %v", pipe.Path, err.Error()))
     }
     defer fd.Close()
     reader := bufio.NewReader(fd)
 
+    // loop messages
     for {
         message, err := reader.ReadString(0xa)
         if err != nil && err != io.EOF {
-            panic(fmt.Sprintf("Reading from pipe %s failed: %v", pipe.Path, err.Error()))
+            panic(fmt.Sprintf("Reading from named pipe %s failed: %v", pipe.Path, err.Error()))
         }
 
         if message != "" {
-            printMessage(pipeOutput, message)
+            switch pipe.Type {
+                case "stdout":
+                    LoggerStdout.Println(message)
+                case "stderr":
+                    LoggerStderr.Println(message)
+            }
         }
     }
 }

pipe.go

@@ -53,6 +53,8 @@ var SyslogFacilityLookup = map[int]string {
 }
 
 func handleSyslog() {
+    LoggerStdout.Verbose(fmt.Sprintf(" -> Starting syslog daemon (%s)", configuration.Syslog.Path))
+
     // Check if syslog path exists, remove if already existing
     _, err := os.Stat(configuration.Syslog.Path)
     if err == nil {
@@ -82,7 +84,7 @@ func handleSyslog() {
             }
 
             message := fmt.Sprintf("%s: %s", facility, logParts["content"])
-            printMessage(os.Stdout, message)
+            LoggerStdout.Println(message)
         }
     }(channel)