mirror of https://github.com/gogits/gogs.git
Unknwon
8 years ago
66 changed files with 198 additions and 1033 deletions
File diff suppressed because one or more lines are too long
@ -1,104 +0,0 @@
|
||||
// Copyright 2014 The Gogs Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package log |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
"io" |
||||
"log" |
||||
"net" |
||||
) |
||||
|
||||
// ConnWriter implements LoggerInterface.
|
||||
// it writes messages in keep-live tcp connection.
|
||||
type ConnWriter struct { |
||||
lg *log.Logger |
||||
innerWriter io.WriteCloser |
||||
ReconnectOnMsg bool `json:"reconnectOnMsg"` |
||||
Reconnect bool `json:"reconnect"` |
||||
Net string `json:"net"` |
||||
Addr string `json:"addr"` |
||||
Level int `json:"level"` |
||||
} |
||||
|
||||
// create new ConnWrite returning as LoggerInterface.
|
||||
func NewConn() LoggerInterface { |
||||
conn := new(ConnWriter) |
||||
conn.Level = TRACE |
||||
return conn |
||||
} |
||||
|
||||
// init connection writer with json config.
|
||||
// json config only need key "level".
|
||||
func (cw *ConnWriter) Init(jsonconfig string) error { |
||||
return json.Unmarshal([]byte(jsonconfig), cw) |
||||
} |
||||
|
||||
// write message in connection.
|
||||
// if connection is down, try to re-connect.
|
||||
func (cw *ConnWriter) WriteMsg(msg string, skip, level int) error { |
||||
if cw.Level > level { |
||||
return nil |
||||
} |
||||
if cw.neddedConnectOnMsg() { |
||||
if err := cw.connect(); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
if cw.ReconnectOnMsg { |
||||
defer cw.innerWriter.Close() |
||||
} |
||||
cw.lg.Println(msg) |
||||
return nil |
||||
} |
||||
|
||||
func (_ *ConnWriter) Flush() { |
||||
} |
||||
|
||||
// destroy connection writer and close tcp listener.
|
||||
func (cw *ConnWriter) Destroy() { |
||||
if cw.innerWriter == nil { |
||||
return |
||||
} |
||||
cw.innerWriter.Close() |
||||
} |
||||
|
||||
func (cw *ConnWriter) connect() error { |
||||
if cw.innerWriter != nil { |
||||
cw.innerWriter.Close() |
||||
cw.innerWriter = nil |
||||
} |
||||
|
||||
conn, err := net.Dial(cw.Net, cw.Addr) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
if tcpConn, ok := conn.(*net.TCPConn); ok { |
||||
tcpConn.SetKeepAlive(true) |
||||
} |
||||
|
||||
cw.innerWriter = conn |
||||
cw.lg = log.New(conn, "", log.Ldate|log.Ltime) |
||||
return nil |
||||
} |
||||
|
||||
func (cw *ConnWriter) neddedConnectOnMsg() bool { |
||||
if cw.Reconnect { |
||||
cw.Reconnect = false |
||||
return true |
||||
} |
||||
|
||||
if cw.innerWriter == nil { |
||||
return true |
||||
} |
||||
|
||||
return cw.ReconnectOnMsg |
||||
} |
||||
|
||||
func init() { |
||||
Register("conn", NewConn) |
||||
} |
||||
@ -1,73 +0,0 @@
|
||||
// Copyright 2014 The Gogs Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package log |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
"log" |
||||
"os" |
||||
"runtime" |
||||
) |
||||
|
||||
type Brush func(string) string |
||||
|
||||
func NewBrush(color string) Brush { |
||||
pre := "\033[" |
||||
reset := "\033[0m" |
||||
return func(text string) string { |
||||
return pre + color + "m" + text + reset |
||||
} |
||||
} |
||||
|
||||
var colors = []Brush{ |
||||
NewBrush("1;36"), // Trace cyan
|
||||
NewBrush("1;34"), // Debug blue
|
||||
NewBrush("1;32"), // Info green
|
||||
NewBrush("1;33"), // Warn yellow
|
||||
NewBrush("1;31"), // Error red
|
||||
NewBrush("1;35"), // Critical purple
|
||||
NewBrush("1;31"), // Fatal red
|
||||
} |
||||
|
||||
// ConsoleWriter implements LoggerInterface and writes messages to terminal.
|
||||
type ConsoleWriter struct { |
||||
lg *log.Logger |
||||
Level int `json:"level"` |
||||
} |
||||
|
||||
// create ConsoleWriter returning as LoggerInterface.
|
||||
func NewConsole() LoggerInterface { |
||||
return &ConsoleWriter{ |
||||
lg: log.New(os.Stdout, "", log.Ldate|log.Ltime), |
||||
Level: TRACE, |
||||
} |
||||
} |
||||
|
||||
func (cw *ConsoleWriter) Init(config string) error { |
||||
return json.Unmarshal([]byte(config), cw) |
||||
} |
||||
|
||||
func (cw *ConsoleWriter) WriteMsg(msg string, skip, level int) error { |
||||
if cw.Level > level { |
||||
return nil |
||||
} |
||||
if runtime.GOOS == "windows" { |
||||
cw.lg.Println(msg) |
||||
} else { |
||||
cw.lg.Println(colors[level](msg)) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (_ *ConsoleWriter) Flush() { |
||||
|
||||
} |
||||
|
||||
func (_ *ConsoleWriter) Destroy() { |
||||
} |
||||
|
||||
func init() { |
||||
Register("console", NewConsole) |
||||
} |
||||
@ -1,243 +0,0 @@
|
||||
// Copyright 2014 The Gogs Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package log |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
"errors" |
||||
"fmt" |
||||
"io/ioutil" |
||||
"log" |
||||
"os" |
||||
"path/filepath" |
||||
"strings" |
||||
"sync" |
||||
"time" |
||||
) |
||||
|
||||
// FileLogWriter implements LoggerInterface.
|
||||
// It writes messages by lines limit, file size limit, or time frequency.
|
||||
type FileLogWriter struct { |
||||
*log.Logger |
||||
mw *MuxWriter |
||||
// The opened file
|
||||
Filename string `json:"filename"` |
||||
|
||||
Maxlines int `json:"maxlines"` |
||||
maxlines_curlines int |
||||
|
||||
// Rotate at size
|
||||
Maxsize int `json:"maxsize"` |
||||
maxsize_cursize int |
||||
|
||||
// Rotate daily
|
||||
Daily bool `json:"daily"` |
||||
Maxdays int64 `json:"maxdays"` |
||||
daily_opendate int |
||||
|
||||
Rotate bool `json:"rotate"` |
||||
|
||||
startLock sync.Mutex // Only one log can write to the file
|
||||
|
||||
Level int `json:"level"` |
||||
} |
||||
|
||||
// an *os.File writer with locker.
|
||||
type MuxWriter struct { |
||||
sync.Mutex |
||||
fd *os.File |
||||
} |
||||
|
||||
// write to os.File.
|
||||
func (l *MuxWriter) Write(b []byte) (int, error) { |
||||
l.Lock() |
||||
defer l.Unlock() |
||||
return l.fd.Write(b) |
||||
} |
||||
|
||||
// set os.File in writer.
|
||||
func (l *MuxWriter) SetFd(fd *os.File) { |
||||
if l.fd != nil { |
||||
l.fd.Close() |
||||
} |
||||
l.fd = fd |
||||
} |
||||
|
||||
// create a FileLogWriter returning as LoggerInterface.
|
||||
func NewFileWriter() LoggerInterface { |
||||
w := &FileLogWriter{ |
||||
Filename: "", |
||||
Maxlines: 1000000, |
||||
Maxsize: 1 << 28, //256 MB
|
||||
Daily: true, |
||||
Maxdays: 7, |
||||
Rotate: true, |
||||
Level: TRACE, |
||||
} |
||||
// use MuxWriter instead direct use os.File for lock write when rotate
|
||||
w.mw = new(MuxWriter) |
||||
// set MuxWriter as Logger's io.Writer
|
||||
w.Logger = log.New(w.mw, "", log.Ldate|log.Ltime) |
||||
return w |
||||
} |
||||
|
||||
// Init file logger with json config.
|
||||
// config like:
|
||||
// {
|
||||
// "filename":"log/gogs.log",
|
||||
// "maxlines":10000,
|
||||
// "maxsize":1<<30,
|
||||
// "daily":true,
|
||||
// "maxdays":15,
|
||||
// "rotate":true
|
||||
// }
|
||||
func (w *FileLogWriter) Init(config string) error { |
||||
if err := json.Unmarshal([]byte(config), w); err != nil { |
||||
return err |
||||
} |
||||
if len(w.Filename) == 0 { |
||||
return errors.New("config must have filename") |
||||
} |
||||
return w.StartLogger() |
||||
} |
||||
|
||||
// start file logger. create log file and set to locker-inside file writer.
|
||||
func (w *FileLogWriter) StartLogger() error { |
||||
fd, err := w.createLogFile() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
w.mw.SetFd(fd) |
||||
if err = w.initFd(); err != nil { |
||||
return err |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (w *FileLogWriter) docheck(size int) { |
||||
w.startLock.Lock() |
||||
defer w.startLock.Unlock() |
||||
if w.Rotate && ((w.Maxlines > 0 && w.maxlines_curlines >= w.Maxlines) || |
||||
(w.Maxsize > 0 && w.maxsize_cursize >= w.Maxsize) || |
||||
(w.Daily && time.Now().Day() != w.daily_opendate)) { |
||||
if err := w.DoRotate(); err != nil { |
||||
fmt.Fprintf(os.Stderr, "FileLogWriter(%q): %s\n", w.Filename, err) |
||||
return |
||||
} |
||||
} |
||||
w.maxlines_curlines++ |
||||
w.maxsize_cursize += size |
||||
} |
||||
|
||||
// write logger message into file.
|
||||
func (w *FileLogWriter) WriteMsg(msg string, skip, level int) error { |
||||
if level < w.Level { |
||||
return nil |
||||
} |
||||
n := 24 + len(msg) // 24 stand for the length "2013/06/23 21:00:22 [T] "
|
||||
w.docheck(n) |
||||
w.Logger.Println(msg) |
||||
return nil |
||||
} |
||||
|
||||
func (w *FileLogWriter) createLogFile() (*os.File, error) { |
||||
// Open the log file
|
||||
return os.OpenFile(w.Filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0660) |
||||
} |
||||
|
||||
func (w *FileLogWriter) initFd() error { |
||||
fd := w.mw.fd |
||||
finfo, err := fd.Stat() |
||||
if err != nil { |
||||
return fmt.Errorf("get stat: %s\n", err) |
||||
} |
||||
w.maxsize_cursize = int(finfo.Size()) |
||||
w.daily_opendate = time.Now().Day() |
||||
if finfo.Size() > 0 { |
||||
content, err := ioutil.ReadFile(w.Filename) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
w.maxlines_curlines = len(strings.Split(string(content), "\n")) |
||||
} else { |
||||
w.maxlines_curlines = 0 |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// DoRotate means it need to write file in new file.
|
||||
// new file name like xx.log.2013-01-01.2
|
||||
func (w *FileLogWriter) DoRotate() error { |
||||
_, err := os.Lstat(w.Filename) |
||||
if err == nil { // file exists
|
||||
// Find the next available number
|
||||
num := 1 |
||||
fname := "" |
||||
for ; err == nil && num <= 999; num++ { |
||||
fname = w.Filename + fmt.Sprintf(".%s.%03d", time.Now().Format("2006-01-02"), num) |
||||
_, err = os.Lstat(fname) |
||||
} |
||||
// return error if the last file checked still existed
|
||||
if err == nil { |
||||
return fmt.Errorf("rotate: cannot find free log number to rename %s\n", w.Filename) |
||||
} |
||||
|
||||
// block Logger's io.Writer
|
||||
w.mw.Lock() |
||||
defer w.mw.Unlock() |
||||
|
||||
fd := w.mw.fd |
||||
fd.Close() |
||||
|
||||
// close fd before rename
|
||||
// Rename the file to its newfound home
|
||||
if err = os.Rename(w.Filename, fname); err != nil { |
||||
return fmt.Errorf("Rotate: %s\n", err) |
||||
} |
||||
|
||||
// re-start logger
|
||||
if err = w.StartLogger(); err != nil { |
||||
return fmt.Errorf("Rotate StartLogger: %s\n", err) |
||||
} |
||||
|
||||
go w.deleteOldLog() |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (w *FileLogWriter) deleteOldLog() { |
||||
dir := filepath.Dir(w.Filename) |
||||
filepath.Walk(dir, func(path string, info os.FileInfo, err error) (returnErr error) { |
||||
defer func() { |
||||
if r := recover(); r != nil { |
||||
returnErr = fmt.Errorf("Unable to delete old log '%s', error: %+v", path, r) |
||||
} |
||||
}() |
||||
|
||||
if !info.IsDir() && info.ModTime().Unix() < (time.Now().Unix()-60*60*24*w.Maxdays) { |
||||
if strings.HasPrefix(filepath.Base(path), filepath.Base(w.Filename)) { |
||||
os.Remove(path) |
||||
} |
||||
} |
||||
return returnErr |
||||
}) |
||||
} |
||||
|
||||
// destroy file logger, close file writer.
|
||||
func (w *FileLogWriter) Destroy() { |
||||
w.mw.fd.Close() |
||||
} |
||||
|
||||
// flush file logger.
|
||||
// there are no buffering messages in file logger in memory.
|
||||
// flush file means sync file from disk.
|
||||
func (w *FileLogWriter) Flush() { |
||||
w.mw.fd.Sync() |
||||
} |
||||
|
||||
func init() { |
||||
Register("file", NewFileWriter) |
||||
} |
||||
@ -1,312 +0,0 @@
|
||||
// Copyright 2014 The Gogs Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package log |
||||
|
||||
import ( |
||||
"fmt" |
||||
"os" |
||||
"path" |
||||
"path/filepath" |
||||
"runtime" |
||||
"strings" |
||||
"sync" |
||||
) |
||||
|
||||
var ( |
||||
loggers []*Logger |
||||
GitLogger *Logger |
||||
) |
||||
|
||||
func NewLogger(bufLen int64, mode, config string) { |
||||
logger := newLogger(bufLen) |
||||
|
||||
isExist := false |
||||
for i, l := range loggers { |
||||
if l.adapter == mode { |
||||
isExist = true |
||||
loggers[i] = logger |
||||
} |
||||
} |
||||
if !isExist { |
||||
loggers = append(loggers, logger) |
||||
} |
||||
if err := logger.SetLogger(mode, config); err != nil { |
||||
Fatal(2, "Fail to set logger (%s): %v", mode, err) |
||||
} |
||||
} |
||||
|
||||
// FIXME: use same log level as other loggers.
|
||||
func NewGitLogger(logPath string) { |
||||
os.MkdirAll(path.Dir(logPath), os.ModePerm) |
||||
GitLogger = newLogger(0) |
||||
GitLogger.SetLogger("file", fmt.Sprintf(`{"level":0,"filename":"%s","rotate":false}`, logPath)) |
||||
} |
||||
|
||||
func Trace(format string, v ...interface{}) { |
||||
for _, logger := range loggers { |
||||
logger.Trace(format, v...) |
||||
} |
||||
} |
||||
|
||||
func Debug(format string, v ...interface{}) { |
||||
for _, logger := range loggers { |
||||
logger.Debug(format, v...) |
||||
} |
||||
} |
||||
|
||||
func Info(format string, v ...interface{}) { |
||||
for _, logger := range loggers { |
||||
logger.Info(format, v...) |
||||
} |
||||
} |
||||
|
||||
func Warn(format string, v ...interface{}) { |
||||
for _, logger := range loggers { |
||||
logger.Warn(format, v...) |
||||
} |
||||
} |
||||
|
||||
func Error(skip int, format string, v ...interface{}) { |
||||
for _, logger := range loggers { |
||||
logger.Error(skip, format, v...) |
||||
} |
||||
} |
||||
|
||||
func Critical(skip int, format string, v ...interface{}) { |
||||
for _, logger := range loggers { |
||||
logger.Critical(skip, format, v...) |
||||
} |
||||
} |
||||
|
||||
func Fatal(skip int, format string, v ...interface{}) { |
||||
Error(skip, format, v...) |
||||
for _, l := range loggers { |
||||
l.Close() |
||||
} |
||||
os.Exit(1) |
||||
} |
||||
|
||||
func Close() { |
||||
for _, l := range loggers { |
||||
l.Close() |
||||
} |
||||
} |
||||
|
||||
// .___ __ _____
|
||||
// | | _____/ |_ ____________/ ____\____ ____ ____
|
||||
// | |/ \ __\/ __ \_ __ \ __\\__ \ _/ ___\/ __ \
|
||||
// | | | \ | \ ___/| | \/| | / __ \\ \__\ ___/
|
||||
// |___|___| /__| \___ >__| |__| (____ /\___ >___ >
|
||||
// \/ \/ \/ \/ \/
|
||||
|
||||
type LogLevel int |
||||
|
||||
const ( |
||||
TRACE = iota |
||||
DEBUG |
||||
INFO |
||||
WARN |
||||
ERROR |
||||
CRITICAL |
||||
FATAL |
||||
) |
||||
|
||||
// LoggerInterface represents behaviors of a logger provider.
|
||||
type LoggerInterface interface { |
||||
Init(config string) error |
||||
WriteMsg(msg string, skip, level int) error |
||||
Destroy() |
||||
Flush() |
||||
} |
||||
|
||||
type loggerType func() LoggerInterface |
||||
|
||||
var adapters = make(map[string]loggerType) |
||||
|
||||
// Register registers given logger provider to adapters.
|
||||
func Register(name string, log loggerType) { |
||||
if log == nil { |
||||
panic("log: register provider is nil") |
||||
} |
||||
if _, dup := adapters[name]; dup { |
||||
panic("log: register called twice for provider \"" + name + "\"") |
||||
} |
||||
adapters[name] = log |
||||
} |
||||
|
||||
type logMsg struct { |
||||
skip, level int |
||||
msg string |
||||
} |
||||
|
||||
// Logger is default logger in beego application.
|
||||
// it can contain several providers and log message into all providers.
|
||||
type Logger struct { |
||||
adapter string |
||||
lock sync.Mutex |
||||
level int |
||||
msg chan *logMsg |
||||
outputs map[string]LoggerInterface |
||||
quit chan bool |
||||
} |
||||
|
||||
// newLogger initializes and returns a new logger.
|
||||
func newLogger(buffer int64) *Logger { |
||||
l := &Logger{ |
||||
msg: make(chan *logMsg, buffer), |
||||
outputs: make(map[string]LoggerInterface), |
||||
quit: make(chan bool), |
||||
} |
||||
go l.StartLogger() |
||||
return l |
||||
} |
||||
|
||||
// SetLogger sets new logger instance with given logger adapter and config.
|
||||
func (l *Logger) SetLogger(adapter string, config string) error { |
||||
l.lock.Lock() |
||||
defer l.lock.Unlock() |
||||
if log, ok := adapters[adapter]; ok { |
||||
lg := log() |
||||
if err := lg.Init(config); err != nil { |
||||
return err |
||||
} |
||||
l.outputs[adapter] = lg |
||||
l.adapter = adapter |
||||
} else { |
||||
panic("log: unknown adapter \"" + adapter + "\" (forgotten register?)") |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// DelLogger removes a logger adapter instance.
|
||||
func (l *Logger) DelLogger(adapter string) error { |
||||
l.lock.Lock() |
||||
defer l.lock.Unlock() |
||||
if lg, ok := l.outputs[adapter]; ok { |
||||
lg.Destroy() |
||||
delete(l.outputs, adapter) |
||||
} else { |
||||
panic("log: unknown adapter \"" + adapter + "\" (forgotten register?)") |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (l *Logger) writerMsg(skip, level int, msg string) error { |
||||
if l.level > level { |
||||
return nil |
||||
} |
||||
lm := &logMsg{ |
||||
skip: skip, |
||||
level: level, |
||||
} |
||||
|
||||
// Only error information needs locate position for debugging.
|
||||
if lm.level >= ERROR { |
||||
pc, file, line, ok := runtime.Caller(skip) |
||||
if ok { |
||||
// Get caller function name.
|
||||
fn := runtime.FuncForPC(pc) |
||||
var fnName string |
||||
if fn == nil { |
||||
fnName = "?()" |
||||
} else { |
||||
fnName = strings.TrimLeft(filepath.Ext(fn.Name()), ".") + "()" |
||||
} |
||||
|
||||
fileName := file |
||||
if len(fileName) > 20 { |
||||
fileName = "..." + fileName[len(fileName)-20:] |
||||
} |
||||
lm.msg = fmt.Sprintf("[%s:%d %s] %s", fileName, line, fnName, msg) |
||||
} else { |
||||
lm.msg = msg |
||||
} |
||||
} else { |
||||
lm.msg = msg |
||||
} |
||||
l.msg <- lm |
||||
return nil |
||||
} |
||||
|
||||
// StartLogger starts logger chan reading.
|
||||
func (l *Logger) StartLogger() { |
||||
for { |
||||
select { |
||||
case bm := <-l.msg: |
||||
for _, l := range l.outputs { |
||||
if err := l.WriteMsg(bm.msg, bm.skip, bm.level); err != nil { |
||||
fmt.Println("ERROR, unable to WriteMsg:", err) |
||||
} |
||||
} |
||||
case <-l.quit: |
||||
return |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Flush flushs all chan data.
|
||||
func (l *Logger) Flush() { |
||||
for _, l := range l.outputs { |
||||
l.Flush() |
||||
} |
||||
} |
||||
|
||||
// Close closes logger, flush all chan data and destroy all adapter instances.
|
||||
func (l *Logger) Close() { |
||||
l.quit <- true |
||||
for { |
||||
if len(l.msg) > 0 { |
||||
bm := <-l.msg |
||||
for _, l := range l.outputs { |
||||
if err := l.WriteMsg(bm.msg, bm.skip, bm.level); err != nil { |
||||
fmt.Println("ERROR, unable to WriteMsg:", err) |
||||
} |
||||
} |
||||
} else { |
||||
break |
||||
} |
||||
} |
||||
for _, l := range l.outputs { |
||||
l.Flush() |
||||
l.Destroy() |
||||
} |
||||
} |
||||
|
||||
func (l *Logger) Trace(format string, v ...interface{}) { |
||||
msg := fmt.Sprintf("[T] "+format, v...) |
||||
l.writerMsg(0, TRACE, msg) |
||||
} |
||||
|
||||
func (l *Logger) Debug(format string, v ...interface{}) { |
||||
msg := fmt.Sprintf("[D] "+format, v...) |
||||
l.writerMsg(0, DEBUG, msg) |
||||
} |
||||
|
||||
func (l *Logger) Info(format string, v ...interface{}) { |
||||
msg := fmt.Sprintf("[I] "+format, v...) |
||||
l.writerMsg(0, INFO, msg) |
||||
} |
||||
|
||||
func (l *Logger) Warn(format string, v ...interface{}) { |
||||
msg := fmt.Sprintf("[W] "+format, v...) |
||||
l.writerMsg(0, WARN, msg) |
||||
} |
||||
|
||||
func (l *Logger) Error(skip int, format string, v ...interface{}) { |
||||
msg := fmt.Sprintf("[E] "+format, v...) |
||||
l.writerMsg(skip, ERROR, msg) |
||||
} |
||||
|
||||
func (l *Logger) Critical(skip int, format string, v ...interface{}) { |
||||
msg := fmt.Sprintf("[C] "+format, v...) |
||||
l.writerMsg(skip, CRITICAL, msg) |
||||
} |
||||
|
||||
func (l *Logger) Fatal(skip int, format string, v ...interface{}) { |
||||
msg := fmt.Sprintf("[F] "+format, v...) |
||||
l.writerMsg(skip, FATAL, msg) |
||||
l.Close() |
||||
os.Exit(1) |
||||
} |
||||
@ -1,87 +0,0 @@
|
||||
// Copyright 2014 The Gogs Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package log |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
"fmt" |
||||
"net/smtp" |
||||
"strings" |
||||
"time" |
||||
) |
||||
|
||||
const ( |
||||
subjectPhrase = "Diagnostic message from server" |
||||
) |
||||
|
||||
// smtpWriter implements LoggerInterface and is used to send emails via given SMTP-server.
|
||||
type SmtpWriter struct { |
||||
Username string `json:"Username"` |
||||
Password string `json:"password"` |
||||
Host string `json:"Host"` |
||||
Subject string `json:"subject"` |
||||
RecipientAddresses []string `json:"sendTos"` |
||||
Level int `json:"level"` |
||||
} |
||||
|
||||
// create smtp writer.
|
||||
func NewSmtpWriter() LoggerInterface { |
||||
return &SmtpWriter{Level: TRACE} |
||||
} |
||||
|
||||
// init smtp writer with json config.
|
||||
// config like:
|
||||
// {
|
||||
// "Username":"example@gmail.com",
|
||||
// "password:"password",
|
||||
// "host":"smtp.gmail.com:465",
|
||||
// "subject":"email title",
|
||||
// "sendTos":["email1","email2"],
|
||||
// "level":LevelError
|
||||
// }
|
||||
func (sw *SmtpWriter) Init(jsonconfig string) error { |
||||
return json.Unmarshal([]byte(jsonconfig), sw) |
||||
} |
||||
|
||||
// write message in smtp writer.
|
||||
// it will send an email with subject and only this message.
|
||||
func (s *SmtpWriter) WriteMsg(msg string, skip, level int) error { |
||||
if level < s.Level { |
||||
return nil |
||||
} |
||||
|
||||
hp := strings.Split(s.Host, ":") |
||||
|
||||
// Set up authentication information.
|
||||
auth := smtp.PlainAuth( |
||||
"", |
||||
s.Username, |
||||
s.Password, |
||||
hp[0], |
||||
) |
||||
// Connect to the server, authenticate, set the sender and recipient,
|
||||
// and send the email all in one step.
|
||||
content_type := "Content-Type: text/plain" + "; charset=UTF-8" |
||||
mailmsg := []byte("To: " + strings.Join(s.RecipientAddresses, ";") + "\r\nFrom: " + s.Username + "<" + s.Username + |
||||
">\r\nSubject: " + s.Subject + "\r\n" + content_type + "\r\n\r\n" + fmt.Sprintf(".%s", time.Now().Format("2006-01-02 15:04:05")) + msg) |
||||
|
||||
return smtp.SendMail( |
||||
s.Host, |
||||
auth, |
||||
s.Username, |
||||
s.RecipientAddresses, |
||||
mailmsg, |
||||
) |
||||
} |
||||
|
||||
func (_ *SmtpWriter) Flush() { |
||||
} |
||||
|
||||
func (_ *SmtpWriter) Destroy() { |
||||
} |
||||
|
||||
func init() { |
||||
Register("smtp", NewSmtpWriter) |
||||
} |
||||
Loading…
Reference in new issue