Godep workspace -> vendor/

vendor/github.com/astaxie/beego/logs/README.md

@@ -0,0 +1,63 @@
+## logs
+logs is a Go logs manager. It can use many logs adapters. The repo is inspired by `database/sql` .
+
+
+## How to install?
+
+	go get github.com/astaxie/beego/logs
+
+
+## What adapters are supported?
+
+As of now this logs support console, file,smtp and conn.
+
+
+## How to use it?
+
+First you must import it
+
+	import (
+		"github.com/astaxie/beego/logs"
+	)
+
+Then init a Log (example with console adapter)
+
+	log := NewLogger(10000)
+	log.SetLogger("console", "")	
+
+> the first params stand for how many channel
+
+Use it like this:	
+	
+	log.Trace("trace")
+	log.Info("info")
+	log.Warn("warning")
+	log.Debug("debug")
+	log.Critical("critical")
+
+
+## File adapter
+
+Configure file adapter like this:
+
+	log := NewLogger(10000)
+	log.SetLogger("file", `{"filename":"test.log"}`)
+
+
+## Conn adapter
+
+Configure like this:
+
+	log := NewLogger(1000)
+	log.SetLogger("conn", `{"net":"tcp","addr":":7020"}`)
+	log.Info("info")
+
+
+## Smtp adapter
+
+Configure like this:
+
+	log := NewLogger(10000)
+	log.SetLogger("smtp", `{"username":"beegotest@gmail.com","password":"xxxxxxxx","host":"smtp.gmail.com:587","sendTos":["xiemengjun@gmail.com"]}`)
+	log.Critical("sendmail critical")
+	time.Sleep(time.Second * 30)

vendor/github.com/astaxie/beego/logs/conn.go

@@ -0,0 +1,116 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package logs
+
+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 = LevelTrace
+	return conn
+}
+
+// init connection writer with json config.
+// json config only need key "level".
+func (c *ConnWriter) Init(jsonconfig string) error {
+	return json.Unmarshal([]byte(jsonconfig), c)
+}
+
+// write message in connection.
+// if connection is down, try to re-connect.
+func (c *ConnWriter) WriteMsg(msg string, level int) error {
+	if level > c.Level {
+		return nil
+	}
+	if c.neddedConnectOnMsg() {
+		err := c.connect()
+		if err != nil {
+			return err
+		}
+	}
+
+	if c.ReconnectOnMsg {
+		defer c.innerWriter.Close()
+	}
+	c.lg.Println(msg)
+	return nil
+}
+
+// implementing method. empty.
+func (c *ConnWriter) Flush() {
+
+}
+
+// destroy connection writer and close tcp listener.
+func (c *ConnWriter) Destroy() {
+	if c.innerWriter != nil {
+		c.innerWriter.Close()
+	}
+}
+
+func (c *ConnWriter) connect() error {
+	if c.innerWriter != nil {
+		c.innerWriter.Close()
+		c.innerWriter = nil
+	}
+
+	conn, err := net.Dial(c.Net, c.Addr)
+	if err != nil {
+		return err
+	}
+
+	if tcpConn, ok := conn.(*net.TCPConn); ok {
+		tcpConn.SetKeepAlive(true)
+	}
+
+	c.innerWriter = conn
+	c.lg = log.New(conn, "", log.Ldate|log.Ltime)
+	return nil
+}
+
+func (c *ConnWriter) neddedConnectOnMsg() bool {
+	if c.Reconnect {
+		c.Reconnect = false
+		return true
+	}
+
+	if c.innerWriter == nil {
+		return true
+	}
+
+	return c.ReconnectOnMsg
+}
+
+func init() {
+	Register("conn", NewConn)
+}

vendor/github.com/astaxie/beego/logs/console.go

@@ -0,0 +1,95 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package logs
+
+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;37"), // Emergency	white
+	NewBrush("1;36"), // Alert			cyan
+	NewBrush("1;35"), // Critical   magenta
+	NewBrush("1;31"), // Error      red
+	NewBrush("1;33"), // Warning    yellow
+	NewBrush("1;32"), // Notice			green
+	NewBrush("1;34"), // Informational	blue
+	NewBrush("1;34"), // Debug      blue
+}
+
+// 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 {
+	cw := &ConsoleWriter{
+		lg:    log.New(os.Stdout, "", log.Ldate|log.Ltime),
+		Level: LevelDebug,
+	}
+	return cw
+}
+
+// init console logger.
+// jsonconfig like '{"level":LevelTrace}'.
+func (c *ConsoleWriter) Init(jsonconfig string) error {
+	if len(jsonconfig) == 0 {
+		return nil
+	}
+	return json.Unmarshal([]byte(jsonconfig), c)
+}
+
+// write message in console.
+func (c *ConsoleWriter) WriteMsg(msg string, level int) error {
+	if level > c.Level {
+		return nil
+	}
+	if goos := runtime.GOOS; goos == "windows" {
+		c.lg.Println(msg)
+		return nil
+	}
+	c.lg.Println(colors[level](msg))
+
+	return nil
+}
+
+// implementing method. empty.
+func (c *ConsoleWriter) Destroy() {
+
+}
+
+// implementing method. empty.
+func (c *ConsoleWriter) Flush() {
+
+}
+
+func init() {
+	Register("console", NewConsole)
+}

vendor/github.com/astaxie/beego/logs/file.go

@@ -0,0 +1,283 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package logs
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"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:    LevelTrace,
+	}
+	// 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.
+// jsonconfig like:
+//	{
+//	"filename":"logs/beego.log",
+//	"maxlines":10000,
+//	"maxsize":1<<30,
+//	"daily":true,
+//	"maxdays":15,
+//	"rotate":true
+//	}
+func (w *FileLogWriter) Init(jsonconfig string) error {
+	err := json.Unmarshal([]byte(jsonconfig), w)
+	if err != nil {
+		return err
+	}
+	if len(w.Filename) == 0 {
+		return errors.New("jsonconfig must have filename")
+	}
+	err = w.startLogger()
+	return err
+}
+
+// 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)
+	return w.initFd()
+}
+
+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, 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
+	fd, err := os.OpenFile(w.Filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0660)
+	return fd, err
+}
+
+func (w *FileLogWriter) initFd() error {
+	fd := w.mw.fd
+	finfo, err := fd.Stat()
+	if err != nil {
+		return fmt.Errorf("get stat err: %s\n", err)
+	}
+	w.maxsize_cursize = int(finfo.Size())
+	w.daily_opendate = time.Now().Day()
+	w.maxlines_curlines = 0
+	if finfo.Size() > 0 {
+		count, err := w.lines()
+		if err != nil {
+			return err
+		}
+		w.maxlines_curlines = count
+	}
+	return nil
+}
+
+func (w *FileLogWriter) lines() (int, error) {
+	fd, err := os.Open(w.Filename)
+	if err != nil {
+		return 0, err
+	}
+	defer fd.Close()
+
+	buf := make([]byte, 32768) // 32k
+	count := 0
+	lineSep := []byte{'\n'}
+
+	for {
+		c, err := fd.Read(buf)
+		if err != nil && err != io.EOF {
+			return count, err
+		}
+
+		count += bytes.Count(buf[:c], lineSep)
+
+		if err == io.EOF {
+			break
+		}
+	}
+
+	return count, 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
+		err = os.Rename(w.Filename, fname)
+		if err != nil {
+			return fmt.Errorf("Rotate: %s\n", err)
+		}
+
+		// re-start logger
+		err = w.startLogger()
+		if 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)
+				fmt.Println(returnErr)
+			}
+		}()
+
+		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
+	})
+}
+
+// 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)
+}

vendor/github.com/astaxie/beego/logs/log.go

@@ -0,0 +1,350 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Usage:
+//
+// import "github.com/astaxie/beego/logs"
+//
+//	log := NewLogger(10000)
+//	log.SetLogger("console", "")
+//
+//	> the first params stand for how many channel
+//
+// Use it like this:
+//
+//	log.Trace("trace")
+//	log.Info("info")
+//	log.Warn("warning")
+//	log.Debug("debug")
+//	log.Critical("critical")
+//
+//  more docs http://beego.me/docs/module/logs.md
+package logs
+
+import (
+	"fmt"
+	"path"
+	"runtime"
+	"sync"
+)
+
+// RFC5424 log message levels.
+const (
+	LevelEmergency = iota
+	LevelAlert
+	LevelCritical
+	LevelError
+	LevelWarning
+	LevelNotice
+	LevelInformational
+	LevelDebug
+)
+
+// Legacy loglevel constants to ensure backwards compatibility.
+//
+// Deprecated: will be removed in 1.5.0.
+const (
+	LevelInfo  = LevelInformational
+	LevelTrace = LevelDebug
+	LevelWarn  = LevelWarning
+)
+
+type loggerType func() LoggerInterface
+
+// LoggerInterface defines the behavior of a log provider.
+type LoggerInterface interface {
+	Init(config string) error
+	WriteMsg(msg string, level int) error
+	Destroy()
+	Flush()
+}
+
+var adapters = make(map[string]loggerType)
+
+// Register makes a log provide available by the provided name.
+// If Register is called twice with the same name or if driver is nil,
+// it panics.
+func Register(name string, log loggerType) {
+	if log == nil {
+		panic("logs: Register provide is nil")
+	}
+	if _, dup := adapters[name]; dup {
+		panic("logs: Register called twice for provider " + name)
+	}
+	adapters[name] = log
+}
+
+// BeeLogger is default logger in beego application.
+// it can contain several providers and log message into all providers.
+type BeeLogger struct {
+	lock                sync.Mutex
+	level               int
+	enableFuncCallDepth bool
+	loggerFuncCallDepth int
+	asynchronous        bool
+	msg                 chan *logMsg
+	outputs             map[string]LoggerInterface
+}
+
+type logMsg struct {
+	level int
+	msg   string
+}
+
+// NewLogger returns a new BeeLogger.
+// channellen means the number of messages in chan.
+// if the buffering chan is full, logger adapters write to file or other way.
+func NewLogger(channellen int64) *BeeLogger {
+	bl := new(BeeLogger)
+	bl.level = LevelDebug
+	bl.loggerFuncCallDepth = 2
+	bl.msg = make(chan *logMsg, channellen)
+	bl.outputs = make(map[string]LoggerInterface)
+	return bl
+}
+
+func (bl *BeeLogger) Async() *BeeLogger {
+	bl.asynchronous = true
+	go bl.startLogger()
+	return bl
+}
+
+// SetLogger provides a given logger adapter into BeeLogger with config string.
+// config need to be correct JSON as string: {"interval":360}.
+func (bl *BeeLogger) SetLogger(adaptername string, config string) error {
+	bl.lock.Lock()
+	defer bl.lock.Unlock()
+	if log, ok := adapters[adaptername]; ok {
+		lg := log()
+		err := lg.Init(config)
+		bl.outputs[adaptername] = lg
+		if err != nil {
+			fmt.Println("logs.BeeLogger.SetLogger: " + err.Error())
+			return err
+		}
+	} else {
+		return fmt.Errorf("logs: unknown adaptername %q (forgotten Register?)", adaptername)
+	}
+	return nil
+}
+
+// remove a logger adapter in BeeLogger.
+func (bl *BeeLogger) DelLogger(adaptername string) error {
+	bl.lock.Lock()
+	defer bl.lock.Unlock()
+	if lg, ok := bl.outputs[adaptername]; ok {
+		lg.Destroy()
+		delete(bl.outputs, adaptername)
+		return nil
+	} else {
+		return fmt.Errorf("logs: unknown adaptername %q (forgotten Register?)", adaptername)
+	}
+}
+
+func (bl *BeeLogger) writerMsg(loglevel int, msg string) error {
+	lm := new(logMsg)
+	lm.level = loglevel
+	if bl.enableFuncCallDepth {
+		_, file, line, ok := runtime.Caller(bl.loggerFuncCallDepth)
+		if !ok {
+			file = "???"
+			line = 0
+		}
+		_, filename := path.Split(file)
+		lm.msg = fmt.Sprintf("[%s:%d] %s", filename, line, msg)
+	} else {
+		lm.msg = msg
+	}
+	if bl.asynchronous {
+		bl.msg <- lm
+	} else {
+		for name, l := range bl.outputs {
+			err := l.WriteMsg(lm.msg, lm.level)
+			if err != nil {
+				fmt.Println("unable to WriteMsg to adapter:", name, err)
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// Set log message level.
+//
+// If message level (such as LevelDebug) is higher than logger level (such as LevelWarning),
+// log providers will not even be sent the message.
+func (bl *BeeLogger) SetLevel(l int) {
+	bl.level = l
+}
+
+// set log funcCallDepth
+func (bl *BeeLogger) SetLogFuncCallDepth(d int) {
+	bl.loggerFuncCallDepth = d
+}
+
+// get log funcCallDepth for wrapper
+func (bl *BeeLogger) GetLogFuncCallDepth() int {
+	return bl.loggerFuncCallDepth
+}
+
+// enable log funcCallDepth
+func (bl *BeeLogger) EnableFuncCallDepth(b bool) {
+	bl.enableFuncCallDepth = b
+}
+
+// start logger chan reading.
+// when chan is not empty, write logs.
+func (bl *BeeLogger) startLogger() {
+	for {
+		select {
+		case bm := <-bl.msg:
+			for _, l := range bl.outputs {
+				err := l.WriteMsg(bm.msg, bm.level)
+				if err != nil {
+					fmt.Println("ERROR, unable to WriteMsg:", err)
+				}
+			}
+		}
+	}
+}
+
+// Log EMERGENCY level message.
+func (bl *BeeLogger) Emergency(format string, v ...interface{}) {
+	if LevelEmergency > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[M] "+format, v...)
+	bl.writerMsg(LevelEmergency, msg)
+}
+
+// Log ALERT level message.
+func (bl *BeeLogger) Alert(format string, v ...interface{}) {
+	if LevelAlert > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[A] "+format, v...)
+	bl.writerMsg(LevelAlert, msg)
+}
+
+// Log CRITICAL level message.
+func (bl *BeeLogger) Critical(format string, v ...interface{}) {
+	if LevelCritical > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[C] "+format, v...)
+	bl.writerMsg(LevelCritical, msg)
+}
+
+// Log ERROR level message.
+func (bl *BeeLogger) Error(format string, v ...interface{}) {
+	if LevelError > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[E] "+format, v...)
+	bl.writerMsg(LevelError, msg)
+}
+
+// Log WARNING level message.
+func (bl *BeeLogger) Warning(format string, v ...interface{}) {
+	if LevelWarning > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[W] "+format, v...)
+	bl.writerMsg(LevelWarning, msg)
+}
+
+// Log NOTICE level message.
+func (bl *BeeLogger) Notice(format string, v ...interface{}) {
+	if LevelNotice > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[N] "+format, v...)
+	bl.writerMsg(LevelNotice, msg)
+}
+
+// Log INFORMATIONAL level message.
+func (bl *BeeLogger) Informational(format string, v ...interface{}) {
+	if LevelInformational > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[I] "+format, v...)
+	bl.writerMsg(LevelInformational, msg)
+}
+
+// Log DEBUG level message.
+func (bl *BeeLogger) Debug(format string, v ...interface{}) {
+	if LevelDebug > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[D] "+format, v...)
+	bl.writerMsg(LevelDebug, msg)
+}
+
+// Log WARN level message.
+// compatibility alias for Warning()
+func (bl *BeeLogger) Warn(format string, v ...interface{}) {
+	if LevelWarning > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[W] "+format, v...)
+	bl.writerMsg(LevelWarning, msg)
+}
+
+// Log INFO level message.
+// compatibility alias for Informational()
+func (bl *BeeLogger) Info(format string, v ...interface{}) {
+	if LevelInformational > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[I] "+format, v...)
+	bl.writerMsg(LevelInformational, msg)
+}
+
+// Log TRACE level message.
+// compatibility alias for Debug()
+func (bl *BeeLogger) Trace(format string, v ...interface{}) {
+	if LevelDebug > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[D] "+format, v...)
+	bl.writerMsg(LevelDebug, msg)
+}
+
+// flush all chan data.
+func (bl *BeeLogger) Flush() {
+	for _, l := range bl.outputs {
+		l.Flush()
+	}
+}
+
+// close logger, flush all chan data and destroy all adapters in BeeLogger.
+func (bl *BeeLogger) Close() {
+	for {
+		if len(bl.msg) > 0 {
+			bm := <-bl.msg
+			for _, l := range bl.outputs {
+				err := l.WriteMsg(bm.msg, bm.level)
+				if err != nil {
+					fmt.Println("ERROR, unable to WriteMsg (while closing logger):", err)
+				}
+			}
+			continue
+		}
+		break
+	}
+	for _, l := range bl.outputs {
+		l.Flush()
+		l.Destroy()
+	}
+}

vendor/github.com/astaxie/beego/logs/smtp.go

@@ -0,0 +1,165 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package logs
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/smtp"
+	"strings"
+	"time"
+)
+
+const (
+// no usage
+// 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"`
+	FromAddress        string   `json:"fromAddress"`
+	RecipientAddresses []string `json:"sendTos"`
+	Level              int      `json:"level"`
+}
+
+// create smtp writer.
+func NewSmtpWriter() LoggerInterface {
+	return &SmtpWriter{Level: LevelTrace}
+}
+
+// init smtp writer with json config.
+// config like:
+//	{
+//		"Username":"example@gmail.com",
+//		"password:"password",
+//		"host":"smtp.gmail.com:465",
+//		"subject":"email title",
+//		"fromAddress":"from@example.com",
+//		"sendTos":["email1","email2"],
+//		"level":LevelError
+//	}
+func (s *SmtpWriter) Init(jsonconfig string) error {
+	err := json.Unmarshal([]byte(jsonconfig), s)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *SmtpWriter) GetSmtpAuth(host string) smtp.Auth {
+	if len(strings.Trim(s.Username, " ")) == 0 && len(strings.Trim(s.Password, " ")) == 0 {
+		return nil
+	}
+	return smtp.PlainAuth(
+		"",
+		s.Username,
+		s.Password,
+		host,
+	)
+}
+
+func (s *SmtpWriter) sendMail(hostAddressWithPort string, auth smtp.Auth, fromAddress string, recipients []string, msgContent []byte) error {
+	client, err := smtp.Dial(hostAddressWithPort)
+	if err != nil {
+		return err
+	}
+
+	host, _, _ := net.SplitHostPort(hostAddressWithPort)
+	tlsConn := &tls.Config{
+		InsecureSkipVerify: true,
+		ServerName:         host,
+	}
+	if err = client.StartTLS(tlsConn); err != nil {
+		return err
+	}
+
+	if auth != nil {
+		if err = client.Auth(auth); err != nil {
+			return err
+		}
+	}
+
+	if err = client.Mail(fromAddress); err != nil {
+		return err
+	}
+
+	for _, rec := range recipients {
+		if err = client.Rcpt(rec); err != nil {
+			return err
+		}
+	}
+
+	w, err := client.Data()
+	if err != nil {
+		return err
+	}
+	_, err = w.Write([]byte(msgContent))
+	if err != nil {
+		return err
+	}
+
+	err = w.Close()
+	if err != nil {
+		return err
+	}
+
+	err = client.Quit()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// write message in smtp writer.
+// it will send an email with subject and only this message.
+func (s *SmtpWriter) WriteMsg(msg string, level int) error {
+	if level > s.Level {
+		return nil
+	}
+
+	hp := strings.Split(s.Host, ":")
+
+	// Set up authentication information.
+	auth := s.GetSmtpAuth(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.FromAddress + "<" + s.FromAddress +
+		">\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 s.sendMail(s.Host, auth, s.FromAddress, s.RecipientAddresses, mailmsg)
+}
+
+// implementing method. empty.
+func (s *SmtpWriter) Flush() {
+	return
+}
+
+// implementing method. empty.
+func (s *SmtpWriter) Destroy() {
+	return
+}
+
+func init() {
+	Register("smtp", NewSmtpWriter)
+}