From 18fdb9818fc918ee015081c7a465d35d0d6146bc Mon Sep 17 00:00:00 2001 From: Timothy Date: Fri, 27 Oct 2017 14:07:43 +0800 Subject: [PATCH] remove logger, use go's official log package --- cmd/godns/godns.go | 21 ++- logger.go | 310 --------------------------------------------- 2 files changed, 16 insertions(+), 315 deletions(-) delete mode 100644 logger.go diff --git a/cmd/godns/godns.go b/cmd/godns/godns.go index 3255a77..51a59b9 100644 --- a/cmd/godns/godns.go +++ b/cmd/godns/godns.go @@ -3,9 +3,10 @@ package main import ( "flag" "fmt" - "log" "os" + "log" + "github.com/TimothyYe/godns" "github.com/TimothyYe/godns/handler" ) @@ -26,26 +27,36 @@ func main() { // Load settings from configurations file if err := godns.LoadSettings(*optConf, &configuration); err != nil { fmt.Println(err.Error()) - log.Println(err.Error()) os.Exit(1) } if err := godns.CheckSettings(&configuration); err != nil { - log.Println("Settings is invalid! ", err.Error()) + fmt.Println("Settings is invalid! ", err.Error()) os.Exit(1) } - if err := godns.InitLogger(configuration.LogPath, configuration.LogSize, configuration.LogNum); err != nil { - log.Println("InitLogger error:", err.Error()) + if configuration.LogPath == "" { + configuration.LogPath = "./godns.log" + } + + // Init log file + f, err := os.OpenFile(configuration.LogPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) + if err != nil { + fmt.Println("Failed to create log file:", configuration.LogPath) os.Exit(1) } + defer f.Close() + + log.SetOutput(f) + log.Println("GoDNS started, entering main loop...") dnsLoop() } func dnsLoop() { panicChan := make(chan godns.Domain) + log.Println("Creating DNS handler with provider:", configuration.Provider) handler := handler.CreateHandler(configuration.Provider) handler.SetConfiguration(&configuration) for _, domain := range configuration.Domains { diff --git a/logger.go b/logger.go deleted file mode 100644 index f15fecf..0000000 --- a/logger.go +++ /dev/null @@ -1,310 +0,0 @@ -package godns - -import ( - "bufio" - "bytes" - "errors" - "io" - "io/ioutil" - "log" - "os" - "runtime/debug" - "strconv" - "strings" - "sync" - "time" -) - -const ( - // Info log level - Info int = iota - // Warning log level - Warning - // Debug log level - Debug - // PreInfo log level - PreInfo = "[INFO]" - // PreWarning log level - PreWarning = "[WARNING]" - // PreDebug log level - PreDebug = "[DEBUG]" -) - -// Logger struct -type Logger struct { - DevMode bool - fd *os.File - size int - num int - level int - mu sync.Mutex - muSplit sync.Mutex - flushInterval int64 //Second - flushSize int - buf *bytes.Buffer - log *log.Logger -} - -// NewLogger returns a new created logger -func NewLogger(logfile string, size, num int, level int, flushInterval int64, flushSize int) (logger *Logger, err error) { - if size < 1 || num < 1 || level < Info || len(logfile) < 1 { - err = errors.New("newLogWriter:param error") - return - } - logger = &Logger{size: size * 1024, num: num, level: level, DevMode: false} - logger.fd, err = os.OpenFile(logfile, os.O_WRONLY|os.O_APPEND|os.O_CREATE, os.ModeAppend|0666) - if err != nil { - logger = nil - return - } - log.SetOutput(logger) - if flushInterval > 0 && flushSize > 0 { - logger.buf = new(bytes.Buffer) - logger.log = log.New(logger.buf, "", log.LstdFlags) - - go func(interval int64, logger *Logger) { - defer func() { - if r := recover(); r != nil { - log.Printf("logger Tick, Recovered in %v:\n %s", r, debug.Stack()) - } - }() - c := time.Tick(time.Duration(interval) * time.Second) - for _ = range c { - logger.Flush() - } - }(flushInterval, logger) - } - return -} - -// InitLogger initialize logger with specified log filename & size -func InitLogger(logfile string, size, num int) (err error) { - logger, err := NewLogger(logfile, size, num, Info, -1, -1) - if logger != nil { - logger.level = Info - 1 - } - return -} - -// Write immplement write -func (logger *Logger) Write(p []byte) (n int, err error) { - if logger.DevMode { - n, err = os.Stdout.Write(p) - return - } - n, err = logger.fd.Write(p) - if err == nil { - fi, e := logger.fd.Stat() - if e != nil { - err = e - return - } - if fi.Size() > int64(logger.size) { - logger.muSplit.Lock() - defer logger.muSplit.Unlock() - - fname := fi.Name() - strings.HasSuffix(fname, ".log") - fbase := fname[:len(fname)-3] - - oldBs := make([]byte, 0, logger.size) - newBs := []byte{} - fd, e := os.Open(fname) - if e != nil { - err = e - return - } - rd := bufio.NewReader(fd) - for { - line, e := rd.ReadBytes('\n') - if e == io.EOF { - break - } - if e != nil { - err = e - return - } - if len(oldBs)+len(line) > logger.size { - newBs = append(newBs, line...) - } else { - oldBs = append(oldBs, line...) - } - } - fd.Close() - - _, err = logger.saveLog(1, fbase, oldBs) - if err != nil { - return - } - err = logger.fd.Close() - if err != nil { - return - } - err = os.Remove(fname) - if err != nil { - return - } - logger.fd, err = os.OpenFile(fname, os.O_WRONLY|os.O_APPEND|os.O_CREATE, os.ModeAppend|0666) - if err != nil { - return - } - _, err = logger.fd.Write(newBs) - if err != nil { - return - } - } - } - return -} - -func (logger *Logger) saveLog(index int, fbase string, data []byte) (n int, err error) { - fn := fbase + strconv.Itoa(index) + ".log" - _, err = os.Stat(fn) - if index < logger.num && err == nil { - var b []byte - b, err = ioutil.ReadFile(fn) - if err != nil { - return - } - n, err = logger.saveLog(index+1, fbase, b) - if err != nil { - return - } - } - - fd, err := os.OpenFile(fn, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, os.ModePerm|0666) - if err != nil { - return - } - defer fd.Close() - n, err = fd.Write(data) - return -} - -// Flush buf data to std log -func (logger *Logger) Flush() { - if logger.buf.Len() > 0 { - logger.mu.Lock() - defer logger.mu.Unlock() - - log.SetFlags(0) - log.Print(logger.buf) - log.SetFlags(log.LstdFlags) - logger.buf.Reset() - } -} - -// Clean prefix and check buf size -func (logger *Logger) clean() { - logger.log.SetPrefix("") - if logger.buf.Len()/1024 > logger.flushSize { - go logger.Flush() - } -} - -func (logger *Logger) setPrefix(lv int) bool { - if lv > logger.level { - return false - } - - switch lv { - case Info: - logger.log.SetPrefix(PreInfo) - case Warning: - logger.log.SetPrefix(PreWarning) - case Debug: - logger.log.SetPrefix(PreDebug) - default: - return false - } - return true -} - -func (logger *Logger) logPrint(lv int, args ...interface{}) { - logger.mu.Lock() - defer logger.mu.Unlock() - - if !logger.setPrefix(lv) { - return - } - logger.log.Print(args...) - logger.clean() -} - -func (logger *Logger) logPrintln(lv int, args ...interface{}) { - logger.mu.Lock() - defer logger.mu.Unlock() - - if !logger.setPrefix(lv) { - return - } - logger.log.Println(args...) - logger.clean() -} - -func (logger *Logger) logPrintf(lv int, format string, args ...interface{}) { - logger.mu.Lock() - defer logger.mu.Unlock() - - if !logger.setPrefix(lv) { - return - } - logger.log.Printf(format, args...) - logger.clean() -} - -// Close fd -func (logger *Logger) Close() { - if logger.fd != nil { - logger.Flush() - logger.fd.Close() - } -} - -// Info output info log -func (logger *Logger) Info(args ...interface{}) { - logger.logPrint(Info, args...) -} - -// Infoln output info log with newline -func (logger *Logger) Infoln(args ...interface{}) { - logger.logPrintln(Info, args...) -} - -// Infof output formatted info log -func (logger *Logger) Infof(format string, args ...interface{}) { - logger.logPrintf(Info, format, args...) -} - -// Warning output warning log -func (logger *Logger) Warning(args ...interface{}) { - logger.logPrint(Warning, args...) -} - -//Warningln output warning log with newline -func (logger *Logger) Warningln(args ...interface{}) { - logger.logPrintln(Warning, args...) -} - -// Warningf output formatted warning log -func (logger *Logger) Warningf(format string, args ...interface{}) { - logger.logPrintf(Warning, format, args...) -} - -// Debug output debug log -func (logger *Logger) Debug(args ...interface{}) { - logger.logPrint(Debug, args...) - logger.Flush() -} - -// Debugln output debug log with newline -func (logger *Logger) Debugln(args ...interface{}) { - logger.logPrintln(Debug, args...) - logger.Flush() -} - -// Debugf output formatted debug log -func (logger *Logger) Debugf(format string, args ...interface{}) { - logger.logPrintf(Debug, format, args...) - logger.Flush() -}