logging

logging/consts.go

@@ -0,0 +1,25 @@
+package logging
+
+import (
+	`os`
+
+	`r00t2.io/goutils/types`
+)
+
+const (
+	devlog string = "/dev/log"
+	logPerm os.FileMode = 0600
+)
+
+// Flags for logger configuration
+const (
+	LogUndefined types.MaskBit = 1 << iota
+	LogJournald
+	LogSyslog
+	LogFile
+	LogStdout
+)
+
+var (
+	defLogPaths = []string{"/var/log/golang/program.log", "~/.local/log/golang/program.log"}
+)

logging/funcs.go

@@ -0,0 +1,117 @@
+package logging
+
+import (
+	native `log`
+	`os`
+	`path`
+	`strings`
+
+	"r00t2.io/goutils/types"
+
+	sysd `github.com/coreos/go-systemd/journal`
+	`r00t2.io/sysutils/paths`
+)
+
+var (
+	_ = sysd.Enabled()
+	_ = native.Logger{}
+	_ = os.Interrupt
+	_ = types.Env{}
+)
+
+func GetLogger(enableDebug bool, prefix string) (logger Logger, err error) {
+
+	var logPath string
+	var logflags types.MaskBit
+
+	// Configure system-supported logger(s).
+	if sysd.Enabled() {
+		// Use Journald.
+		logflags.AddFlag(LogJournald)
+	} else {
+		// If we can detect syslog, use that. If not, try to use a file logger (+ stdout).
+		// Last ditch, stdout.
+		var hasSyslog bool
+		var stat os.FileInfo
+		var devlogPath string = devlog
+
+		if hasSyslog, stat, err = paths.RealPathExistsStat(&devlogPath); hasSyslog && err != nil {return}
+
+		if hasSyslog && !stat.Mode().IsRegular() {logflags.AddFlag(LogSyslog)} else {
+			var exists bool
+			var success bool
+			logflags.AddFlag(LogStdout)
+			for _, p := range defLogPaths {
+				if exists, _ = paths.RealPathExists(&p); exists {
+					if success, err = testOpen(p); err != nil {
+						continue
+					} else if !success {
+						continue
+					}
+					logflags.AddFlag(LogFile)
+					logPath = p
+					break
+				} else {
+					dirPath := path.Dir(p)
+					if err = paths.MakeDirIfNotExist(&dirPath); err != nil {
+						continue
+					}
+					if success, err = testOpen(p); err != nil {
+						continue
+					} else if !success {
+						continue
+					}
+					logflags.AddFlag(LogFile)
+					logPath = p
+					break
+				}
+			}
+		}
+	}
+
+	if logflags.HasFlag(LogJournald) {
+		logger = &SystemDLogger{
+			Prefix: logPrefix,
+		}
+	} else {
+		if logflags.HasFlag(LogSyslog) {
+			logger = &SyslogLogger{
+				Prefix: logPrefix,
+			}
+		} else {
+			if logflags.HasFlag(LogFile) {
+				logger = &FileLogger{
+					StdLogger: StdLogger{
+						Prefix: logPrefix,
+					},
+					Path:      logPath,
+				}
+			} else {
+				logger = &StdLogger{
+					Prefix: logPrefix,
+				}
+			}
+		}
+	}
+
+	logger.doDebug(enableDebug)
+	if strings.TrimSpace(prefix) != "" {
+		logger.setPrefix(prefix)
+	}
+
+	return
+}
+
+func testOpen(path string) (success bool, err error) {
+	var f *os.File
+
+	// Example #2, https://golang.org/pkg/os/#OpenFile
+	if f, err = os.OpenFile(path, os.O_RDWR | os.O_CREATE, logPerm); err != nil {
+		return
+	}
+	defer f.Close()
+
+	success = true
+
+	return
+}

logging/funcs_file.go

@@ -0,0 +1,41 @@
+package logging
+
+func (l *FileLogger) doDebug(d bool) {
+	l.EnableDebug = d
+}
+
+func (l *FileLogger) setPrefix(prefix string) {
+	l.Prefix = prefix
+}
+
+func (l *FileLogger) Alert(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *FileLogger) Crit(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *FileLogger) Debug(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *FileLogger) Emerg(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *FileLogger) Err(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *FileLogger) Info(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *FileLogger) Notice(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *FileLogger) Warning(s string, v ...interface{}) (err error) {
+	return
+}

logging/funcs_std.go

@@ -0,0 +1,41 @@
+package logging
+
+func (l *StdLogger) doDebug(d bool) {
+	l.EnableDebug = d
+}
+
+func (l *StdLogger) setPrefix(prefix string) {
+	l.Prefix = prefix
+}
+
+func (l *StdLogger) Alert(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *StdLogger) Crit(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *StdLogger) Debug(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *StdLogger) Emerg(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *StdLogger) Err(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *StdLogger) Info(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *StdLogger) Notice(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *StdLogger) Warning(s string, v ...interface{}) (err error) {
+	return
+}

logging/funcs_sysd.go

@@ -0,0 +1,41 @@
+package logging
+
+func (l *SystemDLogger) doDebug(d bool) {
+	l.EnableDebug = d
+}
+
+func (l *SystemDLogger) setPrefix(prefix string) {
+	l.Prefix = prefix
+}
+
+func (l *SystemDLogger) Alert(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SystemDLogger) Crit(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SystemDLogger) Debug(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SystemDLogger) Emerg(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SystemDLogger) Err(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SystemDLogger) Info(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SystemDLogger) Notice(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SystemDLogger) Warning(s string, v ...interface{}) (err error) {
+	return
+}

logging/funcs_syslog.go

@@ -0,0 +1,41 @@
+package logging
+
+func (l *SyslogLogger) doDebug(d bool) {
+	l.EnableDebug = d
+}
+
+func (l *SyslogLogger) setPrefix(prefix string) {
+	l.Prefix = prefix
+}
+
+func (l *SyslogLogger) Alert(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SyslogLogger) Crit(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SyslogLogger) Debug(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SyslogLogger) Emerg(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SyslogLogger) Err(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SyslogLogger) Info(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SyslogLogger) Notice(s string, v ...interface{}) (err error) {
+	return
+}
+
+func (l *SyslogLogger) Warning(s string, v ...interface{}) (err error) {
+	return
+}

logging/types.go

@@ -0,0 +1,44 @@
+package logging
+
+import (
+	`log`
+	`log/syslog`
+)
+
+type Logger interface {
+	Alert(string, ...interface{}) error
+	Crit(string, ...interface{}) error
+	Debug(string, ...interface{}) error
+	Emerg(string, ...interface{}) error
+	Err(string, ...interface{}) error
+	Info(string, ...interface{}) error
+	Notice(string, ...interface{}) error
+	Warning(string, ...interface{}) error
+	doDebug(bool)
+	setPrefix(string)
+}
+
+type SystemDLogger struct {
+	EnableDebug bool
+	Prefix      string
+}
+
+type SyslogLogger struct {
+	syslog.Writer
+	EnableDebug bool
+	Prefix      string
+}
+
+type StdLogger struct {
+	log.Logger
+	EnableDebug bool
+	Prefix      string
+}
+
+type FileLogger struct {
+	log.Logger
+	StdLogger
+	EnableDebug bool
+	Path        string
+	Prefix      string
+}