Merge pull request #2485 from astaxie/develop

beego 1.8.0

.github/ISSUE_TEMPLATE

@@ -0,0 +1,17 @@
+Please answer these questions before submitting your issue. Thanks!
+
+1. What version of Go and beego are you using (`bee version`)?
+
+
+2. What operating system and processor architecture are you using (`go env`)?
+
+
+3. What did you do?
+If possible, provide a recipe for reproducing the error.
+A complete runnable program is good.
+
+
+4. What did you expect to see?
+
+
+5. What did you see instead?

.gitignore

@@ -1,4 +1,5 @@
 .idea
+.vscode
 .DS_Store
 *.swp
 *.swo

.travis.yml

@@ -1,8 +1,7 @@
 language: go
 
 go:
-  - tip
+  - 1.6
-  - 1.6.0
   - 1.5.3
   - 1.4.3
 services:
@@ -31,21 +30,22 @@ install:
   - go get github.com/belogik/goes
   - go get github.com/siddontang/ledisdb/config
   - go get github.com/siddontang/ledisdb/ledis
-  - go get golang.org/x/tools/cmd/vet
-  - go get github.com/golang/lint/golint
   - go get github.com/ssdb/gossdb/ssdb
+  - go get github.com/cloudflare/golz4
+  - go get github.com/gogo/protobuf/proto
 before_script:
+  - psql --version
   - sh -c "if [ '$ORM_DRIVER' = 'postgres' ]; then psql -c 'create database orm_test;' -U postgres; fi"
   - sh -c "if [ '$ORM_DRIVER' = 'mysql' ]; then mysql -u root -e 'create database orm_test;'; fi"
   - sh -c "if [ '$ORM_DRIVER' = 'sqlite' ]; then touch $TRAVIS_BUILD_DIR/orm_test.db; fi"
+  - sh -c "if [ $(go version) == *1.[5-9]* ]; then go get github.com/golang/lint/golint; golint ./...; fi"
+  - sh -c "if [ $(go version) == *1.[5-9]* ]; then go tool vet .; fi"
   - mkdir -p res/var
   - ./ssdb/ssdb-server ./ssdb/ssdb.conf -d
 after_script:
   -killall -w ssdb-server
   - rm -rf ./res/var/*
 script:
-  - go vet -x ./...
-  - $HOME/gopath/bin/golint ./...
   - go test -v ./...
-notifications:
+addons:
-  webhooks: https://hooks.pubu.im/services/z7m9bvybl3rgtg9
+  postgresql: "9.4"

README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://travis-ci.org/astaxie/beego.svg?branch=master)](https://travis-ci.org/astaxie/beego)
 [![GoDoc](http://godoc.org/github.com/astaxie/beego?status.svg)](http://godoc.org/github.com/astaxie/beego)
+[![Foundation](https://img.shields.io/badge/Golang-Foundation-green.svg)](http://golangfoundation.org)
 
 beego is used for rapid development of RESTful APIs, web apps and backend services in Go.
 It is inspired by Tornado, Sinatra and Flask. beego has some Go-specific features such as interfaces and struct embedding.
@@ -30,7 +31,7 @@ func main(){
 ```
 ######Congratulations! 
 You just built your first beego app.
-Open your browser and visit `http://localhost:8000`.
+Open your browser and visit `http://localhost:8080`.
 Please see [Documentation](http://beego.me/docs) for more.
 
 ## Features

admin.go

@@ -23,7 +23,10 @@ import (
 	"text/template"
 	"time"
 
+	"reflect"
+
 	"github.com/astaxie/beego/grace"
+	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/toolbox"
 	"github.com/astaxie/beego/utils"
 )
@@ -90,57 +93,9 @@ func listConf(rw http.ResponseWriter, r *http.Request) {
 	switch command {
 	case "conf":
 		m := make(map[string]interface{})
+		list("BConfig", BConfig, m)
 		m["AppConfigPath"] = appConfigPath
 		m["AppConfigProvider"] = appConfigProvider
-		m["BConfig.AppName"] = BConfig.AppName
-		m["BConfig.RunMode"] = BConfig.RunMode
-		m["BConfig.RouterCaseSensitive"] = BConfig.RouterCaseSensitive
-		m["BConfig.ServerName"] = BConfig.ServerName
-		m["BConfig.RecoverPanic"] = BConfig.RecoverPanic
-		m["BConfig.CopyRequestBody"] = BConfig.CopyRequestBody
-		m["BConfig.EnableGzip"] = BConfig.EnableGzip
-		m["BConfig.MaxMemory"] = BConfig.MaxMemory
-		m["BConfig.EnableErrorsShow"] = BConfig.EnableErrorsShow
-		m["BConfig.Listen.Graceful"] = BConfig.Listen.Graceful
-		m["BConfig.Listen.ServerTimeOut"] = BConfig.Listen.ServerTimeOut
-		m["BConfig.Listen.ListenTCP4"] = BConfig.Listen.ListenTCP4
-		m["BConfig.Listen.EnableHTTP"] = BConfig.Listen.EnableHTTP
-		m["BConfig.Listen.HTTPAddr"] = BConfig.Listen.HTTPAddr
-		m["BConfig.Listen.HTTPPort"] = BConfig.Listen.HTTPPort
-		m["BConfig.Listen.EnableHTTPS"] = BConfig.Listen.EnableHTTPS
-		m["BConfig.Listen.HTTPSAddr"] = BConfig.Listen.HTTPSAddr
-		m["BConfig.Listen.HTTPSPort"] = BConfig.Listen.HTTPSPort
-		m["BConfig.Listen.HTTPSCertFile"] = BConfig.Listen.HTTPSCertFile
-		m["BConfig.Listen.HTTPSKeyFile"] = BConfig.Listen.HTTPSKeyFile
-		m["BConfig.Listen.EnableAdmin"] = BConfig.Listen.EnableAdmin
-		m["BConfig.Listen.AdminAddr"] = BConfig.Listen.AdminAddr
-		m["BConfig.Listen.AdminPort"] = BConfig.Listen.AdminPort
-		m["BConfig.Listen.EnableFcgi"] = BConfig.Listen.EnableFcgi
-		m["BConfig.Listen.EnableStdIo"] = BConfig.Listen.EnableStdIo
-		m["BConfig.WebConfig.AutoRender"] = BConfig.WebConfig.AutoRender
-		m["BConfig.WebConfig.EnableDocs"] = BConfig.WebConfig.EnableDocs
-		m["BConfig.WebConfig.FlashName"] = BConfig.WebConfig.FlashName
-		m["BConfig.WebConfig.FlashSeparator"] = BConfig.WebConfig.FlashSeparator
-		m["BConfig.WebConfig.DirectoryIndex"] = BConfig.WebConfig.DirectoryIndex
-		m["BConfig.WebConfig.StaticDir"] = BConfig.WebConfig.StaticDir
-		m["BConfig.WebConfig.StaticExtensionsToGzip"] = BConfig.WebConfig.StaticExtensionsToGzip
-		m["BConfig.WebConfig.TemplateLeft"] = BConfig.WebConfig.TemplateLeft
-		m["BConfig.WebConfig.TemplateRight"] = BConfig.WebConfig.TemplateRight
-		m["BConfig.WebConfig.ViewsPath"] = BConfig.WebConfig.ViewsPath
-		m["BConfig.WebConfig.EnableXSRF"] = BConfig.WebConfig.EnableXSRF
-		m["BConfig.WebConfig.XSRFKEY"] = BConfig.WebConfig.XSRFKey
-		m["BConfig.WebConfig.XSRFExpire"] = BConfig.WebConfig.XSRFExpire
-		m["BConfig.WebConfig.Session.SessionOn"] = BConfig.WebConfig.Session.SessionOn
-		m["BConfig.WebConfig.Session.SessionProvider"] = BConfig.WebConfig.Session.SessionProvider
-		m["BConfig.WebConfig.Session.SessionName"] = BConfig.WebConfig.Session.SessionName
-		m["BConfig.WebConfig.Session.SessionGCMaxLifetime"] = BConfig.WebConfig.Session.SessionGCMaxLifetime
-		m["BConfig.WebConfig.Session.SessionProviderConfig"] = BConfig.WebConfig.Session.SessionProviderConfig
-		m["BConfig.WebConfig.Session.SessionCookieLifeTime"] = BConfig.WebConfig.Session.SessionCookieLifeTime
-		m["BConfig.WebConfig.Session.SessionAutoSetCookie"] = BConfig.WebConfig.Session.SessionAutoSetCookie
-		m["BConfig.WebConfig.Session.SessionDomain"] = BConfig.WebConfig.Session.SessionDomain
-		m["BConfig.Log.AccessLogs"] = BConfig.Log.AccessLogs
-		m["BConfig.Log.FileLineNum"] = BConfig.Log.FileLineNum
-		m["BConfig.Log.Outputs"] = BConfig.Log.Outputs
 		tmpl := template.Must(template.New("dashboard").Parse(dashboardTpl))
 		tmpl = template.Must(tmpl.Parse(configTpl))
 		tmpl = template.Must(tmpl.Parse(defaultScriptsTpl))
@@ -196,7 +151,7 @@ func listConf(rw http.ResponseWriter, r *http.Request) {
 				BeforeExec:   "Before Exec",
 				AfterExec:    "After Exec",
 				FinishRouter: "Finish Router"} {
-				if bf, ok := BeeApp.Handlers.filters[k]; ok {
+				if bf := BeeApp.Handlers.filters[k]; len(bf) > 0 {
 					filterType = fr
 					filterTypes = append(filterTypes, filterType)
 					resultList := new([][]string)
@@ -223,6 +178,28 @@ func listConf(rw http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func list(root string, p interface{}, m map[string]interface{}) {
+	pt := reflect.TypeOf(p)
+	pv := reflect.ValueOf(p)
+	if pt.Kind() == reflect.Ptr {
+		pt = pt.Elem()
+		pv = pv.Elem()
+	}
+	for i := 0; i < pv.NumField(); i++ {
+		var key string
+		if root == "" {
+			key = pt.Field(i).Name
+		} else {
+			key = root + "." + pt.Field(i).Name
+		}
+		if pv.Field(i).Kind() == reflect.Struct {
+			list(key, pv.Field(i).Interface(), m)
+		} else {
+			m[key] = pv.Field(i).Interface()
+		}
+	}
+}
+
 func printTree(resultList *[][]string, t *Tree) {
 	for _, tr := range t.fixrouters {
 		printTree(resultList, tr)
@@ -410,7 +387,7 @@ func (admin *adminApp) Run() {
 	for p, f := range admin.routers {
 		http.Handle(p, f)
 	}
-	BeeLogger.Info("Admin server Running on %s", addr)
+	logs.Info("Admin server Running on %s", addr)
 
 	var err error
 	if BConfig.Listen.Graceful {
@@ -419,6 +396,6 @@ func (admin *adminApp) Run() {
 		err = http.ListenAndServe(addr, nil)
 	}
 	if err != nil {
-		BeeLogger.Critical("Admin ListenAndServe: ", err, fmt.Sprintf("%d", os.Getpid()))
+		logs.Critical("Admin ListenAndServe: ", err, fmt.Sprintf("%d", os.Getpid()))
 	}
 }

admin_test.go

@@ -0,0 +1,73 @@
+package beego
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestList_01(t *testing.T) {
+	m := make(map[string]interface{})
+	list("BConfig", BConfig, m)
+	t.Log(m)
+	om := oldMap()
+	for k, v := range om {
+		if fmt.Sprint(m[k]) != fmt.Sprint(v) {
+			t.Log(k, "old-key", v, "new-key", m[k])
+			t.FailNow()
+		}
+	}
+}
+
+func oldMap() map[string]interface{} {
+	m := make(map[string]interface{})
+	m["BConfig.AppName"] = BConfig.AppName
+	m["BConfig.RunMode"] = BConfig.RunMode
+	m["BConfig.RouterCaseSensitive"] = BConfig.RouterCaseSensitive
+	m["BConfig.ServerName"] = BConfig.ServerName
+	m["BConfig.RecoverPanic"] = BConfig.RecoverPanic
+	m["BConfig.CopyRequestBody"] = BConfig.CopyRequestBody
+	m["BConfig.EnableGzip"] = BConfig.EnableGzip
+	m["BConfig.MaxMemory"] = BConfig.MaxMemory
+	m["BConfig.EnableErrorsShow"] = BConfig.EnableErrorsShow
+	m["BConfig.Listen.Graceful"] = BConfig.Listen.Graceful
+	m["BConfig.Listen.ServerTimeOut"] = BConfig.Listen.ServerTimeOut
+	m["BConfig.Listen.ListenTCP4"] = BConfig.Listen.ListenTCP4
+	m["BConfig.Listen.EnableHTTP"] = BConfig.Listen.EnableHTTP
+	m["BConfig.Listen.HTTPAddr"] = BConfig.Listen.HTTPAddr
+	m["BConfig.Listen.HTTPPort"] = BConfig.Listen.HTTPPort
+	m["BConfig.Listen.EnableHTTPS"] = BConfig.Listen.EnableHTTPS
+	m["BConfig.Listen.HTTPSAddr"] = BConfig.Listen.HTTPSAddr
+	m["BConfig.Listen.HTTPSPort"] = BConfig.Listen.HTTPSPort
+	m["BConfig.Listen.HTTPSCertFile"] = BConfig.Listen.HTTPSCertFile
+	m["BConfig.Listen.HTTPSKeyFile"] = BConfig.Listen.HTTPSKeyFile
+	m["BConfig.Listen.EnableAdmin"] = BConfig.Listen.EnableAdmin
+	m["BConfig.Listen.AdminAddr"] = BConfig.Listen.AdminAddr
+	m["BConfig.Listen.AdminPort"] = BConfig.Listen.AdminPort
+	m["BConfig.Listen.EnableFcgi"] = BConfig.Listen.EnableFcgi
+	m["BConfig.Listen.EnableStdIo"] = BConfig.Listen.EnableStdIo
+	m["BConfig.WebConfig.AutoRender"] = BConfig.WebConfig.AutoRender
+	m["BConfig.WebConfig.EnableDocs"] = BConfig.WebConfig.EnableDocs
+	m["BConfig.WebConfig.FlashName"] = BConfig.WebConfig.FlashName
+	m["BConfig.WebConfig.FlashSeparator"] = BConfig.WebConfig.FlashSeparator
+	m["BConfig.WebConfig.DirectoryIndex"] = BConfig.WebConfig.DirectoryIndex
+	m["BConfig.WebConfig.StaticDir"] = BConfig.WebConfig.StaticDir
+	m["BConfig.WebConfig.StaticExtensionsToGzip"] = BConfig.WebConfig.StaticExtensionsToGzip
+	m["BConfig.WebConfig.TemplateLeft"] = BConfig.WebConfig.TemplateLeft
+	m["BConfig.WebConfig.TemplateRight"] = BConfig.WebConfig.TemplateRight
+	m["BConfig.WebConfig.ViewsPath"] = BConfig.WebConfig.ViewsPath
+	m["BConfig.WebConfig.EnableXSRF"] = BConfig.WebConfig.EnableXSRF
+	m["BConfig.WebConfig.XSRFExpire"] = BConfig.WebConfig.XSRFExpire
+	m["BConfig.WebConfig.Session.SessionOn"] = BConfig.WebConfig.Session.SessionOn
+	m["BConfig.WebConfig.Session.SessionProvider"] = BConfig.WebConfig.Session.SessionProvider
+	m["BConfig.WebConfig.Session.SessionName"] = BConfig.WebConfig.Session.SessionName
+	m["BConfig.WebConfig.Session.SessionGCMaxLifetime"] = BConfig.WebConfig.Session.SessionGCMaxLifetime
+	m["BConfig.WebConfig.Session.SessionProviderConfig"] = BConfig.WebConfig.Session.SessionProviderConfig
+	m["BConfig.WebConfig.Session.SessionCookieLifeTime"] = BConfig.WebConfig.Session.SessionCookieLifeTime
+	m["BConfig.WebConfig.Session.SessionAutoSetCookie"] = BConfig.WebConfig.Session.SessionAutoSetCookie
+	m["BConfig.WebConfig.Session.SessionDomain"] = BConfig.WebConfig.Session.SessionDomain
+	m["BConfig.WebConfig.Session.SessionDisableHTTPOnly"] = BConfig.WebConfig.Session.SessionDisableHTTPOnly
+	m["BConfig.Log.AccessLogs"] = BConfig.Log.AccessLogs
+	m["BConfig.Log.FileLineNum"] = BConfig.Log.FileLineNum
+	m["BConfig.Log.Outputs"] = BConfig.Log.Outputs
+	return m
+}

adminui.go

@@ -78,13 +78,14 @@ var qpsTpl = `{{define "content"}}
 	{{range $i, $elem := .Content.Data}}
 
 	<tr>
-		{{range $elem}}
+	    <td>{{index $elem 0}}</td>
-			<td>
+	    <td>{{index $elem 1}}</td>
-			{{.}}
+	    <td>{{index $elem 2}}</td>
-			</td>
+	    <td data-order="{{index $elem 3}}">{{index $elem 4}}</td>
-		{{end}}
+	    <td data-order="{{index $elem 5}}">{{index $elem 6}}</td>
+	    <td data-order="{{index $elem 7}}">{{index $elem 8}}</td>
+	    <td data-order="{{index $elem 9}}">{{index $elem 10}}</td>
 	</tr>
-
 	{{end}}
 	</tbody>
 

app.go

@@ -24,6 +24,7 @@ import (
 	"time"
 
 	"github.com/astaxie/beego/grace"
+	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/utils"
 )
 
@@ -68,9 +69,9 @@ func (app *App) Run() {
 	if BConfig.Listen.EnableFcgi {
 		if BConfig.Listen.EnableStdIo {
 			if err = fcgi.Serve(nil, app.Handlers); err == nil { // standard I/O
-				BeeLogger.Info("Use FCGI via standard I/O")
+				logs.Info("Use FCGI via standard I/O")
 			} else {
-				BeeLogger.Critical("Cannot use FCGI via standard I/O", err)
+				logs.Critical("Cannot use FCGI via standard I/O", err)
 			}
 			return
 		}
@@ -84,10 +85,10 @@ func (app *App) Run() {
 			l, err = net.Listen("tcp", addr)
 		}
 		if err != nil {
-			BeeLogger.Critical("Listen: ", err)
+			logs.Critical("Listen: ", err)
 		}
 		if err = fcgi.Serve(l, app.Handlers); err != nil {
-			BeeLogger.Critical("fcgi.Serve: ", err)
+			logs.Critical("fcgi.Serve: ", err)
 		}
 		return
 	}
@@ -95,6 +96,7 @@ func (app *App) Run() {
 	app.Server.Handler = app.Handlers
 	app.Server.ReadTimeout = time.Duration(BConfig.Listen.ServerTimeOut) * time.Second
 	app.Server.WriteTimeout = time.Duration(BConfig.Listen.ServerTimeOut) * time.Second
+	app.Server.ErrorLog = logs.GetLogger("HTTP")
 
 	// run graceful mode
 	if BConfig.Listen.Graceful {
@@ -111,7 +113,7 @@ func (app *App) Run() {
 				server.Server.ReadTimeout = app.Server.ReadTimeout
 				server.Server.WriteTimeout = app.Server.WriteTimeout
 				if err := server.ListenAndServeTLS(BConfig.Listen.HTTPSCertFile, BConfig.Listen.HTTPSKeyFile); err != nil {
-					BeeLogger.Critical("ListenAndServeTLS: ", err, fmt.Sprintf("%d", os.Getpid()))
+					logs.Critical("ListenAndServeTLS: ", err, fmt.Sprintf("%d", os.Getpid()))
 					time.Sleep(100 * time.Microsecond)
 					endRunning <- true
 				}
@@ -126,7 +128,7 @@ func (app *App) Run() {
 					server.Network = "tcp4"
 				}
 				if err := server.ListenAndServe(); err != nil {
-					BeeLogger.Critical("ListenAndServe: ", err, fmt.Sprintf("%d", os.Getpid()))
+					logs.Critical("ListenAndServe: ", err, fmt.Sprintf("%d", os.Getpid()))
 					time.Sleep(100 * time.Microsecond)
 					endRunning <- true
 				}
@@ -137,16 +139,18 @@ func (app *App) Run() {
 	}
 
 	// run normal mode
-	app.Server.Addr = addr
 	if BConfig.Listen.EnableHTTPS {
 		go func() {
 			time.Sleep(20 * time.Microsecond)
 			if BConfig.Listen.HTTPSPort != 0 {
 				app.Server.Addr = fmt.Sprintf("%s:%d", BConfig.Listen.HTTPSAddr, BConfig.Listen.HTTPSPort)
+			} else if BConfig.Listen.EnableHTTP {
+				BeeLogger.Info("Start https server error, confict with http.Please reset https port")
+				return
 			}
-			BeeLogger.Info("https server Running on %s", app.Server.Addr)
+			logs.Info("https server Running on https://%s", app.Server.Addr)
 			if err := app.Server.ListenAndServeTLS(BConfig.Listen.HTTPSCertFile, BConfig.Listen.HTTPSKeyFile); err != nil {
-				BeeLogger.Critical("ListenAndServeTLS: ", err)
+				logs.Critical("ListenAndServeTLS: ", err)
 				time.Sleep(100 * time.Microsecond)
 				endRunning <- true
 			}
@@ -155,24 +159,24 @@ func (app *App) Run() {
 	if BConfig.Listen.EnableHTTP {
 		go func() {
 			app.Server.Addr = addr
-			BeeLogger.Info("http server Running on %s", app.Server.Addr)
+			logs.Info("http server Running on http://%s", app.Server.Addr)
 			if BConfig.Listen.ListenTCP4 {
 				ln, err := net.Listen("tcp4", app.Server.Addr)
 				if err != nil {
-					BeeLogger.Critical("ListenAndServe: ", err)
+					logs.Critical("ListenAndServe: ", err)
 					time.Sleep(100 * time.Microsecond)
 					endRunning <- true
 					return
 				}
 				if err = app.Server.Serve(ln); err != nil {
-					BeeLogger.Critical("ListenAndServe: ", err)
+					logs.Critical("ListenAndServe: ", err)
 					time.Sleep(100 * time.Microsecond)
 					endRunning <- true
 					return
 				}
 			} else {
 				if err := app.Server.ListenAndServe(); err != nil {
-					BeeLogger.Critical("ListenAndServe: ", err)
+					logs.Critical("ListenAndServe: ", err)
 					time.Sleep(100 * time.Microsecond)
 					endRunning <- true
 				}

beego.go

@@ -23,7 +23,7 @@ import (
 
 const (
 	// VERSION represent beego web framework version.
-	VERSION = "1.6.1"
+	VERSION = "1.8.0"
 
 	// DEV is for develop
 	DEV = "dev"
@@ -51,6 +51,7 @@ func AddAPPStartHook(hf hookfunc) {
 // beego.Run(":8089")
 // beego.Run("127.0.0.1:8089")
 func Run(params ...string) {
+
 	initBeforeHTTPRun()
 
 	if len(params) > 0 && params[0] != "" {
@@ -71,9 +72,9 @@ func initBeforeHTTPRun() {
 	AddAPPStartHook(registerMime)
 	AddAPPStartHook(registerDefaultErrorHandler)
 	AddAPPStartHook(registerSession)
-	AddAPPStartHook(registerDocs)
 	AddAPPStartHook(registerTemplate)
 	AddAPPStartHook(registerAdmin)
+	AddAPPStartHook(registerGzip)
 
 	for _, hk := range hooks {
 		if err := hk(); err != nil {
@@ -84,8 +85,16 @@ func initBeforeHTTPRun() {
 
 // TestBeegoInit is for test package init
 func TestBeegoInit(ap string) {
-	os.Setenv("BEEGO_RUNMODE", "test")
+	path := filepath.Join(ap, "conf", "app.conf")
-	appConfigPath = filepath.Join(ap, "conf", "app.conf")
 	os.Chdir(ap)
+	InitBeegoBeforeTest(path)
+}
+
+// InitBeegoBeforeTest is for test package init
+func InitBeegoBeforeTest(appConfigPath string) {
+	if err := LoadAppConfig(appConfigProvider, appConfigPath); err != nil {
+		panic(err)
+	}
+	BConfig.RunMode = "test"
 	initBeforeHTTPRun()
 }

cache/file.go

@@ -22,6 +22,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -222,33 +223,13 @@ func exists(path string) (bool, error) {
 // FileGetContents Get bytes to file.
 // if non-exist, create this file.
 func FileGetContents(filename string) (data []byte, e error) {
-	f, e := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
+	return ioutil.ReadFile(filename)
-	if e != nil {
-		return
-	}
-	defer f.Close()
-	stat, e := f.Stat()
-	if e != nil {
-		return
-	}
-	data = make([]byte, stat.Size())
-	result, e := f.Read(data)
-	if e != nil || int64(result) != stat.Size() {
-		return nil, e
-	}
-	return
 }
 
 // FilePutContents Put bytes to file.
 // if non-exist, create this file.
 func FilePutContents(filename string, content []byte) error {
-	fp, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
+	return ioutil.WriteFile(filename, content, os.ModePerm)
-	if err != nil {
-		return err
-	}
-	defer fp.Close()
-	_, err = fp.Write(content)
-	return err
 }
 
 // GobEncode Gob encodes file cache item.

cache/memcache/memcache.go

@@ -33,12 +33,10 @@ import (
 	"encoding/json"
 	"errors"
 	"strings"
-
-	"github.com/bradfitz/gomemcache/memcache"
-
 	"time"
 
 	"github.com/astaxie/beego/cache"
+	"github.com/bradfitz/gomemcache/memcache"
 )
 
 // Cache Memcache adapter.
@@ -60,7 +58,7 @@ func (rc *Cache) Get(key string) interface{} {
 		}
 	}
 	if item, err := rc.conn.Get(key); err == nil {
-		return string(item.Value)
+		return item.Value
 	}
 	return nil
 }
@@ -80,7 +78,7 @@ func (rc *Cache) GetMulti(keys []string) []interface{} {
 	mv, err := rc.conn.GetMulti(keys)
 	if err == nil {
 		for _, v := range mv {
-			rv = append(rv, string(v.Value))
+			rv = append(rv, v.Value)
 		}
 		return rv
 	}
@@ -90,18 +88,21 @@ func (rc *Cache) GetMulti(keys []string) []interface{} {
 	return rv
 }
 
-// Put put value to memcache. only support string.
+// Put put value to memcache.
 func (rc *Cache) Put(key string, val interface{}, timeout time.Duration) error {
 	if rc.conn == nil {
 		if err := rc.connectInit(); err != nil {
 			return err
 		}
 	}
-	v, ok := val.(string)
+	item := memcache.Item{Key: key, Expiration: int32(timeout / time.Second)}
-	if !ok {
+	if v, ok := val.([]byte); ok {
-		return errors.New("val must string")
+		item.Value = v
+	} else if str, ok := val.(string); ok {
+		item.Value = []byte(str)
+	} else {
+		return errors.New("val only support string and []byte")
 	}
-	item := memcache.Item{Key: key, Value: []byte(v), Expiration: int32(timeout / time.Second)}
 	return rc.conn.Set(&item)
 }
 

cache/memcache/memcache_test.go

@@ -46,7 +46,7 @@ func TestMemcacheCache(t *testing.T) {
 		t.Error("set Error", err)
 	}
 
-	if v, err := strconv.Atoi(bm.Get("astaxie").(string)); err != nil || v != 1 {
+	if v, err := strconv.Atoi(string(bm.Get("astaxie").([]byte))); err != nil || v != 1 {
 		t.Error("get err")
 	}
 
@@ -54,7 +54,7 @@ func TestMemcacheCache(t *testing.T) {
 		t.Error("Incr Error", err)
 	}
 
-	if v, err := strconv.Atoi(bm.Get("astaxie").(string)); err != nil || v != 2 {
+	if v, err := strconv.Atoi(string(bm.Get("astaxie").([]byte))); err != nil || v != 2 {
 		t.Error("get err")
 	}
 
@@ -62,7 +62,7 @@ func TestMemcacheCache(t *testing.T) {
 		t.Error("Decr Error", err)
 	}
 
-	if v, err := strconv.Atoi(bm.Get("astaxie").(string)); err != nil || v != 1 {
+	if v, err := strconv.Atoi(string(bm.Get("astaxie").([]byte))); err != nil || v != 1 {
 		t.Error("get err")
 	}
 	bm.Delete("astaxie")
@@ -78,7 +78,7 @@ func TestMemcacheCache(t *testing.T) {
 		t.Error("check err")
 	}
 
-	if v := bm.Get("astaxie").(string); v != "author" {
+	if v := bm.Get("astaxie").([]byte); string(v) != "author" {
 		t.Error("get err")
 	}
 
@@ -94,10 +94,10 @@ func TestMemcacheCache(t *testing.T) {
 	if len(vv) != 2 {
 		t.Error("GetMulti ERROR")
 	}
-	if vv[0].(string) != "author" && vv[0].(string) != "author1" {
+	if string(vv[0].([]byte)) != "author" && string(vv[0].([]byte)) != "author1" {
 		t.Error("GetMulti ERROR")
 	}
-	if vv[1].(string) != "author1" && vv[1].(string) != "author" {
+	if string(vv[1].([]byte)) != "author1" && string(vv[1].([]byte)) != "author" {
 		t.Error("GetMulti ERROR")
 	}
 

cache/redis/redis_test.go

@@ -18,9 +18,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/garyburd/redigo/redis"
-
 	"github.com/astaxie/beego/cache"
+	"github.com/garyburd/redigo/redis"
 )
 
 func TestRedisCache(t *testing.T) {

cache/ssdb/ssdb.go

@@ -152,7 +152,7 @@ func (rc *Cache) IsExist(key string) bool {
 	if err != nil {
 		return false
 	}
-	if resp[1] == "1" {
+	if len(resp) == 2 && resp[1] == "1" {
 		return true
 	}
 	return false

cache/ssdb/ssdb_test.go

@@ -1,10 +1,11 @@
 package ssdb
 
 import (
-	"github.com/astaxie/beego/cache"
 	"strconv"
 	"testing"
 	"time"
+
+	"github.com/astaxie/beego/cache"
 )
 
 func TestSsdbcacheCache(t *testing.T) {

config.go

@@ -18,9 +18,13 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"reflect"
+	"runtime"
 	"strings"
 
 	"github.com/astaxie/beego/config"
+	"github.com/astaxie/beego/context"
+	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/session"
 	"github.com/astaxie/beego/utils"
 )
@@ -32,10 +36,12 @@ type Config struct {
 	RouterCaseSensitive bool
 	ServerName          string
 	RecoverPanic        bool
+	RecoverFunc         func(*context.Context)
 	CopyRequestBody     bool
 	EnableGzip          bool
 	MaxMemory           int64
 	EnableErrorsShow    bool
+	EnableErrorsRender  bool
 	Listen              Listen
 	WebConfig           WebConfig
 	Log                 LogConfig
@@ -89,6 +95,10 @@ type SessionConfig struct {
 	SessionCookieLifeTime        int
 	SessionAutoSetCookie         bool
 	SessionDomain                string
+	SessionDisableHTTPOnly       bool // used to allow for cross domain cookies/javascript cookies.
+	SessionEnableSidInHTTPHeader bool //	enable store/get the sessionId into/from http headers
+	SessionNameInHTTPHeader      string
+	SessionEnableSidInURLQuery   bool //	enable get the sessionId from Url Query params
 }
 
 // LogConfig holds Log related config
@@ -115,20 +125,72 @@ var (
 )
 
 func init() {
-	AppPath, _ = filepath.Abs(filepath.Dir(os.Args[0]))
+	BConfig = newBConfig()
+	var err error
+	if AppPath, err = filepath.Abs(filepath.Dir(os.Args[0])); err != nil {
+		panic(err)
+	}
+	workPath, err := os.Getwd()
+	if err != nil {
+		panic(err)
+	}
+	appConfigPath = filepath.Join(workPath, "conf", "app.conf")
+	if !utils.FileExists(appConfigPath) {
+		appConfigPath = filepath.Join(AppPath, "conf", "app.conf")
+		if !utils.FileExists(appConfigPath) {
+			AppConfig = &beegoAppConfig{innerConfig: config.NewFakeConfig()}
+			return
+		}
+	}
+	if err = parseConfig(appConfigPath); err != nil {
+		panic(err)
+	}
+}
 
-	os.Chdir(AppPath)
+func recoverPanic(ctx *context.Context) {
+	if err := recover(); err != nil {
+		if err == ErrAbort {
+			return
+		}
+		if !BConfig.RecoverPanic {
+			panic(err)
+		}
+		if BConfig.EnableErrorsShow {
+			if _, ok := ErrorMaps[fmt.Sprint(err)]; ok {
+				exception(fmt.Sprint(err), ctx)
+				return
+			}
+		}
+		var stack string
+		logs.Critical("the request url is ", ctx.Input.URL())
+		logs.Critical("Handler crashed with error", err)
+		for i := 1; ; i++ {
+			_, file, line, ok := runtime.Caller(i)
+			if !ok {
+				break
+			}
+			logs.Critical(fmt.Sprintf("%s:%d", file, line))
+			stack = stack + fmt.Sprintln(fmt.Sprintf("%s:%d", file, line))
+		}
+		if BConfig.RunMode == DEV && BConfig.EnableErrorsRender {
+			showErr(err, ctx, stack)
+		}
+	}
+}
 
-	BConfig = &Config{
+func newBConfig() *Config {
+	return &Config{
 		AppName:             "beego",
 		RunMode:             DEV,
 		RouterCaseSensitive: true,
 		ServerName:          "beegoServer:" + VERSION,
 		RecoverPanic:        true,
+		RecoverFunc:         recoverPanic,
 		CopyRequestBody:     false,
 		EnableGzip:          false,
 		MaxMemory:           1 << 26, //64MB
 		EnableErrorsShow:    true,
+		EnableErrorsRender:  true,
 		Listen: Listen{
 			Graceful:      false,
 			ServerTimeOut: 0,
@@ -167,9 +229,13 @@ func init() {
 				SessionName:                  "beegosessionID",
 				SessionGCMaxLifetime:         3600,
 				SessionProviderConfig:        "",
+				SessionDisableHTTPOnly:       false,
 				SessionCookieLifeTime:        0, //set cookie default is the browser life
 				SessionAutoSetCookie:         true,
 				SessionDomain:                "",
+				SessionEnableSidInHTTPHeader: false, //	enable store/get the sessionId into/from http headers
+				SessionNameInHTTPHeader:      "Beegosessionid",
+				SessionEnableSidInURLQuery:   false, //	enable get the sessionId from Url Query params
 			},
 		},
 		Log: LogConfig{
@@ -178,16 +244,6 @@ func init() {
 			Outputs:     map[string]string{"console": ""},
 		},
 	}
-
-	appConfigPath = filepath.Join(AppPath, "conf", "app.conf")
-	if !utils.FileExists(appConfigPath) {
-		AppConfig = &beegoAppConfig{innerConfig: config.NewFakeConfig()}
-		return
-	}
-
-	if err := parseConfig(appConfigPath); err != nil {
-		panic(err)
-	}
 }
 
 // now only support ini, next will support json.
@@ -196,74 +252,33 @@ func parseConfig(appConfigPath string) (err error) {
 	if err != nil {
 		return err
 	}
+	return assignConfig(AppConfig)
+}
+
+func assignConfig(ac config.Configer) error {
+	for _, i := range []interface{}{BConfig, &BConfig.Listen, &BConfig.WebConfig, &BConfig.Log, &BConfig.WebConfig.Session} {
+		assignSingleConfig(i, ac)
+	}
 	// set the run mode first
 	if envRunMode := os.Getenv("BEEGO_RUNMODE"); envRunMode != "" {
 		BConfig.RunMode = envRunMode
-	} else if runMode := AppConfig.String("RunMode"); runMode != "" {
+	} else if runMode := ac.String("RunMode"); runMode != "" {
 		BConfig.RunMode = runMode
 	}
 
-	BConfig.AppName = AppConfig.DefaultString("AppName", BConfig.AppName)
+	if sd := ac.String("StaticDir"); sd != "" {
-	BConfig.RecoverPanic = AppConfig.DefaultBool("RecoverPanic", BConfig.RecoverPanic)
+		BConfig.WebConfig.StaticDir = map[string]string{}
-	BConfig.RouterCaseSensitive = AppConfig.DefaultBool("RouterCaseSensitive", BConfig.RouterCaseSensitive)
-	BConfig.ServerName = AppConfig.DefaultString("ServerName", BConfig.ServerName)
-	BConfig.EnableGzip = AppConfig.DefaultBool("EnableGzip", BConfig.EnableGzip)
-	BConfig.EnableErrorsShow = AppConfig.DefaultBool("EnableErrorsShow", BConfig.EnableErrorsShow)
-	BConfig.CopyRequestBody = AppConfig.DefaultBool("CopyRequestBody", BConfig.CopyRequestBody)
-	BConfig.MaxMemory = AppConfig.DefaultInt64("MaxMemory", BConfig.MaxMemory)
-	BConfig.Listen.Graceful = AppConfig.DefaultBool("Graceful", BConfig.Listen.Graceful)
-	BConfig.Listen.HTTPAddr = AppConfig.String("HTTPAddr")
-	BConfig.Listen.HTTPPort = AppConfig.DefaultInt("HTTPPort", BConfig.Listen.HTTPPort)
-	BConfig.Listen.ListenTCP4 = AppConfig.DefaultBool("ListenTCP4", BConfig.Listen.ListenTCP4)
-	BConfig.Listen.EnableHTTP = AppConfig.DefaultBool("EnableHTTP", BConfig.Listen.EnableHTTP)
-	BConfig.Listen.EnableHTTPS = AppConfig.DefaultBool("EnableHTTPS", BConfig.Listen.EnableHTTPS)
-	BConfig.Listen.HTTPSAddr = AppConfig.DefaultString("HTTPSAddr", BConfig.Listen.HTTPSAddr)
-	BConfig.Listen.HTTPSPort = AppConfig.DefaultInt("HTTPSPort", BConfig.Listen.HTTPSPort)
-	BConfig.Listen.HTTPSCertFile = AppConfig.DefaultString("HTTPSCertFile", BConfig.Listen.HTTPSCertFile)
-	BConfig.Listen.HTTPSKeyFile = AppConfig.DefaultString("HTTPSKeyFile", BConfig.Listen.HTTPSKeyFile)
-	BConfig.Listen.EnableAdmin = AppConfig.DefaultBool("EnableAdmin", BConfig.Listen.EnableAdmin)
-	BConfig.Listen.AdminAddr = AppConfig.DefaultString("AdminAddr", BConfig.Listen.AdminAddr)
-	BConfig.Listen.AdminPort = AppConfig.DefaultInt("AdminPort", BConfig.Listen.AdminPort)
-	BConfig.Listen.EnableFcgi = AppConfig.DefaultBool("EnableFcgi", BConfig.Listen.EnableFcgi)
-	BConfig.Listen.EnableStdIo = AppConfig.DefaultBool("EnableStdIo", BConfig.Listen.EnableStdIo)
-	BConfig.Listen.ServerTimeOut = AppConfig.DefaultInt64("ServerTimeOut", BConfig.Listen.ServerTimeOut)
-	BConfig.WebConfig.AutoRender = AppConfig.DefaultBool("AutoRender", BConfig.WebConfig.AutoRender)
-	BConfig.WebConfig.ViewsPath = AppConfig.DefaultString("ViewsPath", BConfig.WebConfig.ViewsPath)
-	BConfig.WebConfig.DirectoryIndex = AppConfig.DefaultBool("DirectoryIndex", BConfig.WebConfig.DirectoryIndex)
-	BConfig.WebConfig.FlashName = AppConfig.DefaultString("FlashName", BConfig.WebConfig.FlashName)
-	BConfig.WebConfig.FlashSeparator = AppConfig.DefaultString("FlashSeparator", BConfig.WebConfig.FlashSeparator)
-	BConfig.WebConfig.EnableDocs = AppConfig.DefaultBool("EnableDocs", BConfig.WebConfig.EnableDocs)
-	BConfig.WebConfig.XSRFKey = AppConfig.DefaultString("XSRFKEY", BConfig.WebConfig.XSRFKey)
-	BConfig.WebConfig.EnableXSRF = AppConfig.DefaultBool("EnableXSRF", BConfig.WebConfig.EnableXSRF)
-	BConfig.WebConfig.XSRFExpire = AppConfig.DefaultInt("XSRFExpire", BConfig.WebConfig.XSRFExpire)
-	BConfig.WebConfig.TemplateLeft = AppConfig.DefaultString("TemplateLeft", BConfig.WebConfig.TemplateLeft)
-	BConfig.WebConfig.TemplateRight = AppConfig.DefaultString("TemplateRight", BConfig.WebConfig.TemplateRight)
-	BConfig.WebConfig.Session.SessionOn = AppConfig.DefaultBool("SessionOn", BConfig.WebConfig.Session.SessionOn)
-	BConfig.WebConfig.Session.SessionProvider = AppConfig.DefaultString("SessionProvider", BConfig.WebConfig.Session.SessionProvider)
-	BConfig.WebConfig.Session.SessionName = AppConfig.DefaultString("SessionName", BConfig.WebConfig.Session.SessionName)
-	BConfig.WebConfig.Session.SessionProviderConfig = AppConfig.DefaultString("SessionProviderConfig", BConfig.WebConfig.Session.SessionProviderConfig)
-	BConfig.WebConfig.Session.SessionGCMaxLifetime = AppConfig.DefaultInt64("SessionGCMaxLifetime", BConfig.WebConfig.Session.SessionGCMaxLifetime)
-	BConfig.WebConfig.Session.SessionCookieLifeTime = AppConfig.DefaultInt("SessionCookieLifeTime", BConfig.WebConfig.Session.SessionCookieLifeTime)
-	BConfig.WebConfig.Session.SessionAutoSetCookie = AppConfig.DefaultBool("SessionAutoSetCookie", BConfig.WebConfig.Session.SessionAutoSetCookie)
-	BConfig.WebConfig.Session.SessionDomain = AppConfig.DefaultString("SessionDomain", BConfig.WebConfig.Session.SessionDomain)
-	BConfig.Log.AccessLogs = AppConfig.DefaultBool("LogAccessLogs", BConfig.Log.AccessLogs)
-	BConfig.Log.FileLineNum = AppConfig.DefaultBool("LogFileLineNum", BConfig.Log.FileLineNum)
-
-	if sd := AppConfig.String("StaticDir"); sd != "" {
-		for k := range BConfig.WebConfig.StaticDir {
-			delete(BConfig.WebConfig.StaticDir, k)
-		}
 		sds := strings.Fields(sd)
 		for _, v := range sds {
 			if url2fsmap := strings.SplitN(v, ":", 2); len(url2fsmap) == 2 {
-				BConfig.WebConfig.StaticDir["/"+strings.TrimRight(url2fsmap[0], "/")] = url2fsmap[1]
+				BConfig.WebConfig.StaticDir["/"+strings.Trim(url2fsmap[0], "/")] = url2fsmap[1]
 			} else {
-				BConfig.WebConfig.StaticDir["/"+strings.TrimRight(url2fsmap[0], "/")] = url2fsmap[0]
+				BConfig.WebConfig.StaticDir["/"+strings.Trim(url2fsmap[0], "/")] = url2fsmap[0]
 			}
 		}
 	}
 
-	if sgz := AppConfig.String("StaticExtensionsToGzip"); sgz != "" {
+	if sgz := ac.String("StaticExtensionsToGzip"); sgz != "" {
 		extensions := strings.Split(sgz, ",")
 		fileExts := []string{}
 		for _, ext := range extensions {
@@ -281,7 +296,11 @@ func parseConfig(appConfigPath string) (err error) {
 		}
 	}
 
-	if lo := AppConfig.String("LogOutputs"); lo != "" {
+	if lo := ac.String("LogOutputs"); lo != "" {
+		// if lo is not nil or empty
+		// means user has set his own LogOutputs
+		// clear the default setting to BConfig.Log.Outputs
+		BConfig.Log.Outputs = make(map[string]string)
 		los := strings.Split(lo, ";")
 		for _, v := range los {
 			if logType2Config := strings.SplitN(v, ",", 2); len(logType2Config) == 2 {
@@ -293,18 +312,50 @@ func parseConfig(appConfigPath string) (err error) {
 	}
 
 	//init log
-	BeeLogger.Reset()
+	logs.Reset()
 	for adaptor, config := range BConfig.Log.Outputs {
-		err = BeeLogger.SetLogger(adaptor, config)
+		err := logs.SetLogger(adaptor, config)
 		if err != nil {
-			fmt.Printf("%s with the config `%s` got err:%s\n", adaptor, config, err)
+			fmt.Fprintln(os.Stderr, fmt.Sprintf("%s with the config %q got err:%s", adaptor, config, err.Error()))
 		}
 	}
-	SetLogFuncCall(BConfig.Log.FileLineNum)
+	logs.SetLogFuncCall(BConfig.Log.FileLineNum)
 
 	return nil
 }
 
+func assignSingleConfig(p interface{}, ac config.Configer) {
+	pt := reflect.TypeOf(p)
+	if pt.Kind() != reflect.Ptr {
+		return
+	}
+	pt = pt.Elem()
+	if pt.Kind() != reflect.Struct {
+		return
+	}
+	pv := reflect.ValueOf(p).Elem()
+
+	for i := 0; i < pt.NumField(); i++ {
+		pf := pv.Field(i)
+		if !pf.CanSet() {
+			continue
+		}
+		name := pt.Field(i).Name
+		switch pf.Kind() {
+		case reflect.String:
+			pf.SetString(ac.DefaultString(name, pf.String()))
+		case reflect.Int, reflect.Int64:
+			pf.SetInt(int64(ac.DefaultInt64(name, pf.Int())))
+		case reflect.Bool:
+			pf.SetBool(ac.DefaultBool(name, pf.Bool()))
+		case reflect.Struct:
+		default:
+			//do nothing here
+		}
+	}
+
+}
+
 // LoadAppConfig allow developer to apply a config file
 func LoadAppConfig(adapterName, configPath string) error {
 	absConfigPath, err := filepath.Abs(configPath)
@@ -316,10 +367,6 @@ func LoadAppConfig(adapterName, configPath string) error {
 		return fmt.Errorf("the target config file: %s don't exist", configPath)
 	}
 
-	if absConfigPath == appConfigPath {
-		return nil
-	}
-
 	appConfigPath = absConfigPath
 	appConfigProvider = adapterName
 
@@ -353,7 +400,7 @@ func (b *beegoAppConfig) String(key string) string {
 }
 
 func (b *beegoAppConfig) Strings(key string) []string {
-	if v := b.innerConfig.Strings(BConfig.RunMode + "::" + key); v[0] != "" {
+	if v := b.innerConfig.Strings(BConfig.RunMode + "::" + key); len(v) > 0 {
 		return v
 	}
 	return b.innerConfig.Strings(key)

config/config.go

@@ -12,11 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package config is used to parse config
+// Package config is used to parse config.
 // Usage:
-// import(
+//  import "github.com/astaxie/beego/config"
-//   "github.com/astaxie/beego/config"
+//Examples.
-// )
 //
 //  cnf, err := config.NewConfig("ini", "config.conf")
 //
@@ -38,12 +37,14 @@
 //  cnf.DIY(key string) (interface{}, error)
 //  cnf.GetSection(section string) (map[string]string, error)
 //  cnf.SaveConfigFile(filename string) error
-//
+//More docs http://beego.me/docs/module/config.md
-//  more docs http://beego.me/docs/module/config.md
 package config
 
 import (
 	"fmt"
+	"os"
+	"reflect"
+	"time"
 )
 
 // Configer defines how to get and set value from configuration raw data.
@@ -107,6 +108,69 @@ func NewConfigData(adapterName string, data []byte) (Configer, error) {
 	return adapter.ParseData(data)
 }
 
+// ExpandValueEnvForMap convert all string value with environment variable.
+func ExpandValueEnvForMap(m map[string]interface{}) map[string]interface{} {
+	for k, v := range m {
+		switch value := v.(type) {
+		case string:
+			m[k] = ExpandValueEnv(value)
+		case map[string]interface{}:
+			m[k] = ExpandValueEnvForMap(value)
+		case map[string]string:
+			for k2, v2 := range value {
+				value[k2] = ExpandValueEnv(v2)
+			}
+			m[k] = value
+		}
+	}
+	return m
+}
+
+// ExpandValueEnv returns value of convert with environment variable.
+//
+// Return environment variable if value start with "${" and end with "}".
+// Return default value if environment variable is empty or not exist.
+//
+// It accept value formats "${env}" , "${env||}}" , "${env||defaultValue}" , "defaultvalue".
+// Examples:
+//	v1 := config.ExpandValueEnv("${GOPATH}")			// return the GOPATH environment variable.
+//	v2 := config.ExpandValueEnv("${GOAsta||/usr/local/go}")	// return the default value "/usr/local/go/".
+//	v3 := config.ExpandValueEnv("Astaxie")				// return the value "Astaxie".
+func ExpandValueEnv(value string) (realValue string) {
+	realValue = value
+
+	vLen := len(value)
+	// 3 = ${}
+	if vLen < 3 {
+		return
+	}
+	// Need start with "${" and end with "}", then return.
+	if value[0] != '$' || value[1] != '{' || value[vLen-1] != '}' {
+		return
+	}
+
+	key := ""
+	defalutV := ""
+	// value start with "${"
+	for i := 2; i < vLen; i++ {
+		if value[i] == '|' && (i+1 < vLen && value[i+1] == '|') {
+			key = value[2:i]
+			defalutV = value[i+2 : vLen-1] // other string is default value.
+			break
+		} else if value[i] == '}' {
+			key = value[2:i]
+			break
+		}
+	}
+
+	realValue = os.Getenv(key)
+	if realValue == "" {
+		realValue = defalutV
+	}
+
+	return
+}
+
 // ParseBool returns the boolean value represented by the string.
 //
 // It accepts 1, 1.0, t, T, TRUE, true, True, YES, yes, Yes,Y, y, ON, on, On,
@@ -142,3 +206,37 @@ func ParseBool(val interface{}) (value bool, err error) {
 	}
 	return false, fmt.Errorf("parsing <nil>: invalid syntax")
 }
+
+// ToString converts values of any type to string.
+func ToString(x interface{}) string {
+	switch y := x.(type) {
+
+	// Handle dates with special logic
+	// This needs to come above the fmt.Stringer
+	// test since time.Time's have a .String()
+	// method
+	case time.Time:
+		return y.Format("A Monday")
+
+	// Handle type string
+	case string:
+		return y
+
+	// Handle type with .String() method
+	case fmt.Stringer:
+		return y.String()
+
+	// Handle type with .Error() method
+	case error:
+		return y.Error()
+
+	}
+
+	// Handle named string type
+	if v := reflect.ValueOf(x); v.Kind() == reflect.String {
+		return v.String()
+	}
+
+	// Fallback to fmt package for anything else like numeric types
+	return fmt.Sprint(x)
+}

config/config_test.go

@@ -0,0 +1,55 @@
+// Copyright 2016 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 config
+
+import (
+	"os"
+	"testing"
+)
+
+func TestExpandValueEnv(t *testing.T) {
+
+	testCases := []struct {
+		item string
+		want string
+	}{
+		{"", ""},
+		{"$", "$"},
+		{"{", "{"},
+		{"{}", "{}"},
+		{"${}", ""},
+		{"${|}", ""},
+		{"${}", ""},
+		{"${{}}", ""},
+		{"${{||}}", "}"},
+		{"${pwd||}", ""},
+		{"${pwd||}", ""},
+		{"${pwd||}", ""},
+		{"${pwd||}}", "}"},
+		{"${pwd||{{||}}}", "{{||}}"},
+		{"${GOPATH}", os.Getenv("GOPATH")},
+		{"${GOPATH||}", os.Getenv("GOPATH")},
+		{"${GOPATH||root}", os.Getenv("GOPATH")},
+		{"${GOPATH_NOT||root}", "root"},
+		{"${GOPATH_NOT||||root}", "||root"},
+	}
+
+	for _, c := range testCases {
+		if got := ExpandValueEnv(c.item); got != c.want {
+			t.Errorf("expand value error, item %q want %q, got %q", c.item, c.want, got)
+		}
+	}
+
+}

config/env/env.go

@@ -0,0 +1,85 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+// Copyright 2017 Faissal Elamraoui. 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 env
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/astaxie/beego/utils"
+)
+
+var env *utils.BeeMap
+
+func init() {
+	env = utils.NewBeeMap()
+	for _, e := range os.Environ() {
+		splits := strings.Split(e, "=")
+		env.Set(splits[0], os.Getenv(splits[0]))
+	}
+}
+
+// Get returns a value by key.
+// If the key does not exist, the default value will be returned.
+func Get(key string, defVal string) string {
+	if val := env.Get(key); val != nil {
+		return val.(string)
+	}
+	return defVal
+}
+
+// MustGet returns a value by key.
+// If the key does not exist, it will return an error.
+func MustGet(key string) (string, error) {
+	if val := env.Get(key); val != nil {
+		return val.(string), nil
+	}
+	return "", fmt.Errorf("no env variable with %s", key)
+}
+
+// Set sets a value in the ENV copy.
+// This does not affect the child process environment.
+func Set(key string, value string) {
+	env.Set(key, value)
+}
+
+// MustSet sets a value in the ENV copy and the child process environment.
+// It returns an error in case the set operation failed.
+func MustSet(key string, value string) error {
+	err := os.Setenv(key, value)
+	if err != nil {
+		return err
+	}
+	env.Set(key, value)
+	return nil
+}
+
+// GetAll returns all keys/values in the current child process environment.
+func GetAll() map[string]string {
+	items := env.Items()
+	envs := make(map[string]string, env.Count())
+
+	for key, val := range items {
+		switch key := key.(type) {
+		case string:
+			switch val := val.(type) {
+			case string:
+				envs[key] = val
+			}
+		}
+	}
+	return envs
+}

config/env/env_test.go

@@ -0,0 +1,75 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+// Copyright 2017 Faissal Elamraoui. 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 env
+
+import (
+	"os"
+	"testing"
+)
+
+func TestEnvGet(t *testing.T) {
+	gopath := Get("GOPATH", "")
+	if gopath != os.Getenv("GOPATH") {
+		t.Error("expected GOPATH not empty.")
+	}
+
+	noExistVar := Get("NOEXISTVAR", "foo")
+	if noExistVar != "foo" {
+		t.Errorf("expected NOEXISTVAR to equal foo, got %s.", noExistVar)
+	}
+}
+
+func TestEnvMustGet(t *testing.T) {
+	gopath, err := MustGet("GOPATH")
+	if err != nil {
+		t.Error(err)
+	}
+
+	if gopath != os.Getenv("GOPATH") {
+		t.Errorf("expected GOPATH to be the same, got %s.", gopath)
+	}
+
+	_, err = MustGet("NOEXISTVAR")
+	if err == nil {
+		t.Error("expected error to be non-nil")
+	}
+}
+
+func TestEnvSet(t *testing.T) {
+	Set("MYVAR", "foo")
+	myVar := Get("MYVAR", "bar")
+	if myVar != "foo" {
+		t.Errorf("expected MYVAR to equal foo, got %s.", myVar)
+	}
+}
+
+func TestEnvMustSet(t *testing.T) {
+	err := MustSet("FOO", "bar")
+	if err != nil {
+		t.Error(err)
+	}
+
+	fooVar := os.Getenv("FOO")
+	if fooVar != "bar" {
+		t.Errorf("expected FOO variable to equal bar, got %s.", fooVar)
+	}
+}
+
+func TestEnvGetAll(t *testing.T) {
+	envMap := GetAll()
+	if len(envMap) == 0 {
+		t.Error("expected environment not empty.")
+	}
+}

config/fake.go

@@ -38,7 +38,7 @@ func (c *fakeConfigContainer) String(key string) string {
 }
 
 func (c *fakeConfigContainer) DefaultString(key string, defaultval string) string {
-	v := c.getData(key)
+	v := c.String(key)
 	if v == "" {
 		return defaultval
 	}
@@ -46,7 +46,7 @@ func (c *fakeConfigContainer) DefaultString(key string, defaultval string) strin
 }
 
 func (c *fakeConfigContainer) Strings(key string) []string {
-	v := c.getData(key)
+	v := c.String(key)
 	if v == "" {
 		return nil
 	}

config/ini.go

@@ -18,15 +18,13 @@ import (
 	"bufio"
 	"bytes"
 	"errors"
-	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
-	"path"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"sync"
-	"time"
 )
 
 var (
@@ -51,24 +49,26 @@ func (ini *IniConfig) Parse(name string) (Configer, error) {
 }
 
 func (ini *IniConfig) parseFile(name string) (*IniConfigContainer, error) {
-	file, err := os.Open(name)
+	data, err := ioutil.ReadFile(name)
 	if err != nil {
 		return nil, err
 	}
 
+	return ini.parseData(filepath.Dir(name), data)
+}
+
+func (ini *IniConfig) parseData(dir string, data []byte) (*IniConfigContainer, error) {
 	cfg := &IniConfigContainer{
-		file.Name(),
+		data:           make(map[string]map[string]string),
-		make(map[string]map[string]string),
+		sectionComment: make(map[string]string),
-		make(map[string]string),
+		keyComment:     make(map[string]string),
-		make(map[string]string),
+		RWMutex:        sync.RWMutex{},
-		sync.RWMutex{},
 	}
 	cfg.Lock()
 	defer cfg.Unlock()
-	defer file.Close()
 
 	var comment bytes.Buffer
-	buf := bufio.NewReader(file)
+	buf := bufio.NewReader(bytes.NewBuffer(data))
 	// check the BOM
 	head, err := buf.Peek(3)
 	if err == nil && head[0] == 239 && head[1] == 187 && head[2] == 191 {
@@ -82,11 +82,14 @@ func (ini *IniConfig) parseFile(name string) (*IniConfigContainer, error) {
 		if err == io.EOF {
 			break
 		}
+		//It might be a good idea to throw a error on all unknonw errors?
+		if _, ok := err.(*os.PathError); ok {
+			return nil, err
+		}
+		line = bytes.TrimSpace(line)
 		if bytes.Equal(line, bEmpty) {
 			continue
 		}
-		line = bytes.TrimSpace(line)
-
 		var bComment []byte
 		switch {
 		case bytes.HasPrefix(line, bNumComment):
@@ -126,16 +129,20 @@ func (ini *IniConfig) parseFile(name string) (*IniConfigContainer, error) {
 
 		// handle include "other.conf"
 		if len(keyValue) == 1 && strings.HasPrefix(key, "include") {
+
 			includefiles := strings.Fields(key)
 			if includefiles[0] == "include" && len(includefiles) == 2 {
+
 				otherfile := strings.Trim(includefiles[1], "\"")
-				if !path.IsAbs(otherfile) {
+				if !filepath.IsAbs(otherfile) {
-					otherfile = path.Join(path.Dir(name), otherfile)
+					otherfile = filepath.Join(dir, otherfile)
 				}
+
 				i, err := ini.parseFile(otherfile)
 				if err != nil {
 					return nil, err
 				}
+
 				for sec, dt := range i.data {
 					if _, ok := cfg.data[sec]; !ok {
 						cfg.data[sec] = make(map[string]string)
@@ -144,12 +151,15 @@ func (ini *IniConfig) parseFile(name string) (*IniConfigContainer, error) {
 						cfg.data[sec][k] = v
 					}
 				}
+
 				for sec, comm := range i.sectionComment {
 					cfg.sectionComment[sec] = comm
 				}
+
 				for k, comm := range i.keyComment {
 					cfg.keyComment[k] = comm
 				}
+
 				continue
 			}
 		}
@@ -162,7 +172,7 @@ func (ini *IniConfig) parseFile(name string) (*IniConfigContainer, error) {
 			val = bytes.Trim(val, `"`)
 		}
 
-		cfg.data[section][key] = string(val)
+		cfg.data[section][key] = ExpandValueEnv(string(val))
 		if comment.Len() > 0 {
 			cfg.keyComment[section+"."+key] = comment.String()
 			comment.Reset()
@@ -173,20 +183,18 @@ func (ini *IniConfig) parseFile(name string) (*IniConfigContainer, error) {
 }
 
 // ParseData parse ini the data
+// When include other.conf,other.conf is either absolute directory
+// or under beego in default temporary directory(/tmp/beego).
 func (ini *IniConfig) ParseData(data []byte) (Configer, error) {
-	// Save memory data to temporary file
+	dir := filepath.Join(os.TempDir(), "beego")
-	tmpName := path.Join(os.TempDir(), "beego", fmt.Sprintf("%d", time.Now().Nanosecond()))
+	os.MkdirAll(dir, os.ModePerm)
-	os.MkdirAll(path.Dir(tmpName), os.ModePerm)
+
-	if err := ioutil.WriteFile(tmpName, data, 0655); err != nil {
+	return ini.parseData(dir, data)
-		return nil, err
-	}
-	return ini.Parse(tmpName)
 }
 
 // IniConfigContainer A Config represents the ini configuration.
 // When set and get value, support key as section:name type.
 type IniConfigContainer struct {
-	filename       string
 	data           map[string]map[string]string // section=> key:val
 	sectionComment map[string]string            // section : comment
 	keyComment     map[string]string            // id: []{comment, key...}; id 1 is for main comment.
@@ -293,10 +301,12 @@ func (c *IniConfigContainer) GetSection(section string) (map[string]string, erro
 	if v, ok := c.data[section]; ok {
 		return v, nil
 	}
-	return nil, errors.New("not exist setction")
+	return nil, errors.New("not exist section")
 }
 
-// SaveConfigFile save the config into file
+// SaveConfigFile save the config into file.
+//
+// BUG(env): The environment variable config item will be saved with real value in SaveConfigFile Funcation.
 func (c *IniConfigContainer) SaveConfigFile(filename string) (err error) {
 	// Write configuration file by filename.
 	f, err := os.Create(filename)

config/ini_test.go

@@ -42,11 +42,14 @@ needlogin = ON
 enableSession = Y
 enableCookie = N
 flag = 1
+path1 = ${GOPATH}
+path2 = ${GOPATH||/home/go}
 [demo]
 key1="asta"
 key2 = "xie"
 CaseInsensitive = true
 peers = one;two;three
+password = ${GOPATH}
 `
 
 		keyValue = map[string]interface{}{
@@ -64,10 +67,13 @@ peers = one;two;three
 			"enableSession":         true,
 			"enableCookie":          false,
 			"flag":                  true,
+			"path1":                 os.Getenv("GOPATH"),
+			"path2":                 os.Getenv("GOPATH"),
 			"demo::key1":            "asta",
 			"demo::key2":            "xie",
 			"demo::CaseInsensitive": true,
 			"demo::peers":           []string{"one", "two", "three"},
+			"demo::password":        os.Getenv("GOPATH"),
 			"null":                  "",
 			"demo2::key1":           "",
 			"error":                 "",

config/json.go

@@ -57,6 +57,9 @@ func (js *JSONConfig) ParseData(data []byte) (Configer, error) {
 		}
 		x.data["rootArray"] = wrappingArray
 	}
+
+	x.data = ExpandValueEnvForMap(x.data)
+
 	return x, nil
 }
 

config/json_test.go

@@ -86,16 +86,19 @@ func TestJson(t *testing.T) {
 "enableSession": "Y",
 "enableCookie": "N",
 "flag": 1,
+"path1": "${GOPATH}",
+"path2": "${GOPATH||/home/go}",
 "database": {
         "host": "host",
         "port": "port",
         "database": "database",
         "username": "username",
-        "password": "password",
+        "password": "${GOPATH}",
 		"conns":{
 			"maxconnection":12,
 			"autoconnect":true,
-			"connectioninfo":"info"
+			"connectioninfo":"info",
+			"root": "${GOPATH}"
 		}
     }
 }`
@@ -115,13 +118,16 @@ func TestJson(t *testing.T) {
 			"enableSession":                   true,
 			"enableCookie":                    false,
 			"flag":                            true,
+			"path1":                           os.Getenv("GOPATH"),
+			"path2":                           os.Getenv("GOPATH"),
 			"database::host":                  "host",
 			"database::port":                  "port",
 			"database::database":              "database",
-			"database::password":              "password",
+			"database::password":              os.Getenv("GOPATH"),
 			"database::conns::maxconnection":  12,
 			"database::conns::autoconnect":    true,
 			"database::conns::connectioninfo": "info",
+			"database::conns::root":           os.Getenv("GOPATH"),
 			"unknown":                         "",
 		}
 	)

config/xml/xml.go

@@ -12,11 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package xml for config provider
+// Package xml for config provider.
 //
-// depend on github.com/beego/x2j
+// depend on github.com/beego/x2j.
 //
-// go install github.com/beego/x2j
+// go install github.com/beego/x2j.
 //
 // Usage:
 //  import(
@@ -26,7 +26,7 @@
 //
 //  cnf, err := config.NewConfig("xml", "config.xml")
 //
-//  more docs http://beego.me/docs/module/config.md
+//More docs http://beego.me/docs/module/config.md
 package xml
 
 import (
@@ -35,11 +35,9 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"path"
 	"strconv"
 	"strings"
 	"sync"
-	"time"
 
 	"github.com/astaxie/beego/config"
 	"github.com/beego/x2j"
@@ -52,36 +50,26 @@ type Config struct{}
 
 // Parse returns a ConfigContainer with parsed xml config map.
 func (xc *Config) Parse(filename string) (config.Configer, error) {
-	file, err := os.Open(filename)
+	context, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	x := &ConfigContainer{data: make(map[string]interface{})}
-	content, err := ioutil.ReadAll(file)
 	if err != nil {
 		return nil, err
 	}
 
-	d, err := x2j.DocToMap(string(content))
+	return xc.ParseData(context)
-	if err != nil {
-		return nil, err
-	}
-
-	x.data = d["config"].(map[string]interface{})
-	return x, nil
 }
 
 // ParseData xml data
 func (xc *Config) ParseData(data []byte) (config.Configer, error) {
-	// Save memory data to temporary file
+	x := &ConfigContainer{data: make(map[string]interface{})}
-	tmpName := path.Join(os.TempDir(), "beego", fmt.Sprintf("%d", time.Now().Nanosecond()))
+
-	os.MkdirAll(path.Dir(tmpName), os.ModePerm)
+	d, err := x2j.DocToMap(string(data))
-	if err := ioutil.WriteFile(tmpName, data, 0655); err != nil {
+	if err != nil {
 		return nil, err
 	}
-	return xc.Parse(tmpName)
+
+	x.data = config.ExpandValueEnvForMap(d["config"].(map[string]interface{}))
+
+	return x, nil
 }
 
 // ConfigContainer A Config represents the xml configuration.
@@ -92,7 +80,7 @@ type ConfigContainer struct {
 
 // Bool returns the boolean value for a given key.
 func (c *ConfigContainer) Bool(key string) (bool, error) {
-	if v, ok := c.data[key]; ok {
+	if v := c.data[key]; v != nil {
 		return config.ParseBool(v)
 	}
 	return false, fmt.Errorf("not exist key: %q", key)
@@ -193,10 +181,14 @@ func (c *ConfigContainer) DefaultStrings(key string, defaultval []string) []stri
 
 // GetSection returns map for the given section
 func (c *ConfigContainer) GetSection(section string) (map[string]string, error) {
-	if v, ok := c.data[section]; ok {
+	if v, ok := c.data[section].(map[string]interface{}); ok {
-		return v.(map[string]string), nil
+		mapstr := make(map[string]string)
+		for k, val := range v {
+			mapstr[k] = config.ToString(val)
 		}
-	return nil, errors.New("not exist setction")
+		return mapstr, nil
+	}
+	return nil, fmt.Errorf("section '%s' not found", section)
 }
 
 // SaveConfigFile save the config into file

config/xml/xml_test.go

@@ -15,14 +15,18 @@
 package xml
 
 import (
+	"fmt"
 	"os"
 	"testing"
 
 	"github.com/astaxie/beego/config"
 )
 
+func TestXML(t *testing.T) {
+
+	var (
 		//xml parse should incluce in <config></config> tags
-var xmlcontext = `<?xml version="1.0" encoding="UTF-8"?>
+		xmlcontext = `<?xml version="1.0" encoding="UTF-8"?>
 <config>
 <appname>beeapi</appname>
 <httpport>8080</httpport>
@@ -31,10 +35,29 @@ var xmlcontext = `<?xml version="1.0" encoding="UTF-8"?>
 <runmode>dev</runmode>
 <autorender>false</autorender>
 <copyrequestbody>true</copyrequestbody>
+<path1>${GOPATH}</path1>
+<path2>${GOPATH||/home/go}</path2>
+<mysection>
+<id>1</id>
+<name>MySection</name>
+</mysection>
 </config>
 `
+		keyValue = map[string]interface{}{
+			"appname":         "beeapi",
+			"httpport":        8080,
+			"mysqlport":       int64(3600),
+			"PI":              3.1415976,
+			"runmode":         "dev",
+			"autorender":      false,
+			"copyrequestbody": true,
+			"path1":           os.Getenv("GOPATH"),
+			"path2":           os.Getenv("GOPATH"),
+			"error":           "",
+			"emptystrings":    []string{},
+		}
+	)
 
-func TestXML(t *testing.T) {
 	f, err := os.Create("testxml.conf")
 	if err != nil {
 		t.Fatal(err)
@@ -46,43 +69,57 @@ func TestXML(t *testing.T) {
 	}
 	f.Close()
 	defer os.Remove("testxml.conf")
+
 	xmlconf, err := config.NewConfig("xml", "testxml.conf")
 	if err != nil {
 		t.Fatal(err)
 	}
-	if xmlconf.String("appname") != "beeapi" {
+
-		t.Fatal("appname not equal to beeapi")
+	var xmlsection map[string]string
-	}
+	xmlsection, err = xmlconf.GetSection("mysection")
-	if port, err := xmlconf.Int("httpport"); err != nil || port != 8080 {
+	if err != nil {
-		t.Error(port)
 		t.Fatal(err)
 	}
-	if port, err := xmlconf.Int64("mysqlport"); err != nil || port != 3600 {
+
-		t.Error(port)
+	if len(xmlsection) == 0 {
-		t.Fatal(err)
+		t.Error("section should not be empty")
 	}
-	if pi, err := xmlconf.Float("PI"); err != nil || pi != 3.1415976 {
+
-		t.Error(pi)
+	for k, v := range keyValue {
-		t.Fatal(err)
+
+		var (
+			value interface{}
+			err   error
+		)
+
+		switch v.(type) {
+		case int:
+			value, err = xmlconf.Int(k)
+		case int64:
+			value, err = xmlconf.Int64(k)
+		case float64:
+			value, err = xmlconf.Float(k)
+		case bool:
+			value, err = xmlconf.Bool(k)
+		case []string:
+			value = xmlconf.Strings(k)
+		case string:
+			value = xmlconf.String(k)
+		default:
+			value, err = xmlconf.DIY(k)
 		}
-	if xmlconf.String("runmode") != "dev" {
+		if err != nil {
-		t.Fatal("runmode not equal to dev")
+			t.Errorf("get key %q value fatal,%v err %s", k, v, err)
+		} else if fmt.Sprintf("%v", v) != fmt.Sprintf("%v", value) {
+			t.Errorf("get key %q value, want %v got %v .", k, v, value)
 		}
-	if v, err := xmlconf.Bool("autorender"); err != nil || v != false {
+
-		t.Error(v)
-		t.Fatal(err)
-	}
-	if v, err := xmlconf.Bool("copyrequestbody"); err != nil || v != true {
-		t.Error(v)
-		t.Fatal(err)
 	}
+
 	if err = xmlconf.Set("name", "astaxie"); err != nil {
 		t.Fatal(err)
 	}
 	if xmlconf.String("name") != "astaxie" {
 		t.Fatal("get name error")
 	}
-	if xmlconf.Strings("emptystrings") != nil {
-		t.Fatal("get emtpy strings error")
-	}
 }

config/yaml/yaml.go

@@ -26,7 +26,7 @@
 //
 //  cnf, err := config.NewConfig("yaml", "config.yaml")
 //
-//  more docs http://beego.me/docs/module/config.md
+//More docs http://beego.me/docs/module/config.md
 package yaml
 
 import (
@@ -37,10 +37,8 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
-	"path"
 	"strings"
 	"sync"
-	"time"
 
 	"github.com/astaxie/beego/config"
 	"github.com/beego/goyaml2"
@@ -63,26 +61,30 @@ func (yaml *Config) Parse(filename string) (y config.Configer, err error) {
 
 // ParseData parse yaml data
 func (yaml *Config) ParseData(data []byte) (config.Configer, error) {
-	// Save memory data to temporary file
+	cnf, err := parseYML(data)
-	tmpName := path.Join(os.TempDir(), "beego", fmt.Sprintf("%d", time.Now().Nanosecond()))
+	if err != nil {
-	os.MkdirAll(path.Dir(tmpName), os.ModePerm)
-	if err := ioutil.WriteFile(tmpName, data, 0655); err != nil {
 		return nil, err
 	}
-	return yaml.Parse(tmpName)
+
+	return &ConfigContainer{
+		data: cnf,
+	}, nil
 }
 
 // ReadYmlReader Read yaml file to map.
 // if json like, use json package, unless goyaml2 package.
 func ReadYmlReader(path string) (cnf map[string]interface{}, err error) {
-	f, err := os.Open(path)
+	buf, err := ioutil.ReadFile(path)
 	if err != nil {
 		return
 	}
-	defer f.Close()
 
-	buf, err := ioutil.ReadAll(f)
+	return parseYML(buf)
-	if err != nil || len(buf) < 3 {
+}
+
+// parseYML parse yaml formatted []byte to map.
+func parseYML(buf []byte) (cnf map[string]interface{}, err error) {
+	if len(buf) < 3 {
 		return
 	}
 
@@ -110,6 +112,7 @@ func ReadYmlReader(path string) (cnf map[string]interface{}, err error) {
 		log.Println("Not a Map? >> ", string(buf), data)
 		cnf = nil
 	}
+	cnf = config.ExpandValueEnvForMap(cnf)
 	return
 }
 
@@ -121,10 +124,11 @@ type ConfigContainer struct {
 
 // Bool returns the boolean value for a given key.
 func (c *ConfigContainer) Bool(key string) (bool, error) {
-	if v, ok := c.data[key]; ok {
+	v, err := c.getData(key)
-		return config.ParseBool(v)
+	if err != nil {
+		return false, err
 	}
-	return false, fmt.Errorf("not exist key: %q", key)
+	return config.ParseBool(v)
 }
 
 // DefaultBool return the bool value if has no error
@@ -139,8 +143,12 @@ func (c *ConfigContainer) DefaultBool(key string, defaultval bool) bool {
 
 // Int returns the integer value for a given key.
 func (c *ConfigContainer) Int(key string) (int, error) {
-	if v, ok := c.data[key].(int64); ok {
+	if v, err := c.getData(key); err != nil {
-		return int(v), nil
+		return 0, err
+	} else if vv, ok := v.(int); ok {
+		return vv, nil
+	} else if vv, ok := v.(int64); ok {
+		return int(vv), nil
 	}
 	return 0, errors.New("not int value")
 }
@@ -157,8 +165,10 @@ func (c *ConfigContainer) DefaultInt(key string, defaultval int) int {
 
 // Int64 returns the int64 value for a given key.
 func (c *ConfigContainer) Int64(key string) (int64, error) {
-	if v, ok := c.data[key].(int64); ok {
+	if v, err := c.getData(key); err != nil {
-		return v, nil
+		return 0, err
+	} else if vv, ok := v.(int64); ok {
+		return vv, nil
 	}
 	return 0, errors.New("not bool value")
 }
@@ -175,8 +185,14 @@ func (c *ConfigContainer) DefaultInt64(key string, defaultval int64) int64 {
 
 // Float returns the float value for a given key.
 func (c *ConfigContainer) Float(key string) (float64, error) {
-	if v, ok := c.data[key].(float64); ok {
+	if v, err := c.getData(key); err != nil {
-		return v, nil
+		return 0.0, err
+	} else if vv, ok := v.(float64); ok {
+		return vv, nil
+	} else if vv, ok := v.(int); ok {
+		return float64(vv), nil
+	} else if vv, ok := v.(int64); ok {
+		return float64(vv), nil
 	}
 	return 0.0, errors.New("not float64 value")
 }
@@ -193,8 +209,10 @@ func (c *ConfigContainer) DefaultFloat(key string, defaultval float64) float64 {
 
 // String returns the string value for a given key.
 func (c *ConfigContainer) String(key string) string {
-	if v, ok := c.data[key].(string); ok {
+	if v, err := c.getData(key); err == nil {
-		return v
+		if vv, ok := v.(string); ok {
+			return vv
+		}
 	}
 	return ""
 }
@@ -230,11 +248,11 @@ func (c *ConfigContainer) DefaultStrings(key string, defaultval []string) []stri
 
 // GetSection returns map for the given section
 func (c *ConfigContainer) GetSection(section string) (map[string]string, error) {
-	v, ok := c.data[section]
+
-	if ok {
+	if v, ok := c.data[section]; ok {
 		return v.(map[string]string), nil
 	}
-	return nil, errors.New("not exist setction")
+	return nil, errors.New("not exist section")
 }
 
 // SaveConfigFile save the config into file
@@ -259,10 +277,19 @@ func (c *ConfigContainer) Set(key, val string) error {
 
 // DIY returns the raw value by a given key.
 func (c *ConfigContainer) DIY(key string) (v interface{}, err error) {
+	return c.getData(key)
+}
+
+func (c *ConfigContainer) getData(key string) (interface{}, error) {
+
+	if len(key) == 0 {
+		return nil, errors.New("key is empty")
+	}
+
 	if v, ok := c.data[key]; ok {
 		return v, nil
 	}
-	return nil, errors.New("not exist key")
+	return nil, fmt.Errorf("not exist key %q", key)
 }
 
 func init() {

config/yaml/yaml_test.go

@@ -15,13 +15,17 @@
 package yaml
 
 import (
+	"fmt"
 	"os"
 	"testing"
 
 	"github.com/astaxie/beego/config"
 )
 
-var yamlcontext = `
+func TestYaml(t *testing.T) {
+
+	var (
+		yamlcontext = `
 "appname": beeapi
 "httpport": 8080
 "mysqlport": 3600
@@ -29,9 +33,27 @@ var yamlcontext = `
 "runmode": dev
 "autorender": false
 "copyrequestbody": true
+"PATH": GOPATH
+"path1": ${GOPATH}
+"path2": ${GOPATH||/home/go}
+"empty": "" 
 `
 
-func TestYaml(t *testing.T) {
+		keyValue = map[string]interface{}{
+			"appname":         "beeapi",
+			"httpport":        8080,
+			"mysqlport":       int64(3600),
+			"PI":              3.1415976,
+			"runmode":         "dev",
+			"autorender":      false,
+			"copyrequestbody": true,
+			"PATH":            "GOPATH",
+			"path1":           os.Getenv("GOPATH"),
+			"path2":           os.Getenv("GOPATH"),
+			"error":           "",
+			"emptystrings":    []string{},
+		}
+	)
 	f, err := os.Create("testyaml.conf")
 	if err != nil {
 		t.Fatal(err)
@@ -47,32 +69,42 @@ func TestYaml(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+
 	if yamlconf.String("appname") != "beeapi" {
 		t.Fatal("appname not equal to beeapi")
 	}
-	if port, err := yamlconf.Int("httpport"); err != nil || port != 8080 {
+
-		t.Error(port)
+	for k, v := range keyValue {
-		t.Fatal(err)
+
+		var (
+			value interface{}
+			err   error
+		)
+
+		switch v.(type) {
+		case int:
+			value, err = yamlconf.Int(k)
+		case int64:
+			value, err = yamlconf.Int64(k)
+		case float64:
+			value, err = yamlconf.Float(k)
+		case bool:
+			value, err = yamlconf.Bool(k)
+		case []string:
+			value = yamlconf.Strings(k)
+		case string:
+			value = yamlconf.String(k)
+		default:
+			value, err = yamlconf.DIY(k)
 		}
-	if port, err := yamlconf.Int64("mysqlport"); err != nil || port != 3600 {
+		if err != nil {
-		t.Error(port)
+			t.Errorf("get key %q value fatal,%v err %s", k, v, err)
-		t.Fatal(err)
+		} else if fmt.Sprintf("%v", v) != fmt.Sprintf("%v", value) {
+			t.Errorf("get key %q value, want %v got %v .", k, v, value)
 		}
-	if pi, err := yamlconf.Float("PI"); err != nil || pi != 3.1415976 {
+
-		t.Error(pi)
-		t.Fatal(err)
-	}
-	if yamlconf.String("runmode") != "dev" {
-		t.Fatal("runmode not equal to dev")
-	}
-	if v, err := yamlconf.Bool("autorender"); err != nil || v != false {
-		t.Error(v)
-		t.Fatal(err)
-	}
-	if v, err := yamlconf.Bool("copyrequestbody"); err != nil || v != true {
-		t.Error(v)
-		t.Fatal(err)
 	}
+
 	if err = yamlconf.Set("name", "astaxie"); err != nil {
 		t.Fatal(err)
 	}
@@ -80,7 +112,4 @@ func TestYaml(t *testing.T) {
 		t.Fatal("get name error")
 	}
 
-	if yamlconf.Strings("emptystrings") != nil {
-		t.Fatal("get emtpy strings error")
-	}
 }

config_test.go

@@ -15,7 +15,11 @@
 package beego
 
 import (
+	"encoding/json"
+	"reflect"
 	"testing"
+
+	"github.com/astaxie/beego/config"
 )
 
 func TestDefaults(t *testing.T) {
@@ -27,3 +31,108 @@ func TestDefaults(t *testing.T) {
 		t.Errorf("FlashName was not set to default.")
 	}
 }
+
+func TestAssignConfig_01(t *testing.T) {
+	_BConfig := &Config{}
+	_BConfig.AppName = "beego_test"
+	jcf := &config.JSONConfig{}
+	ac, _ := jcf.ParseData([]byte(`{"AppName":"beego_json"}`))
+	assignSingleConfig(_BConfig, ac)
+	if _BConfig.AppName != "beego_json" {
+		t.Log(_BConfig)
+		t.FailNow()
+	}
+}
+
+func TestAssignConfig_02(t *testing.T) {
+	_BConfig := &Config{}
+	bs, _ := json.Marshal(newBConfig())
+
+	jsonMap := map[string]interface{}{}
+	json.Unmarshal(bs, &jsonMap)
+
+	configMap := map[string]interface{}{}
+	for k, v := range jsonMap {
+		if reflect.TypeOf(v).Kind() == reflect.Map {
+			for k1, v1 := range v.(map[string]interface{}) {
+				if reflect.TypeOf(v1).Kind() == reflect.Map {
+					for k2, v2 := range v1.(map[string]interface{}) {
+						configMap[k2] = v2
+					}
+				} else {
+					configMap[k1] = v1
+				}
+			}
+		} else {
+			configMap[k] = v
+		}
+	}
+	configMap["MaxMemory"] = 1024
+	configMap["Graceful"] = true
+	configMap["XSRFExpire"] = 32
+	configMap["SessionProviderConfig"] = "file"
+	configMap["FileLineNum"] = true
+
+	jcf := &config.JSONConfig{}
+	bs, _ = json.Marshal(configMap)
+	ac, _ := jcf.ParseData([]byte(bs))
+
+	for _, i := range []interface{}{_BConfig, &_BConfig.Listen, &_BConfig.WebConfig, &_BConfig.Log, &_BConfig.WebConfig.Session} {
+		assignSingleConfig(i, ac)
+	}
+
+	if _BConfig.MaxMemory != 1024 {
+		t.Log(_BConfig.MaxMemory)
+		t.FailNow()
+	}
+
+	if !_BConfig.Listen.Graceful {
+		t.Log(_BConfig.Listen.Graceful)
+		t.FailNow()
+	}
+
+	if _BConfig.WebConfig.XSRFExpire != 32 {
+		t.Log(_BConfig.WebConfig.XSRFExpire)
+		t.FailNow()
+	}
+
+	if _BConfig.WebConfig.Session.SessionProviderConfig != "file" {
+		t.Log(_BConfig.WebConfig.Session.SessionProviderConfig)
+		t.FailNow()
+	}
+
+	if !_BConfig.Log.FileLineNum {
+		t.Log(_BConfig.Log.FileLineNum)
+		t.FailNow()
+	}
+
+}
+
+func TestAssignConfig_03(t *testing.T) {
+	jcf := &config.JSONConfig{}
+	ac, _ := jcf.ParseData([]byte(`{"AppName":"beego"}`))
+	ac.Set("AppName", "test_app")
+	ac.Set("RunMode", "online")
+	ac.Set("StaticDir", "download:down download2:down2")
+	ac.Set("StaticExtensionsToGzip", ".css,.js,.html,.jpg,.png")
+	assignConfig(ac)
+
+	t.Logf("%#v", BConfig)
+
+	if BConfig.AppName != "test_app" {
+		t.FailNow()
+	}
+
+	if BConfig.RunMode != "online" {
+		t.FailNow()
+	}
+	if BConfig.WebConfig.StaticDir["/download"] != "down" {
+		t.FailNow()
+	}
+	if BConfig.WebConfig.StaticDir["/download2"] != "down2" {
+		t.FailNow()
+	}
+	if len(BConfig.WebConfig.StaticExtensionsToGzip) != 5 {
+		t.FailNow()
+	}
+}

context/acceptencoder.go

@@ -27,6 +27,33 @@ import (
 	"sync"
 )
 
+var (
+	//Default size==20B same as nginx
+	defaultGzipMinLength = 20
+	//Content will only be compressed if content length is either unknown or greater than gzipMinLength.
+	gzipMinLength = defaultGzipMinLength
+	//The compression level used for deflate compression. (0-9).
+	gzipCompressLevel int
+	//List of HTTP methods to compress. If not set, only GET requests are compressed.
+	includedMethods map[string]bool
+	getMethodOnly   bool
+)
+
+func InitGzip(minLength, compressLevel int, methods []string) {
+	if minLength >= 0 {
+		gzipMinLength = minLength
+	}
+	gzipCompressLevel = compressLevel
+	if gzipCompressLevel < flate.NoCompression || gzipCompressLevel > flate.BestCompression {
+		gzipCompressLevel = flate.BestSpeed
+	}
+	getMethodOnly = (len(methods) == 0) || (len(methods) == 1 && strings.ToUpper(methods[0]) == "GET")
+	includedMethods = make(map[string]bool, len(methods))
+	for _, v := range methods {
+		includedMethods[strings.ToUpper(v)] = true
+	}
+}
+
 type resetWriter interface {
 	io.Writer
 	Reset(w io.Writer)
@@ -43,18 +70,18 @@ func (n nopResetWriter) Reset(w io.Writer) {
 type acceptEncoder struct {
 	name                    string
 	levelEncode             func(int) resetWriter
-	bestSpeedPool       *sync.Pool
+	customCompressLevelPool *sync.Pool
 	bestCompressionPool     *sync.Pool
 }
 
 func (ac acceptEncoder) encode(wr io.Writer, level int) resetWriter {
-	if ac.bestSpeedPool == nil || ac.bestCompressionPool == nil {
+	if ac.customCompressLevelPool == nil || ac.bestCompressionPool == nil {
 		return nopResetWriter{wr}
 	}
 	var rwr resetWriter
 	switch level {
 	case flate.BestSpeed:
-		rwr = ac.bestSpeedPool.Get().(resetWriter)
+		rwr = ac.customCompressLevelPool.Get().(resetWriter)
 	case flate.BestCompression:
 		rwr = ac.bestCompressionPool.Get().(resetWriter)
 	default:
@@ -65,13 +92,18 @@ func (ac acceptEncoder) encode(wr io.Writer, level int) resetWriter {
 }
 
 func (ac acceptEncoder) put(wr resetWriter, level int) {
-	if ac.bestSpeedPool == nil || ac.bestCompressionPool == nil {
+	if ac.customCompressLevelPool == nil || ac.bestCompressionPool == nil {
 		return
 	}
 	wr.Reset(nil)
+
+	//notice
+	//compressionLevel==BestCompression DOES NOT MATTER
+	//sync.Pool will not memory leak
+
 	switch level {
-	case flate.BestSpeed:
+	case gzipCompressLevel:
-		ac.bestSpeedPool.Put(wr)
+		ac.customCompressLevelPool.Put(wr)
 	case flate.BestCompression:
 		ac.bestCompressionPool.Put(wr)
 	}
@@ -79,28 +111,22 @@ func (ac acceptEncoder) put(wr resetWriter, level int) {
 
 var (
 	noneCompressEncoder = acceptEncoder{"", nil, nil, nil}
-	gzipCompressEncoder = acceptEncoder{"gzip",
+	gzipCompressEncoder = acceptEncoder{
-		func(level int) resetWriter { wr, _ := gzip.NewWriterLevel(nil, level); return wr },
+		name:                    "gzip",
-		&sync.Pool{
+		levelEncode:             func(level int) resetWriter { wr, _ := gzip.NewWriterLevel(nil, level); return wr },
-			New: func() interface{} { wr, _ := gzip.NewWriterLevel(nil, flate.BestSpeed); return wr },
+		customCompressLevelPool: &sync.Pool{New: func() interface{} { wr, _ := gzip.NewWriterLevel(nil, gzipCompressLevel); return wr }},
-		},
+		bestCompressionPool:     &sync.Pool{New: func() interface{} { wr, _ := gzip.NewWriterLevel(nil, flate.BestCompression); return wr }},
-		&sync.Pool{
-			New: func() interface{} { wr, _ := gzip.NewWriterLevel(nil, flate.BestCompression); return wr },
-		},
 	}
 
 	//according to the sec :http://tools.ietf.org/html/rfc2616#section-3.5 ,the deflate compress in http is zlib indeed
 	//deflate
 	//The "zlib" format defined in RFC 1950 [31] in combination with
 	//the "deflate" compression mechanism described in RFC 1951 [29].
-	deflateCompressEncoder = acceptEncoder{"deflate",
+	deflateCompressEncoder = acceptEncoder{
-		func(level int) resetWriter { wr, _ := zlib.NewWriterLevel(nil, level); return wr },
+		name:                    "deflate",
-		&sync.Pool{
+		levelEncode:             func(level int) resetWriter { wr, _ := zlib.NewWriterLevel(nil, level); return wr },
-			New: func() interface{} { wr, _ := zlib.NewWriterLevel(nil, flate.BestSpeed); return wr },
+		customCompressLevelPool: &sync.Pool{New: func() interface{} { wr, _ := zlib.NewWriterLevel(nil, gzipCompressLevel); return wr }},
-		},
+		bestCompressionPool:     &sync.Pool{New: func() interface{} { wr, _ := zlib.NewWriterLevel(nil, flate.BestCompression); return wr }},
-		&sync.Pool{
-			New: func() interface{} { wr, _ := zlib.NewWriterLevel(nil, flate.BestCompression); return wr },
-		},
 	}
 )
 
@@ -120,7 +146,11 @@ func WriteFile(encoding string, writer io.Writer, file *os.File) (bool, string,
 
 // WriteBody reads  writes content to writer by the specific encoding(gzip/deflate)
 func WriteBody(encoding string, writer io.Writer, content []byte) (bool, string, error) {
-	return writeLevel(encoding, writer, bytes.NewReader(content), flate.BestSpeed)
+	if encoding == "" || len(content) < gzipMinLength {
+		_, err := writer.Write(content)
+		return false, "", err
+	}
+	return writeLevel(encoding, writer, bytes.NewReader(content), gzipCompressLevel)
 }
 
 // writeLevel reads from reader,writes to writer by specific encoding and compress level
@@ -156,8 +186,11 @@ func ParseEncoding(r *http.Request) string {
 	if r == nil {
 		return ""
 	}
+	if (getMethodOnly && r.Method == "GET") || includedMethods[r.Method] {
 		return parseEncoding(r)
 	}
+	return ""
+}
 
 type q struct {
 	name  string
@@ -176,9 +209,13 @@ func parseEncoding(r *http.Request) string {
 			continue
 		}
 		vs := strings.Split(v, ";")
+		var cf acceptEncoder
+		var ok bool
+		if cf, ok = encoderMap[vs[0]]; !ok {
+			continue
+		}
 		if len(vs) == 1 {
-			lastQ = q{vs[0], 1}
+			return cf.name
-			break
 		}
 		if len(vs) == 2 {
 			f, _ := strconv.ParseFloat(strings.Replace(vs[1], "q=", "", -1), 64)
@@ -186,12 +223,9 @@ func parseEncoding(r *http.Request) string {
 				continue
 			}
 			if f > lastQ.value {
-				lastQ = q{vs[0], f}
+				lastQ = q{cf.name, f}
 			}
 		}
 	}
-	if cf, ok := encoderMap[lastQ.name]; ok {
+	return lastQ.name
-		return cf.name
-	}
-	return ""
 }

context/acceptencoder_test.go

@@ -41,4 +41,19 @@ func Test_ExtractEncoding(t *testing.T) {
 	if parseEncoding(&http.Request{Header: map[string][]string{"Accept-Encoding": {"*"}}}) != "gzip" {
 		t.Fail()
 	}
+	if parseEncoding(&http.Request{Header: map[string][]string{"Accept-Encoding": {"x,gzip,deflate"}}}) != "gzip" {
+		t.Fail()
+	}
+	if parseEncoding(&http.Request{Header: map[string][]string{"Accept-Encoding": {"gzip,x,deflate"}}}) != "gzip" {
+		t.Fail()
+	}
+	if parseEncoding(&http.Request{Header: map[string][]string{"Accept-Encoding": {"gzip;q=0.5,x,deflate"}}}) != "deflate" {
+		t.Fail()
+	}
+	if parseEncoding(&http.Request{Header: map[string][]string{"Accept-Encoding": {"x"}}}) != "" {
+		t.Fail()
+	}
+	if parseEncoding(&http.Request{Header: map[string][]string{"Accept-Encoding": {"gzip;q=0.5,x;q=0.8"}}}) != "gzip" {
+		t.Fail()
+	}
 }

context/context.go

@@ -24,13 +24,11 @@ package context
 
 import (
 	"bufio"
-	"bytes"
 	"crypto/hmac"
 	"crypto/sha1"
 	"encoding/base64"
 	"errors"
 	"fmt"
-	"io"
 	"net"
 	"net/http"
 	"strconv"
@@ -67,18 +65,18 @@ func (ctx *Context) Reset(rw http.ResponseWriter, r *http.Request) {
 	ctx.ResponseWriter.reset(rw)
 	ctx.Input.Reset(ctx)
 	ctx.Output.Reset(ctx)
+	ctx._xsrfToken = ""
 }
 
 // Redirect does redirection to localurl with http header status code.
-// It sends http response header directly.
 func (ctx *Context) Redirect(status int, localurl string) {
-	ctx.Output.Header("Location", localurl)
+	http.Redirect(ctx.ResponseWriter, ctx.Request, localurl, status)
-	ctx.ResponseWriter.WriteHeader(status)
 }
 
 // Abort stops this request.
 // if beego.ErrorMaps exists, panic body.
 func (ctx *Context) Abort(status int, body string) {
+	ctx.Output.SetStatus(status)
 	panic(body)
 }
 
@@ -195,14 +193,6 @@ func (r *Response) Write(p []byte) (int, error) {
 	return r.ResponseWriter.Write(p)
 }
 
-// Copy writes the data to the connection as part of an HTTP reply,
-// and sets `started` to true.
-// started means the response has sent out.
-func (r *Response) Copy(buf *bytes.Buffer) (int64, error) {
-	r.Started = true
-	return io.Copy(r.ResponseWriter, buf)
-}
-
 // WriteHeader sends an HTTP response header with status code,
 // and sets `started` to true.
 func (r *Response) WriteHeader(code int) {

context/context_test.go

@@ -0,0 +1,47 @@
+// Copyright 2016 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 context
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestXsrfReset_01(t *testing.T) {
+	r := &http.Request{}
+	c := NewContext()
+	c.Request = r
+	c.ResponseWriter = &Response{}
+	c.ResponseWriter.reset(httptest.NewRecorder())
+	c.Output.Reset(c)
+	c.Input.Reset(c)
+	c.XSRFToken("key", 16)
+	if c._xsrfToken == "" {
+		t.FailNow()
+	}
+	token := c._xsrfToken
+	c.Reset(&Response{ResponseWriter: httptest.NewRecorder()}, r)
+	if c._xsrfToken != "" {
+		t.FailNow()
+	}
+	c.XSRFToken("key", 16)
+	if c._xsrfToken == "" {
+		t.FailNow()
+	}
+	if token == c._xsrfToken {
+		t.FailNow()
+	}
+}

context/input.go

@@ -46,6 +46,8 @@ type BeegoInput struct {
 	pvalues       []string
 	data          map[interface{}]interface{} // store some values in this context when calling context in filter or controller.
 	RequestBody   []byte
+	RunMethod     string
+	RunController reflect.Type
 }
 
 // NewInput return BeegoInput generated by Context.
@@ -89,6 +91,9 @@ func (input *BeegoInput) Site() string {
 
 // Scheme returns request scheme as "http" or "https".
 func (input *BeegoInput) Scheme() string {
+	if scheme := input.Header("X-Forwarded-Proto"); scheme != "" {
+		return scheme
+	}
 	if input.Context.Request.URL.Scheme != "" {
 		return input.Context.Request.URL.Scheme
 	}
@@ -298,6 +303,14 @@ func (input *BeegoInput) SetParam(key, val string) {
 	input.pnames = append(input.pnames, key)
 }
 
+// ResetParams clears any of the input's Params
+// This function is used to clear parameters so they may be reset between filter
+// passes.
+func (input *BeegoInput) ResetParams() {
+	input.pnames = input.pnames[:0]
+	input.pvalues = input.pvalues[:0]
+}
+
 // Query returns input data item string by a given string.
 func (input *BeegoInput) Query(key string) string {
 	if val := input.Param(key); val != "" {
@@ -326,13 +339,16 @@ func (input *BeegoInput) Cookie(key string) string {
 }
 
 // Session returns current session item value by a given key.
-// if non-existed, return empty string.
+// if non-existed, return nil.
 func (input *BeegoInput) Session(key interface{}) interface{} {
 	return input.CruSession.Get(key)
 }
 
 // CopyBody returns the raw request body data as bytes.
 func (input *BeegoInput) CopyBody(MaxMemory int64) []byte {
+	if input.Context.Request.Body == nil {
+		return []byte{}
+	}
 	safe := &io.LimitedReader{R: input.Context.Request.Body, N: MaxMemory}
 	requestbody, _ := ioutil.ReadAll(safe)
 	input.Context.Request.Body.Close()
@@ -397,7 +413,13 @@ func (input *BeegoInput) Bind(dest interface{}, key string) error {
 	if !value.CanSet() {
 		return errors.New("beego: non-settable variable passed to Bind: " + key)
 	}
-	rv := input.bind(key, value.Type())
+	typ := value.Type()
+	// Get real type if dest define with interface{}.
+	// e.g  var dest interface{} dest=1.0
+	if value.Kind() == reflect.Interface {
+		typ = value.Elem().Type()
+	}
+	rv := input.bind(key, typ)
 	if !rv.IsValid() {
 		return errors.New("beego: reflect value is empty")
 	}
@@ -406,6 +428,9 @@ func (input *BeegoInput) Bind(dest interface{}, key string) error {
 }
 
 func (input *BeegoInput) bind(key string, typ reflect.Type) reflect.Value {
+	if input.Context.Request.Form == nil {
+		input.Context.Request.ParseForm()
+	}
 	rv := reflect.Zero(typ)
 	switch typ.Kind() {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
@@ -576,12 +601,15 @@ func (input *BeegoInput) bindStruct(params *url.Values, key string, typ reflect.
 	result := reflect.New(typ).Elem()
 	fieldValues := make(map[string]reflect.Value)
 	for reqKey, val := range *params {
-		if !strings.HasPrefix(reqKey, key+".") {
+		var fieldName string
+		if strings.HasPrefix(reqKey, key+".") {
+			fieldName = reqKey[len(key)+1:]
+		} else if strings.HasPrefix(reqKey, key+"[") && reqKey[len(reqKey)-1] == ']' {
+			fieldName = reqKey[len(key)+1 : len(reqKey)-1]
+		} else {
 			continue
 		}
 
-		fieldName := reqKey[len(key)+1:]
-
 		if _, ok := fieldValues[fieldName]; !ok {
 			// Time to bind this field.  Get it and make sure we can set it.
 			fieldValue := result.FieldByName(fieldName)

context/input_test.go

@@ -15,64 +15,98 @@
 package context
 
 import (
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"reflect"
 	"testing"
 )
 
-func TestParse(t *testing.T) {
+func TestBind(t *testing.T) {
-	r, _ := http.NewRequest("GET", "/?id=123&isok=true&ft=1.2&ol[0]=1&ol[1]=2&ul[]=str&ul[]=array&user.Name=astaxie", nil)
+	type testItem struct {
+		field string
+		empty interface{}
+		want  interface{}
+	}
+	type Human struct {
+		ID   int
+		Nick string
+		Pwd  string
+		Ms   bool
+	}
+
+	cases := []struct {
+		request string
+		valueGp []testItem
+	}{
+		{"/?p=str", []testItem{{"p", interface{}(""), interface{}("str")}}},
+
+		{"/?p=", []testItem{{"p", "", ""}}},
+		{"/?p=str", []testItem{{"p", "", "str"}}},
+
+		{"/?p=123", []testItem{{"p", 0, 123}}},
+		{"/?p=123", []testItem{{"p", uint(0), uint(123)}}},
+
+		{"/?p=1.0", []testItem{{"p", 0.0, 1.0}}},
+		{"/?p=1", []testItem{{"p", false, true}}},
+
+		{"/?p=true", []testItem{{"p", false, true}}},
+		{"/?p=ON", []testItem{{"p", false, true}}},
+		{"/?p=on", []testItem{{"p", false, true}}},
+		{"/?p=1", []testItem{{"p", false, true}}},
+		{"/?p=2", []testItem{{"p", false, false}}},
+		{"/?p=false", []testItem{{"p", false, false}}},
+
+		{"/?p[a]=1&p[b]=2&p[c]=3", []testItem{{"p", map[string]int{}, map[string]int{"a": 1, "b": 2, "c": 3}}}},
+		{"/?p[a]=v1&p[b]=v2&p[c]=v3", []testItem{{"p", map[string]string{}, map[string]string{"a": "v1", "b": "v2", "c": "v3"}}}},
+
+		{"/?p[]=8&p[]=9&p[]=10", []testItem{{"p", []int{}, []int{8, 9, 10}}}},
+		{"/?p[0]=8&p[1]=9&p[2]=10", []testItem{{"p", []int{}, []int{8, 9, 10}}}},
+		{"/?p[0]=8&p[1]=9&p[2]=10&p[5]=14", []testItem{{"p", []int{}, []int{8, 9, 10, 0, 0, 14}}}},
+		{"/?p[0]=8.0&p[1]=9.0&p[2]=10.0", []testItem{{"p", []float64{}, []float64{8.0, 9.0, 10.0}}}},
+
+		{"/?p[]=10&p[]=9&p[]=8", []testItem{{"p", []string{}, []string{"10", "9", "8"}}}},
+		{"/?p[0]=8&p[1]=9&p[2]=10", []testItem{{"p", []string{}, []string{"8", "9", "10"}}}},
+
+		{"/?p[0]=true&p[1]=false&p[2]=true&p[5]=1&p[6]=ON&p[7]=other", []testItem{{"p", []bool{}, []bool{true, false, true, false, false, true, true, false}}}},
+
+		{"/?human.Nick=astaxie", []testItem{{"human", Human{}, Human{Nick: "astaxie"}}}},
+		{"/?human.ID=888&human.Nick=astaxie&human.Ms=true&human[Pwd]=pass", []testItem{{"human", Human{}, Human{ID: 888, Nick: "astaxie", Ms: true, Pwd: "pass"}}}},
+		{"/?human[0].ID=888&human[0].Nick=astaxie&human[0].Ms=true&human[0][Pwd]=pass01&human[1].ID=999&human[1].Nick=ysqi&human[1].Ms=On&human[1].Pwd=pass02",
+			[]testItem{{"human", []Human{}, []Human{
+				Human{ID: 888, Nick: "astaxie", Ms: true, Pwd: "pass01"},
+				Human{ID: 999, Nick: "ysqi", Ms: true, Pwd: "pass02"},
+			}}}},
+
+		{
+			"/?id=123&isok=true&ft=1.2&ol[0]=1&ol[1]=2&ul[]=str&ul[]=array&human.Nick=astaxie",
+			[]testItem{
+				{"id", 0, 123},
+				{"isok", false, true},
+				{"ft", 0.0, 1.2},
+				{"ol", []int{}, []int{1, 2}},
+				{"ul", []string{}, []string{"str", "array"}},
+				{"human", Human{}, Human{Nick: "astaxie"}},
+			},
+		},
+	}
+	for _, c := range cases {
+		r, _ := http.NewRequest("GET", c.request, nil)
 		beegoInput := NewInput()
 		beegoInput.Context = NewContext()
 		beegoInput.Context.Reset(httptest.NewRecorder(), r)
-	beegoInput.ParseFormOrMulitForm(1 << 20)
 
-	var id int
+		for _, item := range c.valueGp {
-	err := beegoInput.Bind(&id, "id")
+			got := item.empty
-	if id != 123 || err != nil {
+			err := beegoInput.Bind(&got, item.field)
-		t.Fatal("id should has int value")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(got, item.want) {
+				t.Fatalf("Bind %q error,should be:\n%#v \ngot:\n%#v", item.field, item.want, got)
+			}
 		}
-	fmt.Println(id)
 
-	var isok bool
-	err = beegoInput.Bind(&isok, "isok")
-	if !isok || err != nil {
-		t.Fatal("isok should be true")
 	}
-	fmt.Println(isok)
-
-	var float float64
-	err = beegoInput.Bind(&float, "ft")
-	if float != 1.2 || err != nil {
-		t.Fatal("float should be equal to 1.2")
-	}
-	fmt.Println(float)
-
-	ol := make([]int, 0, 2)
-	err = beegoInput.Bind(&ol, "ol")
-	if len(ol) != 2 || err != nil || ol[0] != 1 || ol[1] != 2 {
-		t.Fatal("ol should has two elements")
-	}
-	fmt.Println(ol)
-
-	ul := make([]string, 0, 2)
-	err = beegoInput.Bind(&ul, "ul")
-	if len(ul) != 2 || err != nil || ul[0] != "str" || ul[1] != "array" {
-		t.Fatal("ul should has two elements")
-	}
-	fmt.Println(ul)
-
-	type User struct {
-		Name string
-	}
-	user := User{}
-	err = beegoInput.Bind(&user, "user")
-	if err != nil || user.Name != "astaxie" {
-		t.Fatal("user should has name")
-	}
-	fmt.Println(user)
 }
 
 func TestSubDomain(t *testing.T) {
@@ -100,7 +134,7 @@ func TestSubDomain(t *testing.T) {
 
 	/* TODO Fix this
 	r, _ = http.NewRequest("GET", "http://127.0.0.1/", nil)
-	beegoInput.Request = r
+	beegoInput.Context.Request = r
 	if beegoInput.SubDomains() != "" {
 		t.Fatal("Subdomain parse error, got " + beegoInput.SubDomains())
 	}

context/output.go

@@ -21,8 +21,11 @@ import (
 	"errors"
 	"fmt"
 	"html/template"
+	"io"
 	"mime"
 	"net/http"
+	"net/url"
+	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -64,6 +67,7 @@ func (output *BeegoOutput) Body(content []byte) error {
 	}
 	if b, n, _ := WriteBody(encoding, buf, content); b {
 		output.Header("Content-Encoding", n)
+		output.Header("Content-Length", strconv.Itoa(buf.Len()))
 	} else {
 		output.Header("Content-Length", strconv.Itoa(len(content)))
 	}
@@ -72,10 +76,11 @@ func (output *BeegoOutput) Body(content []byte) error {
 	if output.Status != 0 {
 		output.Context.ResponseWriter.WriteHeader(output.Status)
 		output.Status = 0
+	} else {
+		output.Context.ResponseWriter.Started = true
 	}
-
+	io.Copy(output.Context.ResponseWriter, buf)
-	_, err := output.Context.ResponseWriter.Copy(buf)
+	return nil
-	return err
 }
 
 // Cookie sets cookie value via given key.
@@ -142,17 +147,11 @@ func (output *BeegoOutput) Cookie(name string, value string, others ...interface
 	}
 
 	// default false. for session cookie default true
-	httponly := false
 	if len(others) > 4 {
 		if v, ok := others[4].(bool); ok && v {
-			// HttpOnly = true
-			httponly = true
-		}
-	}
-
-	if httponly {
 			fmt.Fprintf(&b, "; HttpOnly")
 		}
+	}
 
 	output.Context.ResponseWriter.Header().Add("Set-Cookie", b.String())
 }
@@ -208,7 +207,8 @@ func (output *BeegoOutput) JSONP(data interface{}, hasIndent bool) error {
 	if callback == "" {
 		return errors.New(`"callback" parameter required`)
 	}
-	callbackContent := bytes.NewBufferString(" " + template.JSEscapeString(callback))
+	callback = template.JSEscapeString(callback)
+	callbackContent := bytes.NewBufferString(" if(window." + callback + ")" + callback)
 	callbackContent.WriteString("(")
 	callbackContent.Write(content)
 	callbackContent.WriteString(");\r\n")
@@ -235,13 +235,21 @@ func (output *BeegoOutput) XML(data interface{}, hasIndent bool) error {
 // Download forces response for download file.
 // it prepares the download response header automatically.
 func (output *BeegoOutput) Download(file string, filename ...string) {
+	// check get file error, file not found or other error.
+	if _, err := os.Stat(file); err != nil {
+		http.ServeFile(output.Context.ResponseWriter, output.Context.Request, file)
+		return
+	}
+
+	var fName string
+	if len(filename) > 0 && filename[0] != "" {
+		fName = filename[0]
+	} else {
+		fName = filepath.Base(file)
+	}
+	output.Header("Content-Disposition", "attachment; filename="+url.QueryEscape(fName))
 	output.Header("Content-Description", "File Transfer")
 	output.Header("Content-Type", "application/octet-stream")
-	if len(filename) > 0 && filename[0] != "" {
-		output.Header("Content-Disposition", "attachment; filename="+filename[0])
-	} else {
-		output.Header("Content-Disposition", "attachment; filename="+filepath.Base(file))
-	}
 	output.Header("Content-Transfer-Encoding", "binary")
 	output.Header("Expires", "0")
 	output.Header("Cache-Control", "must-revalidate")
@@ -269,70 +277,71 @@ func (output *BeegoOutput) SetStatus(status int) {
 
 // IsCachable returns boolean of this request is cached.
 // HTTP 304 means cached.
-func (output *BeegoOutput) IsCachable(status int) bool {
+func (output *BeegoOutput) IsCachable() bool {
 	return output.Status >= 200 && output.Status < 300 || output.Status == 304
 }
 
 // IsEmpty returns boolean of this request is empty.
 // HTTP 201，204 and 304 means empty.
-func (output *BeegoOutput) IsEmpty(status int) bool {
+func (output *BeegoOutput) IsEmpty() bool {
 	return output.Status == 201 || output.Status == 204 || output.Status == 304
 }
 
 // IsOk returns boolean of this request runs well.
 // HTTP 200 means ok.
-func (output *BeegoOutput) IsOk(status int) bool {
+func (output *BeegoOutput) IsOk() bool {
 	return output.Status == 200
 }
 
 // IsSuccessful returns boolean of this request runs successfully.
 // HTTP 2xx means ok.
-func (output *BeegoOutput) IsSuccessful(status int) bool {
+func (output *BeegoOutput) IsSuccessful() bool {
 	return output.Status >= 200 && output.Status < 300
 }
 
 // IsRedirect returns boolean of this request is redirection header.
 // HTTP 301,302,307 means redirection.
-func (output *BeegoOutput) IsRedirect(status int) bool {
+func (output *BeegoOutput) IsRedirect() bool {
 	return output.Status == 301 || output.Status == 302 || output.Status == 303 || output.Status == 307
 }
 
 // IsForbidden returns boolean of this request is forbidden.
 // HTTP 403 means forbidden.
-func (output *BeegoOutput) IsForbidden(status int) bool {
+func (output *BeegoOutput) IsForbidden() bool {
 	return output.Status == 403
 }
 
 // IsNotFound returns boolean of this request is not found.
 // HTTP 404 means forbidden.
-func (output *BeegoOutput) IsNotFound(status int) bool {
+func (output *BeegoOutput) IsNotFound() bool {
 	return output.Status == 404
 }
 
 // IsClientError returns boolean of this request client sends error data.
 // HTTP 4xx means forbidden.
-func (output *BeegoOutput) IsClientError(status int) bool {
+func (output *BeegoOutput) IsClientError() bool {
 	return output.Status >= 400 && output.Status < 500
 }
 
 // IsServerError returns boolean of this server handler errors.
 // HTTP 5xx means server internal error.
-func (output *BeegoOutput) IsServerError(status int) bool {
+func (output *BeegoOutput) IsServerError() bool {
 	return output.Status >= 500 && output.Status < 600
 }
 
 func stringsToJSON(str string) string {
 	rs := []rune(str)
-	jsons := ""
+	var jsons bytes.Buffer
 	for _, r := range rs {
 		rint := int(r)
 		if rint < 128 {
-			jsons += string(r)
+			jsons.WriteRune(r)
 		} else {
-			jsons += "\\u" + strconv.FormatInt(int64(rint), 16) // json
+			jsons.WriteString("\\u")
+			jsons.WriteString(strconv.FormatInt(int64(rint), 16))
 		}
 	}
-	return jsons
+	return jsons.String()
 }
 
 // Session sets session item value with given key.

controller.go

@@ -69,8 +69,10 @@ type Controller struct {
 
 	// template data
 	TplName        string
+	ViewPath       string
 	Layout         string
 	LayoutSections map[string]string // the key is the section name and the value is the template name
+	TplPrefix      string
 	TplExt         string
 	EnableRender   bool
 
@@ -184,7 +186,11 @@ func (c *Controller) Render() error {
 	if err != nil {
 		return err
 	}
+
+	if c.Ctx.ResponseWriter.Header().Get("Content-Type") == "" {
 		c.Ctx.Output.Header("Content-Type", "text/html; charset=utf-8")
+	}
+
 	return c.Ctx.Output.Body(rb)
 }
 
@@ -208,7 +214,7 @@ func (c *Controller) RenderBytes() ([]byte, error) {
 					continue
 				}
 				buf.Reset()
-				err = executeTemplate(&buf, sectionTpl, c.Data)
+				err = ExecuteViewPathTemplate(&buf, sectionTpl, c.viewPath(), c.Data)
 				if err != nil {
 					return nil, err
 				}
@@ -217,7 +223,7 @@ func (c *Controller) RenderBytes() ([]byte, error) {
 		}
 
 		buf.Reset()
-		executeTemplate(&buf, c.Layout, c.Data)
+		ExecuteViewPathTemplate(&buf, c.Layout, c.viewPath() ,c.Data)
 	}
 	return buf.Bytes(), err
 }
@@ -227,6 +233,9 @@ func (c *Controller) renderTemplate() (bytes.Buffer, error) {
 	if c.TplName == "" {
 		c.TplName = strings.ToLower(c.controllerName) + "/" + strings.ToLower(c.actionName) + "." + c.TplExt
 	}
+	if c.TplPrefix != "" {
+		c.TplName = c.TplPrefix + c.TplName
+	}
 	if BConfig.RunMode == DEV {
 		buildFiles := []string{c.TplName}
 		if c.Layout != "" {
@@ -240,9 +249,16 @@ func (c *Controller) renderTemplate() (bytes.Buffer, error) {
 				}
 			}
 		}
-		BuildTemplate(BConfig.WebConfig.ViewsPath, buildFiles...)
+		BuildTemplate(c.viewPath() , buildFiles...)
 	}
-	return buf, executeTemplate(&buf, c.TplName, c.Data)
+	return buf, ExecuteViewPathTemplate(&buf, c.TplName, c.viewPath(), c.Data)
+}
+
+func (c *Controller) viewPath() string {
+	if c.ViewPath == "" {
+		return BConfig.WebConfig.ViewsPath
+	}
+	return c.ViewPath
 }
 
 // Redirect sends the redirection response to url with status code.
@@ -261,12 +277,13 @@ func (c *Controller) Abort(code string) {
 
 // CustomAbort stops controller handler and show the error data, it's similar Aborts, but support status code and body.
 func (c *Controller) CustomAbort(status int, body string) {
-	c.Ctx.Output.Status = status
+	// first panic from ErrorMaps, it is user defined error functions.
-	// first panic from ErrorMaps, is is user defined error functions.
 	if _, ok := ErrorMaps[body]; ok {
+		c.Ctx.Output.Status = status
 		panic(body)
 	}
 	// last panic user string
+	c.Ctx.ResponseWriter.WriteHeader(status)
 	c.Ctx.ResponseWriter.Write([]byte(body))
 	panic(ErrAbort)
 }
@@ -394,6 +411,16 @@ func (c *Controller) GetInt8(key string, def ...int8) (int8, error) {
 	return int8(i64), err
 }
 
+// GetUint8 return input as an uint8 or the default value while it's present and input is blank
+func (c *Controller) GetUint8(key string, def ...uint8) (uint8, error) {
+	strv := c.Ctx.Input.Query(key)
+	if len(strv) == 0 && len(def) > 0 {
+		return def[0], nil
+	}
+	u64, err := strconv.ParseUint(strv, 10, 8)
+	return uint8(u64), err
+}
+
 // GetInt16 returns input as an int16 or the default value while it's present and input is blank
 func (c *Controller) GetInt16(key string, def ...int16) (int16, error) {
 	strv := c.Ctx.Input.Query(key)
@@ -404,6 +431,16 @@ func (c *Controller) GetInt16(key string, def ...int16) (int16, error) {
 	return int16(i64), err
 }
 
+// GetUint16 returns input as an uint16 or the default value while it's present and input is blank
+func (c *Controller) GetUint16(key string, def ...uint16) (uint16, error) {
+	strv := c.Ctx.Input.Query(key)
+	if len(strv) == 0 && len(def) > 0 {
+		return def[0], nil
+	}
+	u64, err := strconv.ParseUint(strv, 10, 16)
+	return uint16(u64), err
+}
+
 // GetInt32 returns input as an int32 or the default value while it's present and input is blank
 func (c *Controller) GetInt32(key string, def ...int32) (int32, error) {
 	strv := c.Ctx.Input.Query(key)
@@ -414,6 +451,16 @@ func (c *Controller) GetInt32(key string, def ...int32) (int32, error) {
 	return int32(i64), err
 }
 
+// GetUint32 returns input as an uint32 or the default value while it's present and input is blank
+func (c *Controller) GetUint32(key string, def ...uint32) (uint32, error) {
+	strv := c.Ctx.Input.Query(key)
+	if len(strv) == 0 && len(def) > 0 {
+		return def[0], nil
+	}
+	u64, err := strconv.ParseUint(strv, 10, 32)
+	return uint32(u64), err
+}
+
 // GetInt64 returns input value as int64 or the default value while it's present and input is blank.
 func (c *Controller) GetInt64(key string, def ...int64) (int64, error) {
 	strv := c.Ctx.Input.Query(key)
@@ -423,6 +470,15 @@ func (c *Controller) GetInt64(key string, def ...int64) (int64, error) {
 	return strconv.ParseInt(strv, 10, 64)
 }
 
+// GetUint64 returns input value as uint64 or the default value while it's present and input is blank.
+func (c *Controller) GetUint64(key string, def ...uint64) (uint64, error) {
+	strv := c.Ctx.Input.Query(key)
+	if len(strv) == 0 && len(def) > 0 {
+		return def[0], nil
+	}
+	return strconv.ParseUint(strv, 10, 64)
+}
+
 // GetBool returns input value as bool or the default value while it's present and input is blank.
 func (c *Controller) GetBool(key string, def ...bool) (bool, error) {
 	strv := c.Ctx.Input.Query(key)
@@ -448,7 +504,7 @@ func (c *Controller) GetFile(key string) (multipart.File, *multipart.FileHeader,
 }
 
 // GetFiles return multi-upload files
-// files, err:=c.Getfiles("myfiles")
+// files, err:=c.GetFiles("myfiles")
 //	if err != nil {
 //		http.Error(w, err.Error(), http.StatusNoContent)
 //		return

controller_test.go

@@ -15,9 +15,13 @@
 package beego
 
 import (
+	"math"
+	"strconv"
 	"testing"
 
 	"github.com/astaxie/beego/context"
+	"os"
+	"path/filepath"
 )
 
 func TestGetInt(t *testing.T) {
@@ -75,3 +79,103 @@ func TestGetInt64(t *testing.T) {
 		t.Errorf("TestGeetInt64 expect 40,get %T,%v", val, val)
 	}
 }
+
+func TestGetUint8(t *testing.T) {
+	i := context.NewInput()
+	i.SetParam("age", strconv.FormatUint(math.MaxUint8, 10))
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+	val, _ := ctrlr.GetUint8("age")
+	if val != math.MaxUint8 {
+		t.Errorf("TestGetUint8 expect %v,get %T,%v", math.MaxUint8, val, val)
+	}
+}
+
+func TestGetUint16(t *testing.T) {
+	i := context.NewInput()
+	i.SetParam("age", strconv.FormatUint(math.MaxUint16, 10))
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+	val, _ := ctrlr.GetUint16("age")
+	if val != math.MaxUint16 {
+		t.Errorf("TestGetUint16 expect %v,get %T,%v", math.MaxUint16, val, val)
+	}
+}
+
+func TestGetUint32(t *testing.T) {
+	i := context.NewInput()
+	i.SetParam("age", strconv.FormatUint(math.MaxUint32, 10))
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+	val, _ := ctrlr.GetUint32("age")
+	if val != math.MaxUint32 {
+		t.Errorf("TestGetUint32 expect %v,get %T,%v", math.MaxUint32, val, val)
+	}
+}
+
+func TestGetUint64(t *testing.T) {
+	i := context.NewInput()
+	i.SetParam("age", strconv.FormatUint(math.MaxUint64, 10))
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+	val, _ := ctrlr.GetUint64("age")
+	if val != math.MaxUint64 {
+		t.Errorf("TestGetUint64 expect %v,get %T,%v", uint64(math.MaxUint64), val, val)
+	}
+}
+
+func TestAdditionalViewPaths(t *testing.T) {
+	dir1 := "_beeTmp"
+	dir2 := "_beeTmp2"
+	defer os.RemoveAll(dir1)
+	defer os.RemoveAll(dir2)
+
+	dir1file := "file1.tpl"
+	dir2file := "file2.tpl"
+
+	genFile := func(dir string, name string, content string) {
+		os.MkdirAll(filepath.Dir(filepath.Join(dir, name)), 0777)
+		if f, err := os.Create(filepath.Join(dir, name)); err != nil {
+			t.Fatal(err)
+		} else {
+			defer f.Close()
+			f.WriteString(content)
+			f.Close()
+		}
+
+	}
+	genFile(dir1, dir1file, `<div>{{.Content}}</div>`)
+	genFile(dir2, dir2file, `<html>{{.Content}}</html>`)
+
+	AddViewPath(dir1)
+	AddViewPath(dir2)
+
+	ctrl := Controller{
+		TplName:  "file1.tpl",
+		ViewPath: dir1,
+	}
+	ctrl.Data = map[interface{}]interface{}{
+		"Content": "value2",
+	}
+	if result, err := ctrl.RenderString(); err != nil {
+		t.Fatal(err)
+	} else {
+		if result != "<div>value2</div>" {
+			t.Fatalf("TestAdditionalViewPaths expect %s got %s", "<div>value2</div>", result)
+		}
+	}
+
+	func() {
+		ctrl.TplName = "file2.tpl"
+		defer func() {
+			if r := recover(); r == nil {
+				t.Fatal("TestAdditionalViewPaths expected error")
+			}
+		}()
+		ctrl.RenderString();
+	}()
+
+	ctrl.TplName = "file2.tpl"
+	ctrl.ViewPath = dir2
+	ctrl.RenderString();
+}

error.go

@@ -93,7 +93,11 @@ func showErr(err interface{}, ctx *context.Context, stack string) {
 		"BeegoVersion":  VERSION,
 		"GoVersion":     runtime.Version(),
 	}
+	if ctx.Output.Status != 0 {
+		ctx.ResponseWriter.WriteHeader(ctx.Output.Status)
+	} else {
 		ctx.ResponseWriter.WriteHeader(500)
+	}
 	t.Execute(ctx.ResponseWriter, data)
 }
 
@@ -210,159 +214,139 @@ var ErrorMaps = make(map[string]*errorInfo, 10)
 
 // show 401 unauthorized error.
 func unauthorized(rw http.ResponseWriter, r *http.Request) {
-	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	responseError(rw, r,
-	data := map[string]interface{}{
+		401,
-		"Title":        http.StatusText(401),
+		"<br>The page you have requested can't be authorized."+
-		"BeegoVersion": VERSION,
-	}
-	data["Content"] = template.HTML("<br>The page you have requested can't be authorized." +
 			"<br>Perhaps you are here because:"+
 			"<br><br><ul>"+
 			"<br>The credentials you supplied are incorrect"+
 			"<br>There are errors in the website address"+
-		"</ul>")
+			"</ul>",
-	t.Execute(rw, data)
+	)
 }
 
 // show 402 Payment Required
 func paymentRequired(rw http.ResponseWriter, r *http.Request) {
-	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	responseError(rw, r,
-	data := map[string]interface{}{
+		402,
-		"Title":        http.StatusText(402),
+		"<br>The page you have requested Payment Required."+
-		"BeegoVersion": VERSION,
-	}
-	data["Content"] = template.HTML("<br>The page you have requested Payment Required." +
 			"<br>Perhaps you are here because:"+
 			"<br><br><ul>"+
 			"<br>The credentials you supplied are incorrect"+
 			"<br>There are errors in the website address"+
-		"</ul>")
+			"</ul>",
-	t.Execute(rw, data)
+	)
 }
 
 // show 403 forbidden error.
 func forbidden(rw http.ResponseWriter, r *http.Request) {
-	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	responseError(rw, r,
-	data := map[string]interface{}{
+		403,
-		"Title":        http.StatusText(403),
+		"<br>The page you have requested is forbidden."+
-		"BeegoVersion": VERSION,
-	}
-	data["Content"] = template.HTML("<br>The page you have requested is forbidden." +
 			"<br>Perhaps you are here because:"+
 			"<br><br><ul>"+
 			"<br>Your address may be blocked"+
 			"<br>The site may be disabled"+
 			"<br>You need to log in"+
-		"</ul>")
+			"</ul>",
-	t.Execute(rw, data)
+	)
 }
 
 // show 404 not found error.
 func notFound(rw http.ResponseWriter, r *http.Request) {
-	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	responseError(rw, r,
-	data := map[string]interface{}{
+		404,
-		"Title":        http.StatusText(404),
+		"<br>The page you have requested has flown the coop."+
-		"BeegoVersion": VERSION,
-	}
-	data["Content"] = template.HTML("<br>The page you have requested has flown the coop." +
 			"<br>Perhaps you are here because:"+
 			"<br><br><ul>"+
 			"<br>The page has moved"+
 			"<br>The page no longer exists"+
 			"<br>You were looking for your puppy and got lost"+
 			"<br>You like 404 pages"+
-		"</ul>")
+			"</ul>",
-	t.Execute(rw, data)
+	)
 }
 
 // show 405 Method Not Allowed
 func methodNotAllowed(rw http.ResponseWriter, r *http.Request) {
-	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	responseError(rw, r,
-	data := map[string]interface{}{
+		405,
-		"Title":        http.StatusText(405),
+		"<br>The method you have requested Not Allowed."+
-		"BeegoVersion": VERSION,
-	}
-	data["Content"] = template.HTML("<br>The method you have requested Not Allowed." +
 			"<br>Perhaps you are here because:"+
 			"<br><br><ul>"+
 			"<br>The method specified in the Request-Line is not allowed for the resource identified by the Request-URI"+
 			"<br>The response MUST include an Allow header containing a list of valid methods for the requested resource."+
-		"</ul>")
+			"</ul>",
-	t.Execute(rw, data)
+	)
 }
 
 // show 500 internal server error.
 func internalServerError(rw http.ResponseWriter, r *http.Request) {
-	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	responseError(rw, r,
-	data := map[string]interface{}{
+		500,
-		"Title":        http.StatusText(500),
+		"<br>The page you have requested is down right now."+
-		"BeegoVersion": VERSION,
-	}
-	data["Content"] = template.HTML("<br>The page you have requested is down right now." +
 			"<br><br><ul>"+
 			"<br>Please try again later and report the error to the website administrator"+
-		"<br></ul>")
+			"<br></ul>",
-	t.Execute(rw, data)
+	)
 }
 
 // show 501 Not Implemented.
 func notImplemented(rw http.ResponseWriter, r *http.Request) {
-	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	responseError(rw, r,
-	data := map[string]interface{}{
+		501,
-		"Title":        http.StatusText(504),
+		"<br>The page you have requested is Not Implemented."+
-		"BeegoVersion": VERSION,
-	}
-	data["Content"] = template.HTML("<br>The page you have requested is Not Implemented." +
 			"<br><br><ul>"+
 			"<br>Please try again later and report the error to the website administrator"+
-		"<br></ul>")
+			"<br></ul>",
-	t.Execute(rw, data)
+	)
 }
 
 // show 502 Bad Gateway.
 func badGateway(rw http.ResponseWriter, r *http.Request) {
-	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	responseError(rw, r,
-	data := map[string]interface{}{
+		502,
-		"Title":        http.StatusText(502),
+		"<br>The page you have requested is down right now."+
-		"BeegoVersion": VERSION,
-	}
-	data["Content"] = template.HTML("<br>The page you have requested is down right now." +
 			"<br><br><ul>"+
 			"<br>The server, while acting as a gateway or proxy, received an invalid response from the upstream server it accessed in attempting to fulfill the request."+
 			"<br>Please try again later and report the error to the website administrator"+
-		"<br></ul>")
+			"<br></ul>",
-	t.Execute(rw, data)
+	)
 }
 
 // show 503 service unavailable error.
 func serviceUnavailable(rw http.ResponseWriter, r *http.Request) {
-	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	responseError(rw, r,
-	data := map[string]interface{}{
+		503,
-		"Title":        http.StatusText(503),
+		"<br>The page you have requested is unavailable."+
-		"BeegoVersion": VERSION,
-	}
-	data["Content"] = template.HTML("<br>The page you have requested is unavailable." +
 			"<br>Perhaps you are here because:"+
 			"<br><br><ul>"+
 			"<br><br>The page is overloaded"+
 			"<br>Please try again later."+
-		"</ul>")
+			"</ul>",
-	t.Execute(rw, data)
+	)
 }
 
 // show 504 Gateway Timeout.
 func gatewayTimeout(rw http.ResponseWriter, r *http.Request) {
-	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	responseError(rw, r,
-	data := map[string]interface{}{
+		504,
-		"Title":        http.StatusText(504),
+		"<br>The page you have requested is unavailable"+
-		"BeegoVersion": VERSION,
-	}
-	data["Content"] = template.HTML("<br>The page you have requested is unavailable." +
 			"<br>Perhaps you are here because:"+
 			"<br><br><ul>"+
 			"<br><br>The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URI."+
 			"<br>Please try again later."+
-		"</ul>")
+			"</ul>",
+	)
+}
+
+func responseError(rw http.ResponseWriter, r *http.Request, errCode int, errContent string) {
+	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	data := map[string]interface{}{
+		"Title":        http.StatusText(errCode),
+		"BeegoVersion": VERSION,
+		"Content":      template.HTML(errContent),
+	}
 	t.Execute(rw, data)
 }
 
@@ -400,6 +384,11 @@ func ErrorController(c ControllerInterface) *App {
 	return BeeApp
 }
 
+// Exception Write HttpStatus with errCode and Exec error handler if exist.
+func Exception(errCode uint64, ctx *context.Context) {
+	exception(strconv.FormatUint(errCode, 10), ctx)
+}
+
 // show error string as simple text message.
 // if error string is empty, show 503 or 500 error as default.
 func exception(errCode string, ctx *context.Context) {
@@ -408,8 +397,11 @@ func exception(errCode string, ctx *context.Context) {
 		if err == nil {
 			return v
 		}
+		if ctx.Output.Status == 0 {
 			return 503
 		}
+		return ctx.Output.Status
+	}
 
 	for _, ec := range []string{errCode, "503", "500"} {
 		if h, ok := ErrorMaps[ec]; ok {

error_test.go

@@ -0,0 +1,88 @@
+// Copyright 2016 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 beego
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type errorTestController struct {
+	Controller
+}
+
+const parseCodeError = "parse code error"
+
+func (ec *errorTestController) Get() {
+	errorCode, err := ec.GetInt("code")
+	if err != nil {
+		ec.Abort(parseCodeError)
+	}
+	if errorCode != 0 {
+		ec.CustomAbort(errorCode, ec.GetString("code"))
+	}
+	ec.Abort("404")
+}
+
+func TestErrorCode_01(t *testing.T) {
+	registerDefaultErrorHandler()
+	for k := range ErrorMaps {
+		r, _ := http.NewRequest("GET", "/error?code="+k, nil)
+		w := httptest.NewRecorder()
+
+		handler := NewControllerRegister()
+		handler.Add("/error", &errorTestController{})
+		handler.ServeHTTP(w, r)
+		code, _ := strconv.Atoi(k)
+		if w.Code != code {
+			t.Fail()
+		}
+		if !strings.Contains(string(w.Body.Bytes()), http.StatusText(code)) {
+			t.Fail()
+		}
+	}
+}
+
+func TestErrorCode_02(t *testing.T) {
+	registerDefaultErrorHandler()
+	r, _ := http.NewRequest("GET", "/error?code=0", nil)
+	w := httptest.NewRecorder()
+
+	handler := NewControllerRegister()
+	handler.Add("/error", &errorTestController{})
+	handler.ServeHTTP(w, r)
+	if w.Code != 404 {
+		t.Fail()
+	}
+}
+
+func TestErrorCode_03(t *testing.T) {
+	registerDefaultErrorHandler()
+	r, _ := http.NewRequest("GET", "/error?code=panic", nil)
+	w := httptest.NewRecorder()
+
+	handler := NewControllerRegister()
+	handler.Add("/error", &errorTestController{})
+	handler.ServeHTTP(w, r)
+	if w.Code != 200 {
+		t.Fail()
+	}
+	if string(w.Body.Bytes()) != parseCodeError {
+		t.Fail()
+	}
+}

filter.go

@@ -27,6 +27,7 @@ type FilterRouter struct {
 	tree           *Tree
 	pattern        string
 	returnOnOutput bool
+	resetParams    bool
 }
 
 // ValidRouter checks if the current request is matched by this filter.

filter_test.go

@@ -20,14 +20,8 @@ import (
 	"testing"
 
 	"github.com/astaxie/beego/context"
-	"github.com/astaxie/beego/logs"
 )
 
-func init() {
-	BeeLogger = logs.NewLogger(10000)
-	BeeLogger.SetLogger("console", "")
-}
-
 var FilterUser = func(ctx *context.Context) {
 	ctx.Output.Body([]byte("i am " + ctx.Input.Param(":last") + ctx.Input.Param(":first")))
 }

grace/grace.go

@@ -85,23 +85,31 @@ var (
 
 	isChild     bool
 	socketOrder string
-	once        sync.Once
+
+	hookableSignals []os.Signal
 )
 
-func onceInit() {
+func init() {
-	regLock = &sync.Mutex{}
 	flag.BoolVar(&isChild, "graceful", false, "listen on open fd (after forking)")
 	flag.StringVar(&socketOrder, "socketorder", "", "previous initialization order - used when more than one listener was started")
+
+	regLock = &sync.Mutex{}
 	runningServers = make(map[string]*Server)
 	runningServersOrder = []string{}
 	socketPtrOffsetMap = make(map[string]uint)
+
+	hookableSignals = []os.Signal{
+		syscall.SIGHUP,
+		syscall.SIGINT,
+		syscall.SIGTERM,
+	}
 }
 
 // NewServer returns a new graceServer.
 func NewServer(addr string, handler http.Handler) (srv *Server) {
-	once.Do(onceInit)
 	regLock.Lock()
 	defer regLock.Unlock()
+
 	if !flag.Parsed() {
 		flag.Parse()
 	}

grace/server.go

@@ -162,9 +162,7 @@ func (srv *Server) handleSignals() {
 
 	signal.Notify(
 		srv.sigChan,
-		syscall.SIGHUP,
+		hookableSignals...,
-		syscall.SIGINT,
-		syscall.SIGTERM,
 	)
 
 	pid := syscall.Getpid()
@@ -290,3 +288,19 @@ func (srv *Server) fork() (err error) {
 
 	return
 }
+
+// RegisterSignalHook registers a function to be run PreSignal or PostSignal for a given signal.
+func (srv *Server) RegisterSignalHook(ppFlag int, sig os.Signal, f func()) (err error) {
+	if ppFlag != PreSignal && ppFlag != PostSignal {
+		err = fmt.Errorf("Invalid ppFlag argument. Must be either grace.PreSignal or grace.PostSignal.")
+		return
+	}
+	for _, s := range hookableSignals {
+		if s == sig {
+			srv.SignalHooks[ppFlag][sig] = append(srv.SignalHooks[ppFlag][sig], f)
+			return
+		}
+	}
+	err = fmt.Errorf("Signal '%v' is not supported.", sig)
+	return
+}

hooks.go

@@ -6,6 +6,8 @@ import (
 	"net/http"
 	"path/filepath"
 
+	"github.com/astaxie/beego/context"
+	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/session"
 )
 
@@ -43,23 +45,25 @@ func registerSession() error {
 	if BConfig.WebConfig.Session.SessionOn {
 		var err error
 		sessionConfig := AppConfig.String("sessionConfig")
+		conf := new(session.ManagerConfig)
 		if sessionConfig == "" {
-			conf := map[string]interface{}{
+			conf.CookieName = BConfig.WebConfig.Session.SessionName
-				"cookieName":      BConfig.WebConfig.Session.SessionName,
+			conf.EnableSetCookie = BConfig.WebConfig.Session.SessionAutoSetCookie
-				"gclifetime":      BConfig.WebConfig.Session.SessionGCMaxLifetime,
+			conf.Gclifetime = BConfig.WebConfig.Session.SessionGCMaxLifetime
-				"providerConfig":  filepath.ToSlash(BConfig.WebConfig.Session.SessionProviderConfig),
+			conf.Secure = BConfig.Listen.EnableHTTPS
-				"secure":          BConfig.Listen.EnableHTTPS,
+			conf.CookieLifeTime = BConfig.WebConfig.Session.SessionCookieLifeTime
-				"enableSetCookie": BConfig.WebConfig.Session.SessionAutoSetCookie,
+			conf.ProviderConfig = filepath.ToSlash(BConfig.WebConfig.Session.SessionProviderConfig)
-				"domain":          BConfig.WebConfig.Session.SessionDomain,
+			conf.DisableHTTPOnly = BConfig.WebConfig.Session.SessionDisableHTTPOnly
-				"cookieLifeTime":  BConfig.WebConfig.Session.SessionCookieLifeTime,
+			conf.Domain = BConfig.WebConfig.Session.SessionDomain
-			}
+			conf.EnableSidInHttpHeader = BConfig.WebConfig.Session.SessionEnableSidInHTTPHeader
-			confBytes, err := json.Marshal(conf)
+			conf.SessionNameInHttpHeader = BConfig.WebConfig.Session.SessionNameInHTTPHeader
-			if err != nil {
+			conf.EnableSidInUrlQuery = BConfig.WebConfig.Session.SessionEnableSidInURLQuery
+		} else {
+			if err = json.Unmarshal([]byte(sessionConfig), conf); err != nil {
 				return err
 			}
-			sessionConfig = string(confBytes)
 		}
-		if GlobalSessions, err = session.NewManager(BConfig.WebConfig.Session.SessionProvider, sessionConfig); err != nil {
+		if GlobalSessions, err = session.NewManager(BConfig.WebConfig.Session.SessionProvider, conf); err != nil {
 			return err
 		}
 		go GlobalSessions.GC()
@@ -68,26 +72,30 @@ func registerSession() error {
 }
 
 func registerTemplate() error {
-	if err := BuildTemplate(BConfig.WebConfig.ViewsPath); err != nil {
+	defer lockViewPaths()
+	if err := AddViewPath(BConfig.WebConfig.ViewsPath); err != nil {
 		if BConfig.RunMode == DEV {
-			Warn(err)
+			logs.Warn(err)
 		}
 		return err
 	}
 	return nil
 }
 
-func registerDocs() error {
-	if BConfig.WebConfig.EnableDocs {
-		Get("/docs", serverDocs)
-		Get("/docs/*", serverDocs)
-	}
-	return nil
-}
-
 func registerAdmin() error {
 	if BConfig.Listen.EnableAdmin {
 		go beeAdminApp.Run()
 	}
 	return nil
 }
+
+func registerGzip() error {
+	if BConfig.EnableGzip {
+		context.InitGzip(
+			AppConfig.DefaultInt("gzipMinLength", -1),
+			AppConfig.DefaultInt("gzipCompressLevel", -1),
+			AppConfig.DefaultStrings("includedMethods", []string{"GET"}),
+		)
+	}
+	return nil
+}

httplib/httplib.go

@@ -136,9 +136,11 @@ type BeegoHTTPSettings struct {
 	TLSClientConfig  *tls.Config
 	Proxy            func(*http.Request) (*url.URL, error)
 	Transport        http.RoundTripper
+	CheckRedirect    func(req *http.Request, via []*http.Request) error
 	EnableCookie     bool
 	Gzip             bool
 	DumpBody         bool
+	Retries          int // if set to -1 means will retry forever
 }
 
 // BeegoHTTPRequest provides more useful methods for requesting one url than http.Request.
@@ -188,6 +190,15 @@ func (b *BeegoHTTPRequest) Debug(isdebug bool) *BeegoHTTPRequest {
 	return b
 }
 
+// Retries sets Retries times.
+// default is 0 means no retried.
+// -1 means retried forever.
+// others means retried times.
+func (b *BeegoHTTPRequest) Retries(times int) *BeegoHTTPRequest {
+	b.setting.Retries = times
+	return b
+}
+
 // DumpBody setting whether need to Dump the Body.
 func (b *BeegoHTTPRequest) DumpBody(isdump bool) *BeegoHTTPRequest {
 	b.setting.DumpBody = isdump
@@ -265,6 +276,15 @@ func (b *BeegoHTTPRequest) SetProxy(proxy func(*http.Request) (*url.URL, error))
 	return b
 }
 
+// SetCheckRedirect specifies the policy for handling redirects.
+//
+// If CheckRedirect is nil, the Client uses its default policy,
+// which is to stop after 10 consecutive requests.
+func (b *BeegoHTTPRequest) SetCheckRedirect(redirect func(req *http.Request, via []*http.Request) error) *BeegoHTTPRequest {
+	b.setting.CheckRedirect = redirect
+	return b
+}
+
 // Param adds query param in to request.
 // params build query string as ?key1=value1&key2=value2...
 func (b *BeegoHTTPRequest) Param(key, value string) *BeegoHTTPRequest {
@@ -380,7 +400,7 @@ func (b *BeegoHTTPRequest) getResponse() (*http.Response, error) {
 }
 
 // DoRequest will do the client.Do
-func (b *BeegoHTTPRequest) DoRequest() (*http.Response, error) {
+func (b *BeegoHTTPRequest) DoRequest() (resp *http.Response, err error) {
 	var paramBody string
 	if len(b.params) > 0 {
 		var buf bytes.Buffer
@@ -412,6 +432,7 @@ func (b *BeegoHTTPRequest) DoRequest() (*http.Response, error) {
 			TLSClientConfig:     b.setting.TLSClientConfig,
 			Proxy:               b.setting.Proxy,
 			Dial:                TimeoutDialer(b.setting.ConnectTimeout, b.setting.ReadWriteTimeout),
+			MaxIdleConnsPerHost: -1,
 		}
 	} else {
 		// if b.transport is *http.Transport then set the settings.
@@ -445,6 +466,10 @@ func (b *BeegoHTTPRequest) DoRequest() (*http.Response, error) {
 		b.req.Header.Set("User-Agent", b.setting.UserAgent)
 	}
 
+	if b.setting.CheckRedirect != nil {
+		client.CheckRedirect = b.setting.CheckRedirect
+	}
+
 	if b.setting.ShowDebug {
 		dump, err := httputil.DumpRequest(b.req, b.setting.DumpBody)
 		if err != nil {
@@ -452,7 +477,16 @@ func (b *BeegoHTTPRequest) DoRequest() (*http.Response, error) {
 		}
 		b.dump = dump
 	}
-	return client.Do(b.req)
+	// retries default value is 0, it will run once.
+	// retries equal to -1, it will run forever until success
+	// retries is setted, it will retries fixed times.
+	for i := 0; b.setting.Retries == -1 || i <= b.setting.Retries; i++ {
+		resp, err = client.Do(b.req)
+		if err == nil {
+			break
+		}
+	}
+	return resp, err
 }
 
 // String returns the body string in response.

log.go

@@ -33,82 +33,77 @@ const (
 )
 
 // BeeLogger references the used application logger.
-var BeeLogger = logs.NewLogger(100)
+var BeeLogger = logs.GetBeeLogger()
 
 // SetLevel sets the global log level used by the simple logger.
 func SetLevel(l int) {
-	BeeLogger.SetLevel(l)
+	logs.SetLevel(l)
 }
 
 // SetLogFuncCall set the CallDepth, default is 3
 func SetLogFuncCall(b bool) {
-	BeeLogger.EnableFuncCallDepth(b)
+	logs.SetLogFuncCall(b)
-	BeeLogger.SetLogFuncCallDepth(3)
 }
 
 // SetLogger sets a new logger.
 func SetLogger(adaptername string, config string) error {
-	err := BeeLogger.SetLogger(adaptername, config)
+	return logs.SetLogger(adaptername, config)
-	if err != nil {
-		return err
-	}
-	return nil
 }
 
 // Emergency logs a message at emergency level.
 func Emergency(v ...interface{}) {
-	BeeLogger.Emergency(generateFmtStr(len(v)), v...)
+	logs.Emergency(generateFmtStr(len(v)), v...)
 }
 
 // Alert logs a message at alert level.
 func Alert(v ...interface{}) {
-	BeeLogger.Alert(generateFmtStr(len(v)), v...)
+	logs.Alert(generateFmtStr(len(v)), v...)
 }
 
 // Critical logs a message at critical level.
 func Critical(v ...interface{}) {
-	BeeLogger.Critical(generateFmtStr(len(v)), v...)
+	logs.Critical(generateFmtStr(len(v)), v...)
 }
 
 // Error logs a message at error level.
 func Error(v ...interface{}) {
-	BeeLogger.Error(generateFmtStr(len(v)), v...)
+	logs.Error(generateFmtStr(len(v)), v...)
 }
 
 // Warning logs a message at warning level.
 func Warning(v ...interface{}) {
-	BeeLogger.Warning(generateFmtStr(len(v)), v...)
+	logs.Warning(generateFmtStr(len(v)), v...)
 }
 
 // Warn compatibility alias for Warning()
 func Warn(v ...interface{}) {
-	BeeLogger.Warn(generateFmtStr(len(v)), v...)
+	logs.Warn(generateFmtStr(len(v)), v...)
 }
 
 // Notice logs a message at notice level.
 func Notice(v ...interface{}) {
-	BeeLogger.Notice(generateFmtStr(len(v)), v...)
+	logs.Notice(generateFmtStr(len(v)), v...)
 }
 
 // Informational logs a message at info level.
 func Informational(v ...interface{}) {
-	BeeLogger.Informational(generateFmtStr(len(v)), v...)
+	logs.Informational(generateFmtStr(len(v)), v...)
 }
 
 // Info compatibility alias for Warning()
 func Info(v ...interface{}) {
-	BeeLogger.Info(generateFmtStr(len(v)), v...)
+	logs.Info(generateFmtStr(len(v)), v...)
 }
 
 // Debug logs a message at debug level.
 func Debug(v ...interface{}) {
-	BeeLogger.Debug(generateFmtStr(len(v)), v...)
+	logs.Debug(generateFmtStr(len(v)), v...)
 }
 
 // Trace logs a message at trace level.
 // compatibility alias for Warning()
 func Trace(v ...interface{}) {
-	BeeLogger.Trace(generateFmtStr(len(v)), v...)
+	logs.Trace(generateFmtStr(len(v)), v...)
 }
 
 func generateFmtStr(n int) string {

logs/alils/alils.go

@@ -0,0 +1,192 @@
+package alils
+
+import (
+	"encoding/json"
+	"github.com/astaxie/beego/logs"
+	"github.com/gogo/protobuf/proto"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	CacheSize int    = 64
+	Delimiter string = "##"
+)
+
+type AliLSConfig struct {
+	Project   string   `json:"project"`
+	Endpoint  string   `json:"endpoint"`
+	KeyID     string   `json:"key_id"`
+	KeySecret string   `json:"key_secret"`
+	LogStore  string   `json:"log_store"`
+	Topics    []string `json:"topics"`
+	Source    string   `json:"source"`
+	Level     int      `json:"level"`
+	FlushWhen int      `json:"flush_when"`
+}
+
+// aliLSWriter implements LoggerInterface.
+// it writes messages in keep-live tcp connection.
+type aliLSWriter struct {
+	store    *LogStore
+	group    []*LogGroup
+	withMap  bool
+	groupMap map[string]*LogGroup
+	lock     *sync.Mutex
+	AliLSConfig
+}
+
+// 创建提供Logger接口的日志服务
+func NewAliLS() logs.Logger {
+	alils := new(aliLSWriter)
+	alils.Level = logs.LevelTrace
+	return alils
+}
+
+// 读取配置
+// 初始化必要的数据结构
+func (c *aliLSWriter) Init(jsonConfig string) (err error) {
+
+	json.Unmarshal([]byte(jsonConfig), c)
+
+	if c.FlushWhen > CacheSize {
+		c.FlushWhen = CacheSize
+	}
+
+	// 初始化Project
+	prj := &LogProject{
+		Name:            c.Project,
+		Endpoint:        c.Endpoint,
+		AccessKeyId:     c.KeyID,
+		AccessKeySecret: c.KeySecret,
+	}
+
+	// 获取logstore
+	c.store, err = prj.GetLogStore(c.LogStore)
+	if err != nil {
+		return err
+	}
+
+	// 创建默认Log Group
+	c.group = append(c.group, &LogGroup{
+		Topic:  proto.String(""),
+		Source: proto.String(c.Source),
+		Logs:   make([]*Log, 0, c.FlushWhen),
+	})
+
+	// 创建其它Log Group
+	c.groupMap = make(map[string]*LogGroup)
+	for _, topic := range c.Topics {
+
+		lg := &LogGroup{
+			Topic:  proto.String(topic),
+			Source: proto.String(c.Source),
+			Logs:   make([]*Log, 0, c.FlushWhen),
+		}
+
+		c.group = append(c.group, lg)
+		c.groupMap[topic] = lg
+	}
+
+	if len(c.group) == 1 {
+		c.withMap = false
+	} else {
+		c.withMap = true
+	}
+
+	c.lock = &sync.Mutex{}
+
+	return nil
+}
+
+// WriteMsg write message in connection.
+// if connection is down, try to re-connect.
+func (c *aliLSWriter) WriteMsg(when time.Time, msg string, level int) (err error) {
+
+	if level > c.Level {
+		return nil
+	}
+
+	var topic string
+	var content string
+	var lg *LogGroup
+	if c.withMap {
+
+		// 解析出Topic，并匹配LogGroup
+		strs := strings.SplitN(msg, Delimiter, 2)
+		if len(strs) == 2 {
+			pos := strings.LastIndex(strs[0], " ")
+			topic = strs[0][pos+1 : len(strs[0])]
+			content = strs[0][0:pos] + strs[1]
+			lg = c.groupMap[topic]
+		}
+
+		// 默认发到空Topic
+		if lg == nil {
+			topic = ""
+			content = msg
+			lg = c.group[0]
+		}
+	} else {
+		topic = ""
+		content = msg
+		lg = c.group[0]
+	}
+
+	// 生成日志
+	c1 := &Log_Content{
+		Key:   proto.String("msg"),
+		Value: proto.String(content),
+	}
+
+	l := &Log{
+		Time: proto.Uint32(uint32(when.Unix())), // 填写日志时间
+		Contents: []*Log_Content{
+			c1,
+		},
+	}
+
+	c.lock.Lock()
+	lg.Logs = append(lg.Logs, l)
+	c.lock.Unlock()
+
+	// 满足条件则Flush
+	if len(lg.Logs) >= c.FlushWhen {
+		c.flush(lg)
+	}
+
+	return nil
+}
+
+// Flush implementing method. empty.
+func (c *aliLSWriter) Flush() {
+
+	// flush所有group
+	for _, lg := range c.group {
+		c.flush(lg)
+	}
+}
+
+// Destroy destroy connection writer and close tcp listener.
+func (c *aliLSWriter) Destroy() {
+}
+
+func (c *aliLSWriter) flush(lg *LogGroup) {
+
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	// 把以上的LogGroup推送到SLS服务器，
+	// SLS服务器会根据该logstore的shard个数自动进行负载均衡。
+	err := c.store.PutLogs(lg)
+	if err != nil {
+		return
+	}
+
+	lg.Logs = make([]*Log, 0, c.FlushWhen)
+}
+
+func init() {
+	logs.Register(logs.AdapterAliLS, NewAliLS)
+}

logs/alils/config.go

@@ -0,0 +1,13 @@
+package alils
+
+const (
+	version         = "0.5.0"     // SDK version
+	signatureMethod = "hmac-sha1" // Signature method
+
+	// OffsetNewest stands for the log head offset, i.e. the offset that will be
+	// assigned to the next message that will be produced to the shard.
+	OffsetNewest = "end"
+	// OffsetOldest stands for the oldest offset available on the logstore for a
+	// shard.
+	OffsetOldest = "begin"
+)

logs/alils/log.pb.go

@@ -0,0 +1,984 @@
+package alils
+
+import "github.com/gogo/protobuf/proto"
+import "fmt"
+import "math"
+
+// discarding unused import gogoproto "."
+
+import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
+
+import "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type Log struct {
+	Time             *uint32        `protobuf:"varint,1,req,name=Time" json:"Time,omitempty"`
+	Contents         []*Log_Content `protobuf:"bytes,2,rep,name=Contents" json:"Contents,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
+}
+
+func (m *Log) Reset()         { *m = Log{} }
+func (m *Log) String() string { return proto.CompactTextString(m) }
+func (*Log) ProtoMessage()    {}
+
+func (m *Log) GetTime() uint32 {
+	if m != nil && m.Time != nil {
+		return *m.Time
+	}
+	return 0
+}
+
+func (m *Log) GetContents() []*Log_Content {
+	if m != nil {
+		return m.Contents
+	}
+	return nil
+}
+
+type Log_Content struct {
+	Key              *string `protobuf:"bytes,1,req,name=Key" json:"Key,omitempty"`
+	Value            *string `protobuf:"bytes,2,req,name=Value" json:"Value,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Log_Content) Reset()         { *m = Log_Content{} }
+func (m *Log_Content) String() string { return proto.CompactTextString(m) }
+func (*Log_Content) ProtoMessage()    {}
+
+func (m *Log_Content) GetKey() string {
+	if m != nil && m.Key != nil {
+		return *m.Key
+	}
+	return ""
+}
+
+func (m *Log_Content) GetValue() string {
+	if m != nil && m.Value != nil {
+		return *m.Value
+	}
+	return ""
+}
+
+type LogGroup struct {
+	Logs             []*Log  `protobuf:"bytes,1,rep,name=Logs" json:"Logs,omitempty"`
+	Reserved         *string `protobuf:"bytes,2,opt,name=Reserved" json:"Reserved,omitempty"`
+	Topic            *string `protobuf:"bytes,3,opt,name=Topic" json:"Topic,omitempty"`
+	Source           *string `protobuf:"bytes,4,opt,name=Source" json:"Source,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *LogGroup) Reset()         { *m = LogGroup{} }
+func (m *LogGroup) String() string { return proto.CompactTextString(m) }
+func (*LogGroup) ProtoMessage()    {}
+
+func (m *LogGroup) GetLogs() []*Log {
+	if m != nil {
+		return m.Logs
+	}
+	return nil
+}
+
+func (m *LogGroup) GetReserved() string {
+	if m != nil && m.Reserved != nil {
+		return *m.Reserved
+	}
+	return ""
+}
+
+func (m *LogGroup) GetTopic() string {
+	if m != nil && m.Topic != nil {
+		return *m.Topic
+	}
+	return ""
+}
+
+func (m *LogGroup) GetSource() string {
+	if m != nil && m.Source != nil {
+		return *m.Source
+	}
+	return ""
+}
+
+type LogGroupList struct {
+	LogGroups        []*LogGroup `protobuf:"bytes,1,rep,name=logGroups" json:"logGroups,omitempty"`
+	XXX_unrecognized []byte      `json:"-"`
+}
+
+func (m *LogGroupList) Reset()         { *m = LogGroupList{} }
+func (m *LogGroupList) String() string { return proto.CompactTextString(m) }
+func (*LogGroupList) ProtoMessage()    {}
+
+func (m *LogGroupList) GetLogGroups() []*LogGroup {
+	if m != nil {
+		return m.LogGroups
+	}
+	return nil
+}
+
+func (m *Log) Marshal() (data []byte, err error) {
+	size := m.Size()
+	data = make([]byte, size)
+	n, err := m.MarshalTo(data)
+	if err != nil {
+		return nil, err
+	}
+	return data[:n], nil
+}
+
+func (m *Log) MarshalTo(data []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Time == nil {
+		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Time")
+	} else {
+		data[i] = 0x8
+		i++
+		i = encodeVarintLog(data, i, uint64(*m.Time))
+	}
+	if len(m.Contents) > 0 {
+		for _, msg := range m.Contents {
+			data[i] = 0x12
+			i++
+			i = encodeVarintLog(data, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(data[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(data[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *Log_Content) Marshal() (data []byte, err error) {
+	size := m.Size()
+	data = make([]byte, size)
+	n, err := m.MarshalTo(data)
+	if err != nil {
+		return nil, err
+	}
+	return data[:n], nil
+}
+
+func (m *Log_Content) MarshalTo(data []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Key == nil {
+		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Key")
+	} else {
+		data[i] = 0xa
+		i++
+		i = encodeVarintLog(data, i, uint64(len(*m.Key)))
+		i += copy(data[i:], *m.Key)
+	}
+	if m.Value == nil {
+		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Value")
+	} else {
+		data[i] = 0x12
+		i++
+		i = encodeVarintLog(data, i, uint64(len(*m.Value)))
+		i += copy(data[i:], *m.Value)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(data[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *LogGroup) Marshal() (data []byte, err error) {
+	size := m.Size()
+	data = make([]byte, size)
+	n, err := m.MarshalTo(data)
+	if err != nil {
+		return nil, err
+	}
+	return data[:n], nil
+}
+
+func (m *LogGroup) MarshalTo(data []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Logs) > 0 {
+		for _, msg := range m.Logs {
+			data[i] = 0xa
+			i++
+			i = encodeVarintLog(data, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(data[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if m.Reserved != nil {
+		data[i] = 0x12
+		i++
+		i = encodeVarintLog(data, i, uint64(len(*m.Reserved)))
+		i += copy(data[i:], *m.Reserved)
+	}
+	if m.Topic != nil {
+		data[i] = 0x1a
+		i++
+		i = encodeVarintLog(data, i, uint64(len(*m.Topic)))
+		i += copy(data[i:], *m.Topic)
+	}
+	if m.Source != nil {
+		data[i] = 0x22
+		i++
+		i = encodeVarintLog(data, i, uint64(len(*m.Source)))
+		i += copy(data[i:], *m.Source)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(data[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *LogGroupList) Marshal() (data []byte, err error) {
+	size := m.Size()
+	data = make([]byte, size)
+	n, err := m.MarshalTo(data)
+	if err != nil {
+		return nil, err
+	}
+	return data[:n], nil
+}
+
+func (m *LogGroupList) MarshalTo(data []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.LogGroups) > 0 {
+		for _, msg := range m.LogGroups {
+			data[i] = 0xa
+			i++
+			i = encodeVarintLog(data, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(data[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(data[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func encodeFixed64Log(data []byte, offset int, v uint64) int {
+	data[offset] = uint8(v)
+	data[offset+1] = uint8(v >> 8)
+	data[offset+2] = uint8(v >> 16)
+	data[offset+3] = uint8(v >> 24)
+	data[offset+4] = uint8(v >> 32)
+	data[offset+5] = uint8(v >> 40)
+	data[offset+6] = uint8(v >> 48)
+	data[offset+7] = uint8(v >> 56)
+	return offset + 8
+}
+func encodeFixed32Log(data []byte, offset int, v uint32) int {
+	data[offset] = uint8(v)
+	data[offset+1] = uint8(v >> 8)
+	data[offset+2] = uint8(v >> 16)
+	data[offset+3] = uint8(v >> 24)
+	return offset + 4
+}
+func encodeVarintLog(data []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		data[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	data[offset] = uint8(v)
+	return offset + 1
+}
+func (m *Log) Size() (n int) {
+	var l int
+	_ = l
+	if m.Time != nil {
+		n += 1 + sovLog(uint64(*m.Time))
+	}
+	if len(m.Contents) > 0 {
+		for _, e := range m.Contents {
+			l = e.Size()
+			n += 1 + l + sovLog(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Log_Content) Size() (n int) {
+	var l int
+	_ = l
+	if m.Key != nil {
+		l = len(*m.Key)
+		n += 1 + l + sovLog(uint64(l))
+	}
+	if m.Value != nil {
+		l = len(*m.Value)
+		n += 1 + l + sovLog(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *LogGroup) Size() (n int) {
+	var l int
+	_ = l
+	if len(m.Logs) > 0 {
+		for _, e := range m.Logs {
+			l = e.Size()
+			n += 1 + l + sovLog(uint64(l))
+		}
+	}
+	if m.Reserved != nil {
+		l = len(*m.Reserved)
+		n += 1 + l + sovLog(uint64(l))
+	}
+	if m.Topic != nil {
+		l = len(*m.Topic)
+		n += 1 + l + sovLog(uint64(l))
+	}
+	if m.Source != nil {
+		l = len(*m.Source)
+		n += 1 + l + sovLog(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *LogGroupList) Size() (n int) {
+	var l int
+	_ = l
+	if len(m.LogGroups) > 0 {
+		for _, e := range m.LogGroups {
+			l = e.Size()
+			n += 1 + l + sovLog(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func sovLog(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozLog(x uint64) (n int) {
+	return sovLog(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Log) Unmarshal(data []byte) error {
+	var hasFields [1]uint64
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowLog
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Log: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Log: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
+			}
+			var v uint32
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				v |= (uint32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Time = &v
+			hasFields[0] |= uint64(0x00000001)
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Contents", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthLog
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Contents = append(m.Contents, &Log_Content{})
+			if err := m.Contents[len(m.Contents)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipLog(data[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthLog
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+	if hasFields[0]&uint64(0x00000001) == 0 {
+		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Time")
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Log_Content) Unmarshal(data []byte) error {
+	var hasFields [1]uint64
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowLog
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Content: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Content: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthLog
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			s := string(data[iNdEx:postIndex])
+			m.Key = &s
+			iNdEx = postIndex
+			hasFields[0] |= uint64(0x00000001)
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthLog
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			s := string(data[iNdEx:postIndex])
+			m.Value = &s
+			iNdEx = postIndex
+			hasFields[0] |= uint64(0x00000002)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipLog(data[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthLog
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+	if hasFields[0]&uint64(0x00000001) == 0 {
+		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Key")
+	}
+	if hasFields[0]&uint64(0x00000002) == 0 {
+		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Value")
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LogGroup) Unmarshal(data []byte) error {
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowLog
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LogGroup: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LogGroup: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthLog
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Logs = append(m.Logs, &Log{})
+			if err := m.Logs[len(m.Logs)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Reserved", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthLog
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			s := string(data[iNdEx:postIndex])
+			m.Reserved = &s
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthLog
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			s := string(data[iNdEx:postIndex])
+			m.Topic = &s
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthLog
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			s := string(data[iNdEx:postIndex])
+			m.Source = &s
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipLog(data[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthLog
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LogGroupList) Unmarshal(data []byte) error {
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowLog
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LogGroupList: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LogGroupList: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LogGroups", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthLog
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.LogGroups = append(m.LogGroups, &LogGroup{})
+			if err := m.LogGroups[len(m.LogGroups)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipLog(data[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthLog
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipLog(data []byte) (n int, err error) {
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowLog
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if data[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowLog
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthLog
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowLog
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := data[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipLog(data[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthLog = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowLog   = fmt.Errorf("proto: integer overflow")
+)

logs/alils/log_config.go

@@ -0,0 +1,39 @@
+package alils
+
+type InputDetail struct {
+	LogType       string   `json:"logType"`
+	LogPath       string   `json:"logPath"`
+	FilePattern   string   `json:"filePattern"`
+	LocalStorage  bool     `json:"localStorage"`
+	TimeFormat    string   `json:"timeFormat"`
+	LogBeginRegex string   `json:"logBeginRegex"`
+	Regex         string   `json:"regex"`
+	Keys          []string `json:"key"`
+	FilterKeys    []string `json:"filterKey"`
+	FilterRegex   []string `json:"filterRegex"`
+	TopicFormat   string   `json:"topicFormat"`
+}
+
+type OutputDetail struct {
+	Endpoint     string `json:"endpoint"`
+	LogStoreName string `json:"logstoreName"`
+}
+
+type LogConfig struct {
+	Name         string       `json:"configName"`
+	InputType    string       `json:"inputType"`
+	InputDetail  InputDetail  `json:"inputDetail"`
+	OutputType   string       `json:"outputType"`
+	OutputDetail OutputDetail `json:"outputDetail"`
+
+	CreateTime     uint32
+	LastModifyTime uint32
+
+	project *LogProject
+}
+
+// GetAppliedMachineGroup returns applied machine group of this config.
+func (c *LogConfig) GetAppliedMachineGroup(confName string) (groupNames []string, err error) {
+	groupNames, err = c.project.GetAppliedMachineGroups(c.Name)
+	return
+}

logs/alils/log_project.go

@@ -0,0 +1,818 @@
+/*
+Package sls implements the SDK(v0.5.0) of Simple Log Service(abbr. SLS).
+
+For more description about SLS, please read this article:
+http://gitlab.alibaba-inc.com/sls/doc.
+*/
+package alils
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httputil"
+)
+
+// Error message in SLS HTTP response.
+type errorMessage struct {
+	Code    string `json:"errorCode"`
+	Message string `json:"errorMessage"`
+}
+
+type LogProject struct {
+	Name            string // Project name
+	Endpoint        string // IP or hostname of SLS endpoint
+	AccessKeyId     string
+	AccessKeySecret string
+}
+
+// NewLogProject creates a new SLS project.
+func NewLogProject(name, endpoint, accessKeyId, accessKeySecret string) (p *LogProject, err error) {
+	p = &LogProject{
+		Name:            name,
+		Endpoint:        endpoint,
+		AccessKeyId:     accessKeyId,
+		AccessKeySecret: accessKeySecret,
+	}
+	return p, nil
+}
+
+// ListLogStore returns all logstore names of project p.
+func (p *LogProject) ListLogStore() (storeNames []string, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	uri := fmt.Sprintf("/logstores")
+	r, err := request(p, "GET", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to list logstore")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	type Body struct {
+		Count     int
+		LogStores []string
+	}
+	body := &Body{}
+
+	err = json.Unmarshal(buf, body)
+	if err != nil {
+		return
+	}
+
+	storeNames = body.LogStores
+
+	return
+}
+
+// GetLogStore returns logstore according by logstore name.
+func (p *LogProject) GetLogStore(name string) (s *LogStore, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	r, err := request(p, "GET", "/logstores/"+name, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to get logstore")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	s = &LogStore{}
+	err = json.Unmarshal(buf, s)
+	if err != nil {
+		return
+	}
+	s.project = p
+	return
+}
+
+// CreateLogStore creates a new logstore in SLS,
+// where name is logstore name,
+// and ttl is time-to-live(in day) of logs,
+// and shardCnt is the number of shards.
+func (p *LogProject) CreateLogStore(name string, ttl, shardCnt int) (err error) {
+
+	type Body struct {
+		Name       string `json:"logstoreName"`
+		TTL        int    `json:"ttl"`
+		ShardCount int    `json:"shardCount"`
+	}
+
+	store := &Body{
+		Name:       name,
+		TTL:        ttl,
+		ShardCount: shardCnt,
+	}
+
+	body, err := json.Marshal(store)
+	if err != nil {
+		return
+	}
+
+	h := map[string]string{
+		"x-sls-bodyrawsize": fmt.Sprintf("%v", len(body)),
+		"Content-Type":      "application/json",
+		"Accept-Encoding":   "deflate", // TODO: support lz4
+	}
+
+	r, err := request(p, "POST", "/logstores", h, body)
+	if err != nil {
+		return
+	}
+
+	body, err = ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(body, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to create logstore")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	return
+}
+
+// DeleteLogStore deletes a logstore according by logstore name.
+func (p *LogProject) DeleteLogStore(name string) (err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	r, err := request(p, "DELETE", "/logstores/"+name, h, nil)
+	if err != nil {
+		return
+	}
+
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(body, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to delete logstore")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+	return
+}
+
+// UpdateLogStore updates a logstore according by logstore name,
+// obviously we can't modify the logstore name itself.
+func (p *LogProject) UpdateLogStore(name string, ttl, shardCnt int) (err error) {
+
+	type Body struct {
+		Name       string `json:"logstoreName"`
+		TTL        int    `json:"ttl"`
+		ShardCount int    `json:"shardCount"`
+	}
+
+	store := &Body{
+		Name:       name,
+		TTL:        ttl,
+		ShardCount: shardCnt,
+	}
+
+	body, err := json.Marshal(store)
+	if err != nil {
+		return
+	}
+
+	h := map[string]string{
+		"x-sls-bodyrawsize": fmt.Sprintf("%v", len(body)),
+		"Content-Type":      "application/json",
+		"Accept-Encoding":   "deflate", // TODO: support lz4
+	}
+
+	r, err := request(p, "PUT", "/logstores", h, body)
+	if err != nil {
+		return
+	}
+
+	body, err = ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(body, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to update logstore")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	return
+}
+
+// ListMachineGroup returns machine group name list and the total number of machine groups.
+// The offset starts from 0 and the size is the max number of machine groups could be returned.
+func (p *LogProject) ListMachineGroup(offset, size int) (m []string, total int, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	if size <= 0 {
+		size = 500
+	}
+
+	uri := fmt.Sprintf("/machinegroups?offset=%v&size=%v", offset, size)
+	r, err := request(p, "GET", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to list machine group")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	type Body struct {
+		MachineGroups []string
+		Count         int
+		Total         int
+	}
+	body := &Body{}
+
+	err = json.Unmarshal(buf, body)
+	if err != nil {
+		return
+	}
+
+	m = body.MachineGroups
+	total = body.Total
+
+	return
+}
+
+// GetMachineGroup retruns machine group according by machine group name.
+func (p *LogProject) GetMachineGroup(name string) (m *MachineGroup, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	r, err := request(p, "GET", "/machinegroups/"+name, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to get machine group:%v", name)
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	m = &MachineGroup{}
+	err = json.Unmarshal(buf, m)
+	if err != nil {
+		return
+	}
+	m.project = p
+	return
+}
+
+// CreateMachineGroup creates a new machine group in SLS.
+func (p *LogProject) CreateMachineGroup(m *MachineGroup) (err error) {
+
+	body, err := json.Marshal(m)
+	if err != nil {
+		return
+	}
+
+	h := map[string]string{
+		"x-sls-bodyrawsize": fmt.Sprintf("%v", len(body)),
+		"Content-Type":      "application/json",
+		"Accept-Encoding":   "deflate", // TODO: support lz4
+	}
+
+	r, err := request(p, "POST", "/machinegroups", h, body)
+	if err != nil {
+		return
+	}
+
+	body, err = ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(body, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to create machine group")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	return
+}
+
+// UpdateMachineGroup updates a machine group.
+func (p *LogProject) UpdateMachineGroup(m *MachineGroup) (err error) {
+
+	body, err := json.Marshal(m)
+	if err != nil {
+		return
+	}
+
+	h := map[string]string{
+		"x-sls-bodyrawsize": fmt.Sprintf("%v", len(body)),
+		"Content-Type":      "application/json",
+		"Accept-Encoding":   "deflate", // TODO: support lz4
+	}
+
+	r, err := request(p, "PUT", "/machinegroups/"+m.Name, h, body)
+	if err != nil {
+		return
+	}
+
+	body, err = ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(body, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to update machine group")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	return
+}
+
+// DeleteMachineGroup deletes machine group according machine group name.
+func (p *LogProject) DeleteMachineGroup(name string) (err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	r, err := request(p, "DELETE", "/machinegroups/"+name, h, nil)
+	if err != nil {
+		return
+	}
+
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(body, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to delete machine group")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+	return
+}
+
+// ListConfig returns config names list and the total number of configs.
+// The offset starts from 0 and the size is the max number of configs could be returned.
+func (p *LogProject) ListConfig(offset, size int) (cfgNames []string, total int, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	if size <= 0 {
+		size = 100
+	}
+
+	uri := fmt.Sprintf("/configs?offset=%v&size=%v", offset, size)
+	r, err := request(p, "GET", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to delete machine group")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	type Body struct {
+		Total   int
+		Configs []string
+	}
+	body := &Body{}
+
+	err = json.Unmarshal(buf, body)
+	if err != nil {
+		return
+	}
+
+	cfgNames = body.Configs
+	total = body.Total
+	return
+}
+
+// GetConfig returns config according by config name.
+func (p *LogProject) GetConfig(name string) (c *LogConfig, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	r, err := request(p, "GET", "/configs/"+name, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to delete config")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	c = &LogConfig{}
+	err = json.Unmarshal(buf, c)
+	if err != nil {
+		return
+	}
+	c.project = p
+	return
+}
+
+// UpdateConfig updates a config.
+func (p *LogProject) UpdateConfig(c *LogConfig) (err error) {
+
+	body, err := json.Marshal(c)
+	if err != nil {
+		return
+	}
+
+	h := map[string]string{
+		"x-sls-bodyrawsize": fmt.Sprintf("%v", len(body)),
+		"Content-Type":      "application/json",
+		"Accept-Encoding":   "deflate", // TODO: support lz4
+	}
+
+	r, err := request(p, "PUT", "/configs/"+c.Name, h, body)
+	if err != nil {
+		return
+	}
+
+	body, err = ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(body, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to update config")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	return
+}
+
+// CreateConfig creates a new config in SLS.
+func (p *LogProject) CreateConfig(c *LogConfig) (err error) {
+
+	body, err := json.Marshal(c)
+	if err != nil {
+		return
+	}
+
+	h := map[string]string{
+		"x-sls-bodyrawsize": fmt.Sprintf("%v", len(body)),
+		"Content-Type":      "application/json",
+		"Accept-Encoding":   "deflate", // TODO: support lz4
+	}
+
+	r, err := request(p, "POST", "/configs", h, body)
+	if err != nil {
+		return
+	}
+
+	body, err = ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(body, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to update config")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	return
+}
+
+// DeleteConfig deletes a config according by config name.
+func (p *LogProject) DeleteConfig(name string) (err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	r, err := request(p, "DELETE", "/configs/"+name, h, nil)
+	if err != nil {
+		return
+	}
+
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(body, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to delete config")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+	return
+}
+
+// GetAppliedMachineGroups returns applied machine group names list according config name.
+func (p *LogProject) GetAppliedMachineGroups(confName string) (groupNames []string, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	uri := fmt.Sprintf("/configs/%v/machinegroups", confName)
+	r, err := request(p, "GET", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to get applied machine groups")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	type Body struct {
+		Count         int
+		Machinegroups []string
+	}
+
+	body := &Body{}
+	err = json.Unmarshal(buf, body)
+	if err != nil {
+		return
+	}
+
+	groupNames = body.Machinegroups
+	return
+}
+
+// GetAppliedConfigs returns applied config names list according machine group name groupName.
+func (p *LogProject) GetAppliedConfigs(groupName string) (confNames []string, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	uri := fmt.Sprintf("/machinegroups/%v/configs", groupName)
+	r, err := request(p, "GET", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to applied configs")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	type Cfg struct {
+		Count   int      `json:"count"`
+		Configs []string `json:"configs"`
+	}
+
+	body := &Cfg{}
+	err = json.Unmarshal(buf, body)
+	if err != nil {
+		return
+	}
+
+	confNames = body.Configs
+	return
+}
+
+// ApplyConfigToMachineGroup applies config to machine group.
+func (p *LogProject) ApplyConfigToMachineGroup(confName, groupName string) (err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	uri := fmt.Sprintf("/machinegroups/%v/configs/%v", groupName, confName)
+	r, err := request(p, "PUT", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to apply config to machine group")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+	return
+}
+
+// RemoveConfigFromMachineGroup removes config from machine group.
+func (p *LogProject) RemoveConfigFromMachineGroup(confName, groupName string) (err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	uri := fmt.Sprintf("/machinegroups/%v/configs/%v", groupName, confName)
+	r, err := request(p, "DELETE", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to remove config from machine group")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Printf("%s\n", dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+	return
+}

logs/alils/log_store.go

@@ -0,0 +1,269 @@
+package alils
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httputil"
+	"strconv"
+
+	lz4 "github.com/cloudflare/golz4"
+	"github.com/gogo/protobuf/proto"
+)
+
+type LogStore struct {
+	Name       string `json:"logstoreName"`
+	TTL        int
+	ShardCount int
+
+	CreateTime     uint32
+	LastModifyTime uint32
+
+	project *LogProject
+}
+
+type Shard struct {
+	ShardID int `json:"shardID"`
+}
+
+// ListShards returns shard id list of this logstore.
+func (s *LogStore) ListShards() (shardIDs []int, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	uri := fmt.Sprintf("/logstores/%v/shards", s.Name)
+	r, err := request(s.project, "GET", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to list logstore")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Println(dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	var shards []*Shard
+	err = json.Unmarshal(buf, &shards)
+	if err != nil {
+		return
+	}
+
+	for _, v := range shards {
+		shardIDs = append(shardIDs, v.ShardID)
+	}
+	return
+}
+
+// PutLogs put logs into logstore.
+// The callers should transform user logs into LogGroup.
+func (s *LogStore) PutLogs(lg *LogGroup) (err error) {
+	body, err := proto.Marshal(lg)
+	if err != nil {
+		return
+	}
+
+	// Compresse body with lz4
+	out := make([]byte, lz4.CompressBound(body))
+	n, err := lz4.Compress(body, out)
+	if err != nil {
+		return
+	}
+
+	h := map[string]string{
+		"x-sls-compresstype": "lz4",
+		"x-sls-bodyrawsize":  fmt.Sprintf("%v", len(body)),
+		"Content-Type":       "application/x-protobuf",
+	}
+
+	uri := fmt.Sprintf("/logstores/%v", s.Name)
+	r, err := request(s.project, "POST", uri, h, out[:n])
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to put logs")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Println(dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+	return
+}
+
+// GetCursor gets log cursor of one shard specified by shardId.
+// The from can be in three form: a) unix timestamp in seccond, b) "begin", c) "end".
+// For more detail please read: http://gitlab.alibaba-inc.com/sls/doc/blob/master/api/shard.md#logstore
+func (s *LogStore) GetCursor(shardId int, from string) (cursor string, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	uri := fmt.Sprintf("/logstores/%v/shards/%v?type=cursor&from=%v",
+		s.Name, shardId, from)
+
+	r, err := request(s.project, "GET", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to get cursor")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Println(dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	type Body struct {
+		Cursor string
+	}
+	body := &Body{}
+
+	err = json.Unmarshal(buf, body)
+	if err != nil {
+		return
+	}
+	cursor = body.Cursor
+	return
+}
+
+// GetLogsBytes gets logs binary data from shard specified by shardId according cursor.
+// The logGroupMaxCount is the max number of logGroup could be returned.
+// The nextCursor is the next curosr can be used to read logs at next time.
+func (s *LogStore) GetLogsBytes(shardId int, cursor string,
+	logGroupMaxCount int) (out []byte, nextCursor string, err error) {
+
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+		"Accept":            "application/x-protobuf",
+		"Accept-Encoding":   "lz4",
+	}
+
+	uri := fmt.Sprintf("/logstores/%v/shards/%v?type=logs&cursor=%v&count=%v",
+		s.Name, shardId, cursor, logGroupMaxCount)
+
+	r, err := request(s.project, "GET", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to get cursor")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Println(dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	v, ok := r.Header["X-Sls-Compresstype"]
+	if !ok || len(v) == 0 {
+		err = fmt.Errorf("can't find 'x-sls-compresstype' header")
+		return
+	}
+	if v[0] != "lz4" {
+		err = fmt.Errorf("unexpected compress type:%v", v[0])
+		return
+	}
+
+	v, ok = r.Header["X-Sls-Cursor"]
+	if !ok || len(v) == 0 {
+		err = fmt.Errorf("can't find 'x-sls-cursor' header")
+		return
+	}
+	nextCursor = v[0]
+
+	v, ok = r.Header["X-Sls-Bodyrawsize"]
+	if !ok || len(v) == 0 {
+		err = fmt.Errorf("can't find 'x-sls-bodyrawsize' header")
+		return
+	}
+	bodyRawSize, err := strconv.Atoi(v[0])
+	if err != nil {
+		return
+	}
+
+	out = make([]byte, bodyRawSize)
+	err = lz4.Uncompress(buf, out)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// LogsBytesDecode decodes logs binary data retruned by GetLogsBytes API
+func LogsBytesDecode(data []byte) (gl *LogGroupList, err error) {
+
+	gl = &LogGroupList{}
+	err = proto.Unmarshal(data, gl)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// GetLogs gets logs from shard specified by shardId according cursor.
+// The logGroupMaxCount is the max number of logGroup could be returned.
+// The nextCursor is the next curosr can be used to read logs at next time.
+func (s *LogStore) GetLogs(shardId int, cursor string,
+	logGroupMaxCount int) (gl *LogGroupList, nextCursor string, err error) {
+
+	out, nextCursor, err := s.GetLogsBytes(shardId, cursor, logGroupMaxCount)
+	if err != nil {
+		return
+	}
+
+	gl, err = LogsBytesDecode(out)
+	if err != nil {
+		return
+	}
+
+	return
+}

logs/alils/machine_group.go

@@ -0,0 +1,87 @@
+package alils
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httputil"
+)
+
+type MachinGroupAttribute struct {
+	ExternalName string `json:"externalName"`
+	TopicName    string `json:"groupTopic"`
+}
+
+type MachineGroup struct {
+	Name          string   `json:"groupName"`
+	Type          string   `json:"groupType"`
+	MachineIdType string   `json:"machineIdentifyType"`
+	MachineIdList []string `json:"machineList"`
+
+	Attribute MachinGroupAttribute `json:"groupAttribute"`
+
+	CreateTime     uint32
+	LastModifyTime uint32
+
+	project *LogProject
+}
+
+type Machine struct {
+	IP            string
+	UniqueId      string `json:"machine-uniqueid"`
+	UserdefinedId string `json:"userdefined-id"`
+}
+
+type MachineList struct {
+	Total    int
+	Machines []*Machine
+}
+
+// ListMachines returns machine list of this machine group.
+func (m *MachineGroup) ListMachines() (ms []*Machine, total int, err error) {
+	h := map[string]string{
+		"x-sls-bodyrawsize": "0",
+	}
+
+	uri := fmt.Sprintf("/machinegroups/%v/machines", m.Name)
+	r, err := request(m.project, "GET", uri, h, nil)
+	if err != nil {
+		return
+	}
+
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		return
+	}
+
+	if r.StatusCode != http.StatusOK {
+		errMsg := &errorMessage{}
+		err = json.Unmarshal(buf, errMsg)
+		if err != nil {
+			err = fmt.Errorf("failed to remove config from machine group")
+			dump, _ := httputil.DumpResponse(r, true)
+			fmt.Println(dump)
+			return
+		}
+		err = fmt.Errorf("%v:%v", errMsg.Code, errMsg.Message)
+		return
+	}
+
+	body := &MachineList{}
+	err = json.Unmarshal(buf, body)
+	if err != nil {
+		return
+	}
+
+	ms = body.Machines
+	total = body.Total
+
+	return
+}
+
+// GetAppliedConfigs returns applied configs of this machine group.
+func (m *MachineGroup) GetAppliedConfigs() (confNames []string, err error) {
+	confNames, err = m.project.GetAppliedConfigs(m.Name)
+	return
+}

logs/alils/request.go

@@ -0,0 +1,62 @@
+package alils
+
+import (
+	"bytes"
+	"crypto/md5"
+	"fmt"
+	"net/http"
+)
+
+// request sends a request to SLS.
+func request(project *LogProject, method, uri string, headers map[string]string,
+	body []byte) (resp *http.Response, err error) {
+
+	// The caller should provide 'x-sls-bodyrawsize' header
+	if _, ok := headers["x-sls-bodyrawsize"]; !ok {
+		err = fmt.Errorf("Can't find 'x-sls-bodyrawsize' header")
+		return
+	}
+
+	// SLS public request headers
+	headers["Host"] = project.Name + "." + project.Endpoint
+	headers["Date"] = nowRFC1123()
+	headers["x-sls-apiversion"] = version
+	headers["x-sls-signaturemethod"] = signatureMethod
+	if body != nil {
+		bodyMD5 := fmt.Sprintf("%X", md5.Sum(body))
+		headers["Content-MD5"] = bodyMD5
+
+		if _, ok := headers["Content-Type"]; !ok {
+			err = fmt.Errorf("Can't find 'Content-Type' header")
+			return
+		}
+	}
+
+	// Calc Authorization
+	// Authorization = "SLS <AccessKeyId>:<Signature>"
+	digest, err := signature(project, method, uri, headers)
+	if err != nil {
+		return
+	}
+	auth := fmt.Sprintf("SLS %v:%v", project.AccessKeyId, digest)
+	headers["Authorization"] = auth
+
+	// Initialize http request
+	reader := bytes.NewReader(body)
+	urlStr := fmt.Sprintf("http://%v.%v%v", project.Name, project.Endpoint, uri)
+	req, err := http.NewRequest(method, urlStr, reader)
+	if err != nil {
+		return
+	}
+	for k, v := range headers {
+		req.Header.Add(k, v)
+	}
+
+	// Get ready to do request
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		return
+	}
+
+	return
+}

logs/alils/signature.go

@@ -0,0 +1,112 @@
+package alils
+
+import (
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/base64"
+	"fmt"
+	"net/url"
+	"sort"
+	"strings"
+	"time"
+)
+
+// GMT location
+var gmtLoc = time.FixedZone("GMT", 0)
+
+// NowRFC1123 returns now time in RFC1123 format with GMT timezone,
+// eg. "Mon, 02 Jan 2006 15:04:05 GMT".
+func nowRFC1123() string {
+	return time.Now().In(gmtLoc).Format(time.RFC1123)
+}
+
+// signature calculates a request's signature digest.
+func signature(project *LogProject, method, uri string,
+	headers map[string]string) (digest string, err error) {
+	var contentMD5, contentType, date, canoHeaders, canoResource string
+	var slsHeaderKeys sort.StringSlice
+
+	// SignString = VERB + "\n"
+	//              + CONTENT-MD5 + "\n"
+	//              + CONTENT-TYPE + "\n"
+	//              + DATE + "\n"
+	//              + CanonicalizedSLSHeaders + "\n"
+	//              + CanonicalizedResource
+
+	if val, ok := headers["Content-MD5"]; ok {
+		contentMD5 = val
+	}
+
+	if val, ok := headers["Content-Type"]; ok {
+		contentType = val
+	}
+
+	date, ok := headers["Date"]
+	if !ok {
+		err = fmt.Errorf("Can't find 'Date' header")
+		return
+	}
+
+	// Calc CanonicalizedSLSHeaders
+	slsHeaders := make(map[string]string, len(headers))
+	for k, v := range headers {
+		l := strings.TrimSpace(strings.ToLower(k))
+		if strings.HasPrefix(l, "x-sls-") {
+			slsHeaders[l] = strings.TrimSpace(v)
+			slsHeaderKeys = append(slsHeaderKeys, l)
+		}
+	}
+
+	sort.Sort(slsHeaderKeys)
+	for i, k := range slsHeaderKeys {
+		canoHeaders += k + ":" + slsHeaders[k]
+		if i+1 < len(slsHeaderKeys) {
+			canoHeaders += "\n"
+		}
+	}
+
+	// Calc CanonicalizedResource
+	u, err := url.Parse(uri)
+	if err != nil {
+		return
+	}
+
+	canoResource += url.QueryEscape(u.Path)
+	if u.RawQuery != "" {
+		var keys sort.StringSlice
+
+		vals := u.Query()
+		for k, _ := range vals {
+			keys = append(keys, k)
+		}
+
+		sort.Sort(keys)
+		canoResource += "?"
+		for i, k := range keys {
+			if i > 0 {
+				canoResource += "&"
+			}
+
+			for _, v := range vals[k] {
+				canoResource += k + "=" + v
+			}
+		}
+	}
+
+	signStr := method + "\n" +
+		contentMD5 + "\n" +
+		contentType + "\n" +
+		date + "\n" +
+		canoHeaders + "\n" +
+		canoResource
+
+	// Signature = base64(hmac-sha1(UTF8-Encoding-Of(SignString)，AccessKeySecret))
+	mac := hmac.New(sha1.New, []byte(project.AccessKeySecret))
+	_, err = mac.Write([]byte(signStr))
+	if err != nil {
+		return
+	}
+	digest = base64.StdEncoding.EncodeToString(mac.Sum(nil))
+	return
+}
+

logs/color.go

@@ -0,0 +1,28 @@
+// 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.
+
+// +build !windows
+
+package logs
+
+import "io"
+
+type ansiColorWriter struct {
+	w    io.Writer
+	mode outputMode
+}
+
+func (cw *ansiColorWriter) Write(p []byte) (int, error) {
+	return cw.w.Write(p)
+}

logs/color_windows.go

@@ -0,0 +1,428 @@
+// 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.
+
+// +build windows
+
+package logs
+
+import (
+	"bytes"
+	"io"
+	"strings"
+	"syscall"
+	"unsafe"
+)
+
+type (
+	csiState    int
+	parseResult int
+)
+
+const (
+	outsideCsiCode csiState = iota
+	firstCsiCode
+	secondCsiCode
+)
+
+const (
+	noConsole parseResult = iota
+	changedColor
+	unknown
+)
+
+type ansiColorWriter struct {
+	w             io.Writer
+	mode          outputMode
+	state         csiState
+	paramStartBuf bytes.Buffer
+	paramBuf      bytes.Buffer
+}
+
+const (
+	firstCsiChar   byte = '\x1b'
+	secondeCsiChar byte = '['
+	separatorChar  byte = ';'
+	sgrCode        byte = 'm'
+)
+
+const (
+	foregroundBlue      = uint16(0x0001)
+	foregroundGreen     = uint16(0x0002)
+	foregroundRed       = uint16(0x0004)
+	foregroundIntensity = uint16(0x0008)
+	backgroundBlue      = uint16(0x0010)
+	backgroundGreen     = uint16(0x0020)
+	backgroundRed       = uint16(0x0040)
+	backgroundIntensity = uint16(0x0080)
+	underscore          = uint16(0x8000)
+
+	foregroundMask = foregroundBlue | foregroundGreen | foregroundRed | foregroundIntensity
+	backgroundMask = backgroundBlue | backgroundGreen | backgroundRed | backgroundIntensity
+)
+
+const (
+	ansiReset        = "0"
+	ansiIntensityOn  = "1"
+	ansiIntensityOff = "21"
+	ansiUnderlineOn  = "4"
+	ansiUnderlineOff = "24"
+	ansiBlinkOn      = "5"
+	ansiBlinkOff     = "25"
+
+	ansiForegroundBlack   = "30"
+	ansiForegroundRed     = "31"
+	ansiForegroundGreen   = "32"
+	ansiForegroundYellow  = "33"
+	ansiForegroundBlue    = "34"
+	ansiForegroundMagenta = "35"
+	ansiForegroundCyan    = "36"
+	ansiForegroundWhite   = "37"
+	ansiForegroundDefault = "39"
+
+	ansiBackgroundBlack   = "40"
+	ansiBackgroundRed     = "41"
+	ansiBackgroundGreen   = "42"
+	ansiBackgroundYellow  = "43"
+	ansiBackgroundBlue    = "44"
+	ansiBackgroundMagenta = "45"
+	ansiBackgroundCyan    = "46"
+	ansiBackgroundWhite   = "47"
+	ansiBackgroundDefault = "49"
+
+	ansiLightForegroundGray    = "90"
+	ansiLightForegroundRed     = "91"
+	ansiLightForegroundGreen   = "92"
+	ansiLightForegroundYellow  = "93"
+	ansiLightForegroundBlue    = "94"
+	ansiLightForegroundMagenta = "95"
+	ansiLightForegroundCyan    = "96"
+	ansiLightForegroundWhite   = "97"
+
+	ansiLightBackgroundGray    = "100"
+	ansiLightBackgroundRed     = "101"
+	ansiLightBackgroundGreen   = "102"
+	ansiLightBackgroundYellow  = "103"
+	ansiLightBackgroundBlue    = "104"
+	ansiLightBackgroundMagenta = "105"
+	ansiLightBackgroundCyan    = "106"
+	ansiLightBackgroundWhite   = "107"
+)
+
+type drawType int
+
+const (
+	foreground drawType = iota
+	background
+)
+
+type winColor struct {
+	code     uint16
+	drawType drawType
+}
+
+var colorMap = map[string]winColor{
+	ansiForegroundBlack:   {0, foreground},
+	ansiForegroundRed:     {foregroundRed, foreground},
+	ansiForegroundGreen:   {foregroundGreen, foreground},
+	ansiForegroundYellow:  {foregroundRed | foregroundGreen, foreground},
+	ansiForegroundBlue:    {foregroundBlue, foreground},
+	ansiForegroundMagenta: {foregroundRed | foregroundBlue, foreground},
+	ansiForegroundCyan:    {foregroundGreen | foregroundBlue, foreground},
+	ansiForegroundWhite:   {foregroundRed | foregroundGreen | foregroundBlue, foreground},
+	ansiForegroundDefault: {foregroundRed | foregroundGreen | foregroundBlue, foreground},
+
+	ansiBackgroundBlack:   {0, background},
+	ansiBackgroundRed:     {backgroundRed, background},
+	ansiBackgroundGreen:   {backgroundGreen, background},
+	ansiBackgroundYellow:  {backgroundRed | backgroundGreen, background},
+	ansiBackgroundBlue:    {backgroundBlue, background},
+	ansiBackgroundMagenta: {backgroundRed | backgroundBlue, background},
+	ansiBackgroundCyan:    {backgroundGreen | backgroundBlue, background},
+	ansiBackgroundWhite:   {backgroundRed | backgroundGreen | backgroundBlue, background},
+	ansiBackgroundDefault: {0, background},
+
+	ansiLightForegroundGray:    {foregroundIntensity, foreground},
+	ansiLightForegroundRed:     {foregroundIntensity | foregroundRed, foreground},
+	ansiLightForegroundGreen:   {foregroundIntensity | foregroundGreen, foreground},
+	ansiLightForegroundYellow:  {foregroundIntensity | foregroundRed | foregroundGreen, foreground},
+	ansiLightForegroundBlue:    {foregroundIntensity | foregroundBlue, foreground},
+	ansiLightForegroundMagenta: {foregroundIntensity | foregroundRed | foregroundBlue, foreground},
+	ansiLightForegroundCyan:    {foregroundIntensity | foregroundGreen | foregroundBlue, foreground},
+	ansiLightForegroundWhite:   {foregroundIntensity | foregroundRed | foregroundGreen | foregroundBlue, foreground},
+
+	ansiLightBackgroundGray:    {backgroundIntensity, background},
+	ansiLightBackgroundRed:     {backgroundIntensity | backgroundRed, background},
+	ansiLightBackgroundGreen:   {backgroundIntensity | backgroundGreen, background},
+	ansiLightBackgroundYellow:  {backgroundIntensity | backgroundRed | backgroundGreen, background},
+	ansiLightBackgroundBlue:    {backgroundIntensity | backgroundBlue, background},
+	ansiLightBackgroundMagenta: {backgroundIntensity | backgroundRed | backgroundBlue, background},
+	ansiLightBackgroundCyan:    {backgroundIntensity | backgroundGreen | backgroundBlue, background},
+	ansiLightBackgroundWhite:   {backgroundIntensity | backgroundRed | backgroundGreen | backgroundBlue, background},
+}
+
+var (
+	kernel32                       = syscall.NewLazyDLL("kernel32.dll")
+	procSetConsoleTextAttribute    = kernel32.NewProc("SetConsoleTextAttribute")
+	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
+	defaultAttr                    *textAttributes
+)
+
+func init() {
+	screenInfo := getConsoleScreenBufferInfo(uintptr(syscall.Stdout))
+	if screenInfo != nil {
+		colorMap[ansiForegroundDefault] = winColor{
+			screenInfo.WAttributes & (foregroundRed | foregroundGreen | foregroundBlue),
+			foreground,
+		}
+		colorMap[ansiBackgroundDefault] = winColor{
+			screenInfo.WAttributes & (backgroundRed | backgroundGreen | backgroundBlue),
+			background,
+		}
+		defaultAttr = convertTextAttr(screenInfo.WAttributes)
+	}
+}
+
+type coord struct {
+	X, Y int16
+}
+
+type smallRect struct {
+	Left, Top, Right, Bottom int16
+}
+
+type consoleScreenBufferInfo struct {
+	DwSize              coord
+	DwCursorPosition    coord
+	WAttributes         uint16
+	SrWindow            smallRect
+	DwMaximumWindowSize coord
+}
+
+func getConsoleScreenBufferInfo(hConsoleOutput uintptr) *consoleScreenBufferInfo {
+	var csbi consoleScreenBufferInfo
+	ret, _, _ := procGetConsoleScreenBufferInfo.Call(
+		hConsoleOutput,
+		uintptr(unsafe.Pointer(&csbi)))
+	if ret == 0 {
+		return nil
+	}
+	return &csbi
+}
+
+func setConsoleTextAttribute(hConsoleOutput uintptr, wAttributes uint16) bool {
+	ret, _, _ := procSetConsoleTextAttribute.Call(
+		hConsoleOutput,
+		uintptr(wAttributes))
+	return ret != 0
+}
+
+type textAttributes struct {
+	foregroundColor     uint16
+	backgroundColor     uint16
+	foregroundIntensity uint16
+	backgroundIntensity uint16
+	underscore          uint16
+	otherAttributes     uint16
+}
+
+func convertTextAttr(winAttr uint16) *textAttributes {
+	fgColor := winAttr & (foregroundRed | foregroundGreen | foregroundBlue)
+	bgColor := winAttr & (backgroundRed | backgroundGreen | backgroundBlue)
+	fgIntensity := winAttr & foregroundIntensity
+	bgIntensity := winAttr & backgroundIntensity
+	underline := winAttr & underscore
+	otherAttributes := winAttr &^ (foregroundMask | backgroundMask | underscore)
+	return &textAttributes{fgColor, bgColor, fgIntensity, bgIntensity, underline, otherAttributes}
+}
+
+func convertWinAttr(textAttr *textAttributes) uint16 {
+	var winAttr uint16
+	winAttr |= textAttr.foregroundColor
+	winAttr |= textAttr.backgroundColor
+	winAttr |= textAttr.foregroundIntensity
+	winAttr |= textAttr.backgroundIntensity
+	winAttr |= textAttr.underscore
+	winAttr |= textAttr.otherAttributes
+	return winAttr
+}
+
+func changeColor(param []byte) parseResult {
+	screenInfo := getConsoleScreenBufferInfo(uintptr(syscall.Stdout))
+	if screenInfo == nil {
+		return noConsole
+	}
+
+	winAttr := convertTextAttr(screenInfo.WAttributes)
+	strParam := string(param)
+	if len(strParam) <= 0 {
+		strParam = "0"
+	}
+	csiParam := strings.Split(strParam, string(separatorChar))
+	for _, p := range csiParam {
+		c, ok := colorMap[p]
+		switch {
+		case !ok:
+			switch p {
+			case ansiReset:
+				winAttr.foregroundColor = defaultAttr.foregroundColor
+				winAttr.backgroundColor = defaultAttr.backgroundColor
+				winAttr.foregroundIntensity = defaultAttr.foregroundIntensity
+				winAttr.backgroundIntensity = defaultAttr.backgroundIntensity
+				winAttr.underscore = 0
+				winAttr.otherAttributes = 0
+			case ansiIntensityOn:
+				winAttr.foregroundIntensity = foregroundIntensity
+			case ansiIntensityOff:
+				winAttr.foregroundIntensity = 0
+			case ansiUnderlineOn:
+				winAttr.underscore = underscore
+			case ansiUnderlineOff:
+				winAttr.underscore = 0
+			case ansiBlinkOn:
+				winAttr.backgroundIntensity = backgroundIntensity
+			case ansiBlinkOff:
+				winAttr.backgroundIntensity = 0
+			default:
+				// unknown code
+			}
+		case c.drawType == foreground:
+			winAttr.foregroundColor = c.code
+		case c.drawType == background:
+			winAttr.backgroundColor = c.code
+		}
+	}
+	winTextAttribute := convertWinAttr(winAttr)
+	setConsoleTextAttribute(uintptr(syscall.Stdout), winTextAttribute)
+
+	return changedColor
+}
+
+func parseEscapeSequence(command byte, param []byte) parseResult {
+	if defaultAttr == nil {
+		return noConsole
+	}
+
+	switch command {
+	case sgrCode:
+		return changeColor(param)
+	default:
+		return unknown
+	}
+}
+
+func (cw *ansiColorWriter) flushBuffer() (int, error) {
+	return cw.flushTo(cw.w)
+}
+
+func (cw *ansiColorWriter) resetBuffer() (int, error) {
+	return cw.flushTo(nil)
+}
+
+func (cw *ansiColorWriter) flushTo(w io.Writer) (int, error) {
+	var n1, n2 int
+	var err error
+
+	startBytes := cw.paramStartBuf.Bytes()
+	cw.paramStartBuf.Reset()
+	if w != nil {
+		n1, err = cw.w.Write(startBytes)
+		if err != nil {
+			return n1, err
+		}
+	} else {
+		n1 = len(startBytes)
+	}
+	paramBytes := cw.paramBuf.Bytes()
+	cw.paramBuf.Reset()
+	if w != nil {
+		n2, err = cw.w.Write(paramBytes)
+		if err != nil {
+			return n1 + n2, err
+		}
+	} else {
+		n2 = len(paramBytes)
+	}
+	return n1 + n2, nil
+}
+
+func isParameterChar(b byte) bool {
+	return ('0' <= b && b <= '9') || b == separatorChar
+}
+
+func (cw *ansiColorWriter) Write(p []byte) (int, error) {
+	r, nw, first, last := 0, 0, 0, 0
+	if cw.mode != DiscardNonColorEscSeq {
+		cw.state = outsideCsiCode
+		cw.resetBuffer()
+	}
+
+	var err error
+	for i, ch := range p {
+		switch cw.state {
+		case outsideCsiCode:
+			if ch == firstCsiChar {
+				cw.paramStartBuf.WriteByte(ch)
+				cw.state = firstCsiCode
+			}
+		case firstCsiCode:
+			switch ch {
+			case firstCsiChar:
+				cw.paramStartBuf.WriteByte(ch)
+				break
+			case secondeCsiChar:
+				cw.paramStartBuf.WriteByte(ch)
+				cw.state = secondCsiCode
+				last = i - 1
+			default:
+				cw.resetBuffer()
+				cw.state = outsideCsiCode
+			}
+		case secondCsiCode:
+			if isParameterChar(ch) {
+				cw.paramBuf.WriteByte(ch)
+			} else {
+				nw, err = cw.w.Write(p[first:last])
+				r += nw
+				if err != nil {
+					return r, err
+				}
+				first = i + 1
+				result := parseEscapeSequence(ch, cw.paramBuf.Bytes())
+				if result == noConsole || (cw.mode == OutputNonColorEscSeq && result == unknown) {
+					cw.paramBuf.WriteByte(ch)
+					nw, err := cw.flushBuffer()
+					if err != nil {
+						return r, err
+					}
+					r += nw
+				} else {
+					n, _ := cw.resetBuffer()
+					// Add one more to the size of the buffer for the last ch
+					r += n + 1
+				}
+
+				cw.state = outsideCsiCode
+			}
+		default:
+			cw.state = outsideCsiCode
+		}
+	}
+
+	if cw.mode != DiscardNonColorEscSeq || cw.state == outsideCsiCode {
+		nw, err = cw.w.Write(p[first:])
+		r += nw
+	}
+
+	return r, err
+}

logs/color_windows_test.go

@@ -0,0 +1,294 @@
+// 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.
+
+// +build windows
+
+package logs
+
+import (
+	"bytes"
+	"fmt"
+	"syscall"
+	"testing"
+)
+
+var GetConsoleScreenBufferInfo = getConsoleScreenBufferInfo
+
+func ChangeColor(color uint16) {
+	setConsoleTextAttribute(uintptr(syscall.Stdout), color)
+}
+
+func ResetColor() {
+	ChangeColor(uint16(0x0007))
+}
+
+func TestWritePlanText(t *testing.T) {
+	inner := bytes.NewBufferString("")
+	w := NewAnsiColorWriter(inner)
+	expected := "plain text"
+	fmt.Fprintf(w, expected)
+	actual := inner.String()
+	if actual != expected {
+		t.Errorf("Get %q, want %q", actual, expected)
+	}
+}
+
+func TestWriteParseText(t *testing.T) {
+	inner := bytes.NewBufferString("")
+	w := NewAnsiColorWriter(inner)
+
+	inputTail := "\x1b[0mtail text"
+	expectedTail := "tail text"
+	fmt.Fprintf(w, inputTail)
+	actualTail := inner.String()
+	inner.Reset()
+	if actualTail != expectedTail {
+		t.Errorf("Get %q, want %q", actualTail, expectedTail)
+	}
+
+	inputHead := "head text\x1b[0m"
+	expectedHead := "head text"
+	fmt.Fprintf(w, inputHead)
+	actualHead := inner.String()
+	inner.Reset()
+	if actualHead != expectedHead {
+		t.Errorf("Get %q, want %q", actualHead, expectedHead)
+	}
+
+	inputBothEnds := "both ends \x1b[0m text"
+	expectedBothEnds := "both ends  text"
+	fmt.Fprintf(w, inputBothEnds)
+	actualBothEnds := inner.String()
+	inner.Reset()
+	if actualBothEnds != expectedBothEnds {
+		t.Errorf("Get %q, want %q", actualBothEnds, expectedBothEnds)
+	}
+
+	inputManyEsc := "\x1b\x1b\x1b\x1b[0m many esc"
+	expectedManyEsc := "\x1b\x1b\x1b many esc"
+	fmt.Fprintf(w, inputManyEsc)
+	actualManyEsc := inner.String()
+	inner.Reset()
+	if actualManyEsc != expectedManyEsc {
+		t.Errorf("Get %q, want %q", actualManyEsc, expectedManyEsc)
+	}
+
+	expectedSplit := "split  text"
+	for _, ch := range "split \x1b[0m text" {
+		fmt.Fprintf(w, string(ch))
+	}
+	actualSplit := inner.String()
+	inner.Reset()
+	if actualSplit != expectedSplit {
+		t.Errorf("Get %q, want %q", actualSplit, expectedSplit)
+	}
+}
+
+type screenNotFoundError struct {
+	error
+}
+
+func writeAnsiColor(expectedText, colorCode string) (actualText string, actualAttributes uint16, err error) {
+	inner := bytes.NewBufferString("")
+	w := NewAnsiColorWriter(inner)
+	fmt.Fprintf(w, "\x1b[%sm%s", colorCode, expectedText)
+
+	actualText = inner.String()
+	screenInfo := GetConsoleScreenBufferInfo(uintptr(syscall.Stdout))
+	if screenInfo != nil {
+		actualAttributes = screenInfo.WAttributes
+	} else {
+		err = &screenNotFoundError{}
+	}
+	return
+}
+
+type testParam struct {
+	text       string
+	attributes uint16
+	ansiColor  string
+}
+
+func TestWriteAnsiColorText(t *testing.T) {
+	screenInfo := GetConsoleScreenBufferInfo(uintptr(syscall.Stdout))
+	if screenInfo == nil {
+		t.Fatal("Could not get ConsoleScreenBufferInfo")
+	}
+	defer ChangeColor(screenInfo.WAttributes)
+	defaultFgColor := screenInfo.WAttributes & uint16(0x0007)
+	defaultBgColor := screenInfo.WAttributes & uint16(0x0070)
+	defaultFgIntensity := screenInfo.WAttributes & uint16(0x0008)
+	defaultBgIntensity := screenInfo.WAttributes & uint16(0x0080)
+
+	fgParam := []testParam{
+		{"foreground black  ", uint16(0x0000 | 0x0000), "30"},
+		{"foreground red    ", uint16(0x0004 | 0x0000), "31"},
+		{"foreground green  ", uint16(0x0002 | 0x0000), "32"},
+		{"foreground yellow ", uint16(0x0006 | 0x0000), "33"},
+		{"foreground blue   ", uint16(0x0001 | 0x0000), "34"},
+		{"foreground magenta", uint16(0x0005 | 0x0000), "35"},
+		{"foreground cyan   ", uint16(0x0003 | 0x0000), "36"},
+		{"foreground white  ", uint16(0x0007 | 0x0000), "37"},
+		{"foreground default", defaultFgColor | 0x0000, "39"},
+		{"foreground light gray   ", uint16(0x0000 | 0x0008 | 0x0000), "90"},
+		{"foreground light red    ", uint16(0x0004 | 0x0008 | 0x0000), "91"},
+		{"foreground light green  ", uint16(0x0002 | 0x0008 | 0x0000), "92"},
+		{"foreground light yellow ", uint16(0x0006 | 0x0008 | 0x0000), "93"},
+		{"foreground light blue   ", uint16(0x0001 | 0x0008 | 0x0000), "94"},
+		{"foreground light magenta", uint16(0x0005 | 0x0008 | 0x0000), "95"},
+		{"foreground light cyan   ", uint16(0x0003 | 0x0008 | 0x0000), "96"},
+		{"foreground light white  ", uint16(0x0007 | 0x0008 | 0x0000), "97"},
+	}
+
+	bgParam := []testParam{
+		{"background black  ", uint16(0x0007 | 0x0000), "40"},
+		{"background red    ", uint16(0x0007 | 0x0040), "41"},
+		{"background green  ", uint16(0x0007 | 0x0020), "42"},
+		{"background yellow ", uint16(0x0007 | 0x0060), "43"},
+		{"background blue   ", uint16(0x0007 | 0x0010), "44"},
+		{"background magenta", uint16(0x0007 | 0x0050), "45"},
+		{"background cyan   ", uint16(0x0007 | 0x0030), "46"},
+		{"background white  ", uint16(0x0007 | 0x0070), "47"},
+		{"background default", uint16(0x0007) | defaultBgColor, "49"},
+		{"background light gray   ", uint16(0x0007 | 0x0000 | 0x0080), "100"},
+		{"background light red    ", uint16(0x0007 | 0x0040 | 0x0080), "101"},
+		{"background light green  ", uint16(0x0007 | 0x0020 | 0x0080), "102"},
+		{"background light yellow ", uint16(0x0007 | 0x0060 | 0x0080), "103"},
+		{"background light blue   ", uint16(0x0007 | 0x0010 | 0x0080), "104"},
+		{"background light magenta", uint16(0x0007 | 0x0050 | 0x0080), "105"},
+		{"background light cyan   ", uint16(0x0007 | 0x0030 | 0x0080), "106"},
+		{"background light white  ", uint16(0x0007 | 0x0070 | 0x0080), "107"},
+	}
+
+	resetParam := []testParam{
+		{"all reset", defaultFgColor | defaultBgColor | defaultFgIntensity | defaultBgIntensity, "0"},
+		{"all reset", defaultFgColor | defaultBgColor | defaultFgIntensity | defaultBgIntensity, ""},
+	}
+
+	boldParam := []testParam{
+		{"bold on", uint16(0x0007 | 0x0008), "1"},
+		{"bold off", uint16(0x0007), "21"},
+	}
+
+	underscoreParam := []testParam{
+		{"underscore on", uint16(0x0007 | 0x8000), "4"},
+		{"underscore off", uint16(0x0007), "24"},
+	}
+
+	blinkParam := []testParam{
+		{"blink on", uint16(0x0007 | 0x0080), "5"},
+		{"blink off", uint16(0x0007), "25"},
+	}
+
+	mixedParam := []testParam{
+		{"both black,   bold, underline, blink", uint16(0x0000 | 0x0000 | 0x0008 | 0x8000 | 0x0080), "30;40;1;4;5"},
+		{"both red,     bold, underline, blink", uint16(0x0004 | 0x0040 | 0x0008 | 0x8000 | 0x0080), "31;41;1;4;5"},
+		{"both green,   bold, underline, blink", uint16(0x0002 | 0x0020 | 0x0008 | 0x8000 | 0x0080), "32;42;1;4;5"},
+		{"both yellow,  bold, underline, blink", uint16(0x0006 | 0x0060 | 0x0008 | 0x8000 | 0x0080), "33;43;1;4;5"},
+		{"both blue,    bold, underline, blink", uint16(0x0001 | 0x0010 | 0x0008 | 0x8000 | 0x0080), "34;44;1;4;5"},
+		{"both magenta, bold, underline, blink", uint16(0x0005 | 0x0050 | 0x0008 | 0x8000 | 0x0080), "35;45;1;4;5"},
+		{"both cyan,    bold, underline, blink", uint16(0x0003 | 0x0030 | 0x0008 | 0x8000 | 0x0080), "36;46;1;4;5"},
+		{"both white,   bold, underline, blink", uint16(0x0007 | 0x0070 | 0x0008 | 0x8000 | 0x0080), "37;47;1;4;5"},
+		{"both default, bold, underline, blink", uint16(defaultFgColor | defaultBgColor | 0x0008 | 0x8000 | 0x0080), "39;49;1;4;5"},
+	}
+
+	assertTextAttribute := func(expectedText string, expectedAttributes uint16, ansiColor string) {
+		actualText, actualAttributes, err := writeAnsiColor(expectedText, ansiColor)
+		if actualText != expectedText {
+			t.Errorf("Get %q, want %q", actualText, expectedText)
+		}
+		if err != nil {
+			t.Fatal("Could not get ConsoleScreenBufferInfo")
+		}
+		if actualAttributes != expectedAttributes {
+			t.Errorf("Text: %q, Get 0x%04x, want 0x%04x", expectedText, actualAttributes, expectedAttributes)
+		}
+	}
+
+	for _, v := range fgParam {
+		ResetColor()
+		assertTextAttribute(v.text, v.attributes, v.ansiColor)
+	}
+
+	for _, v := range bgParam {
+		ChangeColor(uint16(0x0070 | 0x0007))
+		assertTextAttribute(v.text, v.attributes, v.ansiColor)
+	}
+
+	for _, v := range resetParam {
+		ChangeColor(uint16(0x0000 | 0x0070 | 0x0008))
+		assertTextAttribute(v.text, v.attributes, v.ansiColor)
+	}
+
+	ResetColor()
+	for _, v := range boldParam {
+		assertTextAttribute(v.text, v.attributes, v.ansiColor)
+	}
+
+	ResetColor()
+	for _, v := range underscoreParam {
+		assertTextAttribute(v.text, v.attributes, v.ansiColor)
+	}
+
+	ResetColor()
+	for _, v := range blinkParam {
+		assertTextAttribute(v.text, v.attributes, v.ansiColor)
+	}
+
+	for _, v := range mixedParam {
+		ResetColor()
+		assertTextAttribute(v.text, v.attributes, v.ansiColor)
+	}
+}
+
+func TestIgnoreUnknownSequences(t *testing.T) {
+	inner := bytes.NewBufferString("")
+	w := NewModeAnsiColorWriter(inner, OutputNonColorEscSeq)
+
+	inputText := "\x1b[=decpath mode"
+	expectedTail := inputText
+	fmt.Fprintf(w, inputText)
+	actualTail := inner.String()
+	inner.Reset()
+	if actualTail != expectedTail {
+		t.Errorf("Get %q, want %q", actualTail, expectedTail)
+	}
+
+	inputText = "\x1b[=tailing esc and bracket\x1b["
+	expectedTail = inputText
+	fmt.Fprintf(w, inputText)
+	actualTail = inner.String()
+	inner.Reset()
+	if actualTail != expectedTail {
+		t.Errorf("Get %q, want %q", actualTail, expectedTail)
+	}
+
+	inputText = "\x1b[?tailing esc\x1b"
+	expectedTail = inputText
+	fmt.Fprintf(w, inputText)
+	actualTail = inner.String()
+	inner.Reset()
+	if actualTail != expectedTail {
+		t.Errorf("Get %q, want %q", actualTail, expectedTail)
+	}
+
+	inputText = "\x1b[1h;3punended color code invalid\x1b3"
+	expectedTail = inputText
+	fmt.Fprintf(w, inputText)
+	actualTail = inner.String()
+	inner.Reset()
+	if actualTail != expectedTail {
+		t.Errorf("Get %q, want %q", actualTail, expectedTail)
+	}
+}

logs/conn.go

@@ -113,5 +113,5 @@ func (c *connWriter) needToConnectOnMsg() bool {
 }
 
 func init() {
-	Register("conn", NewConn)
+	Register(AdapterConn, NewConn)
 }

logs/console.go

@@ -56,7 +56,7 @@ func NewConsole() Logger {
 	cw := &consoleWriter{
 		lg:       newLogWriter(os.Stdout),
 		Level:    LevelDebug,
-		Colorful: true,
+		Colorful: runtime.GOOS != "windows",
 	}
 	return cw
 }
@@ -97,5 +97,5 @@ func (c *consoleWriter) Flush() {
 }
 
 func init() {
-	Register("console", NewConsole)
+	Register(AdapterConsole, NewConsole)
 }

logs/es/es.go

@@ -76,5 +76,5 @@ func (el *esLogger) Flush() {
 }
 
 func init() {
-	logs.Register("es", NewES)
+	logs.Register(logs.AdapterEs, NewES)
 }

logs/file.go

@@ -22,6 +22,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -30,7 +31,7 @@ import (
 // fileLogWriter implements LoggerInterface.
 // It writes messages by lines limit, file size limit, or time frequency.
 type fileLogWriter struct {
-	sync.Mutex // write log order by order and  atomic incr maxLinesCurLines and maxSizeCurSize
+	sync.RWMutex // write log order by order and  atomic incr maxLinesCurLines and maxSizeCurSize
 	// The opened file
 	Filename   string `json:"filename"`
 	fileWriter *os.File
@@ -47,12 +48,13 @@ type fileLogWriter struct {
 	Daily         bool  `json:"daily"`
 	MaxDays       int64 `json:"maxdays"`
 	dailyOpenDate int
+	dailyOpenTime time.Time
 
 	Rotate bool `json:"rotate"`
 
 	Level int `json:"level"`
 
-	Perm os.FileMode `json:"perm"`
+	Perm string `json:"perm"`
 
 	fileNameOnly, suffix string // like "project.log", project is fileNameOnly and .log is suffix
 }
@@ -60,14 +62,11 @@ type fileLogWriter struct {
 // newFileWriter create a FileLogWriter returning as LoggerInterface.
 func newFileWriter() Logger {
 	w := &fileLogWriter{
-		Filename: "",
-		MaxLines: 1000000,
-		MaxSize:  1 << 28, //256 MB
 		Daily:   true,
 		MaxDays: 7,
 		Rotate:  true,
 		Level:   LevelTrace,
-		Perm:     0660,
+		Perm:    "0660",
 	}
 	return w
 }
@@ -77,11 +76,11 @@ func newFileWriter() Logger {
 //	{
 //	"filename":"logs/beego.log",
 //	"maxLines":10000,
-//	"maxsize":1<<30,
+//	"maxsize":1024,
 //	"daily":true,
 //	"maxDays":15,
 //	"rotate":true,
-//  	"perm":0600
+//  	"perm":"0600"
 //	}
 func (w *fileLogWriter) Init(jsonConfig string) error {
 	err := json.Unmarshal([]byte(jsonConfig), w)
@@ -128,7 +127,9 @@ func (w *fileLogWriter) WriteMsg(when time.Time, msg string, level int) error {
 	h, d := formatTimeHeader(when)
 	msg = string(h) + msg + "\n"
 	if w.Rotate {
+		w.RLock()
 		if w.needRotate(len(msg), d) {
+			w.RUnlock()
 			w.Lock()
 			if w.needRotate(len(msg), d) {
 				if err := w.doRotate(when); err != nil {
@@ -136,6 +137,8 @@ func (w *fileLogWriter) WriteMsg(when time.Time, msg string, level int) error {
 				}
 			}
 			w.Unlock()
+		} else {
+			w.RUnlock()
 		}
 	}
 
@@ -151,7 +154,15 @@ func (w *fileLogWriter) WriteMsg(when time.Time, msg string, level int) error {
 
 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, w.Perm)
+	perm, err := strconv.ParseInt(w.Perm, 8, 64)
+	if err != nil {
+		return nil, err
+	}
+	fd, err := os.OpenFile(w.Filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, os.FileMode(perm))
+	if err == nil {
+		// Make sure file perm is user set perm cause of `os.OpenFile` will obey umask
+		os.Chmod(w.Filename, os.FileMode(perm))
+	}
 	return fd, err
 }
 
@@ -162,8 +173,12 @@ func (w *fileLogWriter) initFd() error {
 		return fmt.Errorf("get stat err: %s\n", err)
 	}
 	w.maxSizeCurSize = int(fInfo.Size())
-	w.dailyOpenDate = time.Now().Day()
+	w.dailyOpenTime = time.Now()
+	w.dailyOpenDate = w.dailyOpenTime.Day()
 	w.maxLinesCurLines = 0
+	if w.Daily {
+		go w.dailyRotate(w.dailyOpenTime)
+	}
 	if fInfo.Size() > 0 {
 		count, err := w.lines()
 		if err != nil {
@@ -174,6 +189,22 @@ func (w *fileLogWriter) initFd() error {
 	return nil
 }
 
+func (w *fileLogWriter) dailyRotate(openTime time.Time) {
+	y, m, d := openTime.Add(24 * time.Hour).Date()
+	nextDay := time.Date(y, m, d, 0, 0, 0, 0, openTime.Location())
+	tm := time.NewTimer(time.Duration(nextDay.UnixNano() - openTime.UnixNano() + 100))
+	select {
+	case <-tm.C:
+		w.Lock()
+		if w.needRotate(0, time.Now().Day()) {
+			if err := w.doRotate(time.Now()); err != nil {
+				fmt.Fprintf(os.Stderr, "FileLogWriter(%q): %s\n", w.Filename, err)
+			}
+		}
+		w.Unlock()
+	}
+}
+
 func (w *fileLogWriter) lines() (int, error) {
 	fd, err := os.Open(w.Filename)
 	if err != nil {
@@ -204,22 +235,29 @@ func (w *fileLogWriter) lines() (int, error) {
 // DoRotate means it need to write file in new file.
 // new file name like xx.2013-01-01.log (daily) or xx.001.log (by line or size)
 func (w *fileLogWriter) doRotate(logTime time.Time) error {
-	_, err := os.Lstat(w.Filename)
-	if err != nil {
-		return err
-	}
 	// file exists
 	// Find the next available number
 	num := 1
 	fName := ""
+
+	_, err := os.Lstat(w.Filename)
+	if err != nil {
+		//even if the file is not exist or other ,we should RESTART the logger
+		goto RESTART_LOGGER
+	}
+
 	if w.MaxLines > 0 || w.MaxSize > 0 {
 		for ; err == nil && num <= 999; num++ {
 			fName = w.fileNameOnly + fmt.Sprintf(".%s.%03d%s", logTime.Format("2006-01-02"), num, w.suffix)
 			_, err = os.Lstat(fName)
 		}
 	} else {
-		fName = fmt.Sprintf("%s.%s%s", w.fileNameOnly, logTime.Format("2006-01-02"), w.suffix)
+		fName = fmt.Sprintf("%s.%s%s", w.fileNameOnly, w.dailyOpenTime.Format("2006-01-02"), w.suffix)
 		_, err = os.Lstat(fName)
+		for ; err == nil && num <= 999; num++ {
+			fName = w.fileNameOnly + fmt.Sprintf(".%s.%03d%s", w.dailyOpenTime.Format("2006-01-02"), num, w.suffix)
+			_, err = os.Lstat(fName)
+		}
 	}
 	// return error if the last file checked still existed
 	if err == nil {
@@ -231,16 +269,19 @@ func (w *fileLogWriter) doRotate(logTime time.Time) error {
 
 	// Rename the file to its new found name
 	// even if occurs error,we MUST guarantee to  restart new logger
-	renameErr := os.Rename(w.Filename, fName)
+	err = os.Rename(w.Filename, fName)
+	err = os.Chmod(fName, os.FileMode(440))
 	// re-start logger
+RESTART_LOGGER:
+
 	startLoggerErr := w.startLogger()
 	go w.deleteOldLog()
 
 	if startLoggerErr != nil {
 		return fmt.Errorf("Rotate StartLogger: %s\n", startLoggerErr)
 	}
-	if renameErr != nil {
+	if err != nil {
-		return fmt.Errorf("Rotate: %s\n", renameErr)
+		return fmt.Errorf("Rotate: %s\n", err)
 	}
 	return nil
 
@@ -255,8 +296,12 @@ func (w *fileLogWriter) deleteOldLog() {
 			}
 		}()
 
-		if !info.IsDir() && info.ModTime().Unix() < (time.Now().Unix()-60*60*24*w.MaxDays) {
+		if info == nil {
-			if strings.HasPrefix(filepath.Base(path), w.fileNameOnly) &&
+			return
+		}
+
+		if !info.IsDir() && info.ModTime().Add(24*time.Hour*time.Duration(w.MaxDays)).Before(time.Now()) {
+			if strings.HasPrefix(filepath.Base(path), filepath.Base(w.fileNameOnly)) &&
 				strings.HasSuffix(filepath.Base(path), w.suffix) {
 				os.Remove(path)
 			}
@@ -278,5 +323,5 @@ func (w *fileLogWriter) Flush() {
 }
 
 func init() {
-	Register("file", newFileWriter)
+	Register(AdapterFile, newFileWriter)
 }

logs/file_test.go

@@ -17,12 +17,35 @@ package logs
 import (
 	"bufio"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"strconv"
 	"testing"
 	"time"
 )
 
+func TestFilePerm(t *testing.T) {
+	log := NewLogger(10000)
+	// use 0666 as test perm cause the default umask is 022
+	log.SetLogger("file", `{"filename":"test.log", "perm": "0666"}`)
+	log.Debug("debug")
+	log.Informational("info")
+	log.Notice("notice")
+	log.Warning("warning")
+	log.Error("error")
+	log.Alert("alert")
+	log.Critical("critical")
+	log.Emergency("emergency")
+	file, err := os.Stat("test.log")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if file.Mode() != 0666 {
+		t.Fatal("unexpected log file permission")
+	}
+	os.Remove("test.log")
+}
+
 func TestFile1(t *testing.T) {
 	log := NewLogger(10000)
 	log.SetLogger("file", `{"filename":"test.log"}`)
@@ -89,7 +112,7 @@ func TestFile2(t *testing.T) {
 	os.Remove("test2.log")
 }
 
-func TestFileRotate(t *testing.T) {
+func TestFileRotate_01(t *testing.T) {
 	log := NewLogger(10000)
 	log.SetLogger("file", `{"filename":"test3.log","maxlines":4}`)
 	log.Debug("debug")
@@ -110,6 +133,90 @@ func TestFileRotate(t *testing.T) {
 	os.Remove("test3.log")
 }
 
+func TestFileRotate_02(t *testing.T) {
+	fn1 := "rotate_day.log"
+	fn2 := "rotate_day." + time.Now().Add(-24*time.Hour).Format("2006-01-02") + ".log"
+	testFileRotate(t, fn1, fn2)
+}
+
+func TestFileRotate_03(t *testing.T) {
+	fn1 := "rotate_day.log"
+	fn := "rotate_day." + time.Now().Add(-24*time.Hour).Format("2006-01-02") + ".log"
+	os.Create(fn)
+	fn2 := "rotate_day." + time.Now().Add(-24*time.Hour).Format("2006-01-02") + ".001.log"
+	testFileRotate(t, fn1, fn2)
+	os.Remove(fn)
+}
+
+func TestFileRotate_04(t *testing.T) {
+	fn1 := "rotate_day.log"
+	fn2 := "rotate_day." + time.Now().Add(-24*time.Hour).Format("2006-01-02") + ".log"
+	testFileDailyRotate(t, fn1, fn2)
+}
+
+func TestFileRotate_05(t *testing.T) {
+	fn1 := "rotate_day.log"
+	fn := "rotate_day." + time.Now().Add(-24*time.Hour).Format("2006-01-02") + ".log"
+	os.Create(fn)
+	fn2 := "rotate_day." + time.Now().Add(-24*time.Hour).Format("2006-01-02") + ".001.log"
+	testFileDailyRotate(t, fn1, fn2)
+	os.Remove(fn)
+}
+
+func testFileRotate(t *testing.T, fn1, fn2 string) {
+	fw := &fileLogWriter{
+		Daily:   true,
+		MaxDays: 7,
+		Rotate:  true,
+		Level:   LevelTrace,
+		Perm:    "0660",
+	}
+	fw.Init(fmt.Sprintf(`{"filename":"%v","maxdays":1}`, fn1))
+	fw.dailyOpenTime = time.Now().Add(-24 * time.Hour)
+	fw.dailyOpenDate = fw.dailyOpenTime.Day()
+	fw.WriteMsg(time.Now(), "this is a msg for test", LevelDebug)
+
+	for _, file := range []string{fn1, fn2} {
+		_, err := os.Stat(file)
+		if err != nil {
+			t.FailNow()
+		}
+		os.Remove(file)
+	}
+	fw.Destroy()
+}
+
+func testFileDailyRotate(t *testing.T, fn1, fn2 string) {
+	fw := &fileLogWriter{
+		Daily:   true,
+		MaxDays: 7,
+		Rotate:  true,
+		Level:   LevelTrace,
+		Perm:    "0660",
+	}
+	fw.Init(fmt.Sprintf(`{"filename":"%v","maxdays":1}`, fn1))
+	fw.dailyOpenTime = time.Now().Add(-24 * time.Hour)
+	fw.dailyOpenDate = fw.dailyOpenTime.Day()
+	today, _ := time.ParseInLocation("2006-01-02", time.Now().Format("2006-01-02"), fw.dailyOpenTime.Location())
+	today = today.Add(-1 * time.Second)
+	fw.dailyRotate(today)
+	for _, file := range []string{fn1, fn2} {
+		_, err := os.Stat(file)
+		if err != nil {
+			t.FailNow()
+		}
+		content, err := ioutil.ReadFile(file)
+		if err != nil {
+			t.FailNow()
+		}
+		if len(content) > 0 {
+			t.FailNow()
+		}
+		os.Remove(file)
+	}
+	fw.Destroy()
+}
+
 func exists(path string) (bool, error) {
 	_, err := os.Stat(path)
 	if err == nil {

logs/jianliao.go

@@ -0,0 +1,78 @@
+package logs
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// JLWriter implements beego LoggerInterface and is used to send jiaoliao webhook
+type JLWriter struct {
+	AuthorName  string `json:"authorname"`
+	Title       string `json:"title"`
+	WebhookURL  string `json:"webhookurl"`
+	RedirectURL string `json:"redirecturl,omitempty"`
+	ImageURL    string `json:"imageurl,omitempty"`
+	Level       int    `json:"level"`
+}
+
+// newJLWriter create jiaoliao writer.
+func newJLWriter() Logger {
+	return &JLWriter{Level: LevelTrace}
+}
+
+// Init JLWriter with json config string
+func (s *JLWriter) Init(jsonconfig string) error {
+	err := json.Unmarshal([]byte(jsonconfig), s)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// WriteMsg write message in smtp writer.
+// it will send an email with subject and only this message.
+func (s *JLWriter) WriteMsg(when time.Time, msg string, level int) error {
+	if level > s.Level {
+		return nil
+	}
+
+	text := fmt.Sprintf("%s %s", when.Format("2006-01-02 15:04:05"), msg)
+
+	form := url.Values{}
+	form.Add("authorName", s.AuthorName)
+	form.Add("title", s.Title)
+	form.Add("text", text)
+	if s.RedirectURL != "" {
+		form.Add("redirectUrl", s.RedirectURL)
+	}
+	if s.ImageURL != "" {
+		form.Add("imageUrl", s.ImageURL)
+	}
+
+	resp, err := http.PostForm(s.WebhookURL, form)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("Post webhook failed %s %d", resp.Status, resp.StatusCode)
+	}
+	return nil
+}
+
+// Flush implementing method. empty.
+func (s *JLWriter) Flush() {
+	return
+}
+
+// Destroy implementing method. empty.
+func (s *JLWriter) Destroy() {
+	return
+}
+
+func init() {
+	Register(AdapterJianLiao, newJLWriter)
+}

logs/log.go

@@ -35,10 +35,12 @@ package logs
 
 import (
 	"fmt"
+	"log"
 	"os"
 	"path"
 	"runtime"
 	"strconv"
+	"strings"
 	"sync"
 	"time"
 )
@@ -55,16 +57,31 @@ const (
 	LevelDebug
 )
 
+// levelLogLogger is defined to implement log.Logger
+// the real log level will be LevelEmergency
+const levelLoggerImpl = -1
+
+// Name for adapter with beego official support
+const (
+	AdapterConsole   = "console"
+	AdapterFile      = "file"
+	AdapterMultiFile = "multifile"
+	AdapterMail      = "smtp"
+	AdapterConn      = "conn"
+	AdapterEs        = "es"
+	AdapterJianLiao  = "jianliao"
+	AdapterSlack     = "slack"
+	AdapterAliLS     = "alils"
+)
+
 // Legacy log level constants to ensure backwards compatibility.
-//
-// Deprecated: will be removed in 1.5.0.
 const (
 	LevelInfo  = LevelInformational
 	LevelTrace = LevelDebug
 	LevelWarn  = LevelWarning
 )
 
-type loggerType func() Logger
+type newLoggerFunc func() Logger
 
 // Logger defines the behavior of a log provider.
 type Logger interface {
@@ -74,12 +91,13 @@ type Logger interface {
 	Flush()
 }
 
-var adapters = make(map[string]loggerType)
+var adapters = make(map[string]newLoggerFunc)
+var levelPrefix = [LevelDebug + 1]string{"[M] ", "[A] ", "[C] ", "[E] ", "[W] ", "[N] ", "[I] ", "[D] "}
 
 // 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) {
+func Register(name string, log newLoggerFunc) {
 	if log == nil {
 		panic("logs: Register provide is nil")
 	}
@@ -94,15 +112,19 @@ func Register(name string, log loggerType) {
 type BeeLogger struct {
 	lock                sync.Mutex
 	level               int
+	init                bool
 	enableFuncCallDepth bool
 	loggerFuncCallDepth int
 	asynchronous        bool
+	msgChanLen          int64
 	msgChan             chan *logMsg
 	signalChan          chan string
 	wg                  sync.WaitGroup
 	outputs             []*nameLogger
 }
 
+const defaultAsyncMsgLen = 1e3
+
 type nameLogger struct {
 	Logger
 	name string
@@ -119,18 +141,31 @@ var logMsgPool *sync.Pool
 // NewLogger returns a new BeeLogger.
 // channelLen means the number of messages in chan(used where asynchronous is true).
 // if the buffering chan is full, logger adapters write to file or other way.
-func NewLogger(channelLen int64) *BeeLogger {
+func NewLogger(channelLens ...int64) *BeeLogger {
 	bl := new(BeeLogger)
 	bl.level = LevelDebug
 	bl.loggerFuncCallDepth = 2
-	bl.msgChan = make(chan *logMsg, channelLen)
+	bl.msgChanLen = append(channelLens, 0)[0]
+	if bl.msgChanLen <= 0 {
+		bl.msgChanLen = defaultAsyncMsgLen
+	}
 	bl.signalChan = make(chan string, 1)
+	bl.setLogger(AdapterConsole)
 	return bl
 }
 
 // Async set the log to asynchronous and start the goroutine
-func (bl *BeeLogger) Async() *BeeLogger {
+func (bl *BeeLogger) Async(msgLen ...int64) *BeeLogger {
+	bl.lock.Lock()
+	defer bl.lock.Unlock()
+	if bl.asynchronous {
+		return bl
+	}
 	bl.asynchronous = true
+	if len(msgLen) > 0 && msgLen[0] > 0 {
+		bl.msgChanLen = msgLen[0]
+	}
+	bl.msgChan = make(chan *logMsg, bl.msgChanLen)
 	logMsgPool = &sync.Pool{
 		New: func() interface{} {
 			return &logMsg{}
@@ -143,10 +178,8 @@ func (bl *BeeLogger) Async() *BeeLogger {
 
 // 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 {
+func (bl *BeeLogger) setLogger(adapterName string, configs ...string) error {
-	bl.lock.Lock()
+	config := append(configs, "{}")[0]
-	defer bl.lock.Unlock()
-
 	for _, l := range bl.outputs {
 		if l.name == adapterName {
 			return fmt.Errorf("logs: duplicate adaptername %q (you have set this logger before)", adapterName)
@@ -168,6 +201,18 @@ func (bl *BeeLogger) SetLogger(adapterName string, config string) error {
 	return nil
 }
 
+// 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, configs ...string) error {
+	bl.lock.Lock()
+	defer bl.lock.Unlock()
+	if !bl.init {
+		bl.outputs = []*nameLogger{}
+		bl.init = true
+	}
+	return bl.setLogger(adapterName, configs...)
+}
+
 // DelLogger remove a logger adapter in BeeLogger.
 func (bl *BeeLogger) DelLogger(adapterName string) error {
 	bl.lock.Lock()
@@ -196,7 +241,32 @@ func (bl *BeeLogger) writeToLoggers(when time.Time, msg string, level int) {
 	}
 }
 
-func (bl *BeeLogger) writeMsg(logLevel int, msg string) error {
+func (bl *BeeLogger) Write(p []byte) (n int, err error) {
+	if len(p) == 0 {
+		return 0, nil
+	}
+	// writeMsg will always add a '\n' character
+	if p[len(p)-1] == '\n' {
+		p = p[0 : len(p)-1]
+	}
+	// set levelLoggerImpl to ensure all log message will be write out
+	err = bl.writeMsg(levelLoggerImpl, string(p))
+	if err == nil {
+		return len(p), err
+	}
+	return 0, err
+}
+
+func (bl *BeeLogger) writeMsg(logLevel int, msg string, v ...interface{}) error {
+	if !bl.init {
+		bl.lock.Lock()
+		bl.setLogger(AdapterConsole)
+		bl.lock.Unlock()
+	}
+
+	if len(v) > 0 {
+		msg = fmt.Sprintf(msg, v...)
+	}
 	when := time.Now()
 	if bl.enableFuncCallDepth {
 		_, file, line, ok := runtime.Caller(bl.loggerFuncCallDepth)
@@ -207,6 +277,15 @@ func (bl *BeeLogger) writeMsg(logLevel int, msg string) error {
 		_, filename := path.Split(file)
 		msg = "[" + filename + ":" + strconv.FormatInt(int64(line), 10) + "] " + msg
 	}
+
+	//set level info in front of filename info
+	if logLevel == levelLoggerImpl {
+		// set to emergency to ensure all log will be print out correctly
+		logLevel = LevelEmergency
+	} else {
+		msg = levelPrefix[logLevel] + msg
+	}
+
 	if bl.asynchronous {
 		lm := logMsgPool.Get().(*logMsg)
 		lm.level = logLevel
@@ -273,8 +352,7 @@ func (bl *BeeLogger) Emergency(format string, v ...interface{}) {
 	if LevelEmergency > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[M] "+format, v...)
+	bl.writeMsg(LevelEmergency, format, v...)
-	bl.writeMsg(LevelEmergency, msg)
 }
 
 // Alert Log ALERT level message.
@@ -282,8 +360,7 @@ func (bl *BeeLogger) Alert(format string, v ...interface{}) {
 	if LevelAlert > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[A] "+format, v...)
+	bl.writeMsg(LevelAlert, format, v...)
-	bl.writeMsg(LevelAlert, msg)
 }
 
 // Critical Log CRITICAL level message.
@@ -291,8 +368,7 @@ func (bl *BeeLogger) Critical(format string, v ...interface{}) {
 	if LevelCritical > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[C] "+format, v...)
+	bl.writeMsg(LevelCritical, format, v...)
-	bl.writeMsg(LevelCritical, msg)
 }
 
 // Error Log ERROR level message.
@@ -300,17 +376,15 @@ func (bl *BeeLogger) Error(format string, v ...interface{}) {
 	if LevelError > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[E] "+format, v...)
+	bl.writeMsg(LevelError, format, v...)
-	bl.writeMsg(LevelError, msg)
 }
 
 // Warning Log WARNING level message.
 func (bl *BeeLogger) Warning(format string, v ...interface{}) {
-	if LevelWarning > bl.level {
+	if LevelWarn > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[W] "+format, v...)
+	bl.writeMsg(LevelWarn, format, v...)
-	bl.writeMsg(LevelWarning, msg)
 }
 
 // Notice Log NOTICE level message.
@@ -318,17 +392,15 @@ func (bl *BeeLogger) Notice(format string, v ...interface{}) {
 	if LevelNotice > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[N] "+format, v...)
+	bl.writeMsg(LevelNotice, format, v...)
-	bl.writeMsg(LevelNotice, msg)
 }
 
 // Informational Log INFORMATIONAL level message.
 func (bl *BeeLogger) Informational(format string, v ...interface{}) {
-	if LevelInformational > bl.level {
+	if LevelInfo > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[I] "+format, v...)
+	bl.writeMsg(LevelInfo, format, v...)
-	bl.writeMsg(LevelInformational, msg)
 }
 
 // Debug Log DEBUG level message.
@@ -336,28 +408,25 @@ func (bl *BeeLogger) Debug(format string, v ...interface{}) {
 	if LevelDebug > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[D] "+format, v...)
+	bl.writeMsg(LevelDebug, format, v...)
-	bl.writeMsg(LevelDebug, msg)
 }
 
 // Warn Log WARN level message.
 // compatibility alias for Warning()
 func (bl *BeeLogger) Warn(format string, v ...interface{}) {
-	if LevelWarning > bl.level {
+	if LevelWarn > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[W] "+format, v...)
+	bl.writeMsg(LevelWarn, format, v...)
-	bl.writeMsg(LevelWarning, msg)
 }
 
 // Info Log INFO level message.
 // compatibility alias for Informational()
 func (bl *BeeLogger) Info(format string, v ...interface{}) {
-	if LevelInformational > bl.level {
+	if LevelInfo > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[I] "+format, v...)
+	bl.writeMsg(LevelInfo, format, v...)
-	bl.writeMsg(LevelInformational, msg)
 }
 
 // Trace Log TRACE level message.
@@ -366,8 +435,7 @@ func (bl *BeeLogger) Trace(format string, v ...interface{}) {
 	if LevelDebug > bl.level {
 		return
 	}
-	msg := fmt.Sprintf("[D] "+format, v...)
+	bl.writeMsg(LevelDebug, format, v...)
-	bl.writeMsg(LevelDebug, msg)
 }
 
 // Flush flush all chan data.
@@ -386,6 +454,7 @@ func (bl *BeeLogger) Close() {
 	if bl.asynchronous {
 		bl.signalChan <- "close"
 		bl.wg.Wait()
+		close(bl.msgChan)
 	} else {
 		bl.flush()
 		for _, l := range bl.outputs {
@@ -393,7 +462,6 @@ func (bl *BeeLogger) Close() {
 		}
 		bl.outputs = nil
 	}
-	close(bl.msgChan)
 	close(bl.signalChan)
 }
 
@@ -407,6 +475,7 @@ func (bl *BeeLogger) Reset() {
 }
 
 func (bl *BeeLogger) flush() {
+	if bl.asynchronous {
 		for {
 			if len(bl.msgChan) > 0 {
 				bm := <-bl.msgChan
@@ -416,7 +485,165 @@ func (bl *BeeLogger) flush() {
 			}
 			break
 		}
+	}
 	for _, l := range bl.outputs {
 		l.Flush()
 	}
 }
+
+// beeLogger references the used application logger.
+var beeLogger *BeeLogger = NewLogger()
+
+// GetLogger returns the default BeeLogger
+func GetBeeLogger() *BeeLogger {
+	return beeLogger
+}
+
+var beeLoggerMap = struct {
+	sync.RWMutex
+	logs map[string]*log.Logger
+}{
+	logs: map[string]*log.Logger{},
+}
+
+// GetLogger returns the default BeeLogger
+func GetLogger(prefixes ...string) *log.Logger {
+	prefix := append(prefixes, "")[0]
+	if prefix != "" {
+		prefix = fmt.Sprintf(`[%s] `, strings.ToUpper(prefix))
+	}
+	beeLoggerMap.RLock()
+	l, ok := beeLoggerMap.logs[prefix]
+	if ok {
+		beeLoggerMap.RUnlock()
+		return l
+	}
+	beeLoggerMap.RUnlock()
+	beeLoggerMap.Lock()
+	defer beeLoggerMap.Unlock()
+	l, ok = beeLoggerMap.logs[prefix]
+	if !ok {
+		l = log.New(beeLogger, prefix, 0)
+		beeLoggerMap.logs[prefix] = l
+	}
+	return l
+}
+
+// Reset will remove all the adapter
+func Reset() {
+	beeLogger.Reset()
+}
+
+func Async(msgLen ...int64) *BeeLogger {
+	return beeLogger.Async(msgLen...)
+}
+
+// SetLevel sets the global log level used by the simple logger.
+func SetLevel(l int) {
+	beeLogger.SetLevel(l)
+}
+
+// EnableFuncCallDepth enable log funcCallDepth
+func EnableFuncCallDepth(b bool) {
+	beeLogger.enableFuncCallDepth = b
+}
+
+// SetLogFuncCall set the CallDepth, default is 4
+func SetLogFuncCall(b bool) {
+	beeLogger.EnableFuncCallDepth(b)
+	beeLogger.SetLogFuncCallDepth(4)
+}
+
+// SetLogFuncCallDepth set log funcCallDepth
+func SetLogFuncCallDepth(d int) {
+	beeLogger.loggerFuncCallDepth = d
+}
+
+// SetLogger sets a new logger.
+func SetLogger(adapter string, config ...string) error {
+	err := beeLogger.SetLogger(adapter, config...)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Emergency logs a message at emergency level.
+func Emergency(f interface{}, v ...interface{}) {
+	beeLogger.Emergency(formatLog(f, v...))
+}
+
+// Alert logs a message at alert level.
+func Alert(f interface{}, v ...interface{}) {
+	beeLogger.Alert(formatLog(f, v...))
+}
+
+// Critical logs a message at critical level.
+func Critical(f interface{}, v ...interface{}) {
+	beeLogger.Critical(formatLog(f, v...))
+}
+
+// Error logs a message at error level.
+func Error(f interface{}, v ...interface{}) {
+	beeLogger.Error(formatLog(f, v...))
+}
+
+// Warning logs a message at warning level.
+func Warning(f interface{}, v ...interface{}) {
+	beeLogger.Warn(formatLog(f, v...))
+}
+
+// Warn compatibility alias for Warning()
+func Warn(f interface{}, v ...interface{}) {
+	beeLogger.Warn(formatLog(f, v...))
+}
+
+// Notice logs a message at notice level.
+func Notice(f interface{}, v ...interface{}) {
+	beeLogger.Notice(formatLog(f, v...))
+}
+
+// Informational logs a message at info level.
+func Informational(f interface{}, v ...interface{}) {
+	beeLogger.Info(formatLog(f, v...))
+}
+
+// Info compatibility alias for Warning()
+func Info(f interface{}, v ...interface{}) {
+	beeLogger.Info(formatLog(f, v...))
+}
+
+// Debug logs a message at debug level.
+func Debug(f interface{}, v ...interface{}) {
+	beeLogger.Debug(formatLog(f, v...))
+}
+
+// Trace logs a message at trace level.
+// compatibility alias for Warning()
+func Trace(f interface{}, v ...interface{}) {
+	beeLogger.Trace(formatLog(f, v...))
+}
+
+func formatLog(f interface{}, v ...interface{}) string {
+	var msg string
+	switch f.(type) {
+	case string:
+		msg = f.(string)
+		if len(v) == 0 {
+			return msg
+		}
+		if strings.Contains(msg, "%") && !strings.Contains(msg, "%%") {
+			//format string
+		} else {
+			//do not contain format char
+			msg += strings.Repeat(" %v", len(v))
+		}
+	default:
+		msg = fmt.Sprint(f)
+		if len(v) == 0 {
+			return msg
+		}
+		msg += strings.Repeat(" %v", len(v))
+	}
+	return fmt.Sprintf(msg, v...)
+}

logs/logger.go

@@ -12,11 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-
 package logs
 
 import (
+	"fmt"
 	"io"
+	"os"
 	"sync"
 	"time"
 )
@@ -37,44 +38,151 @@ func (lg *logWriter) println(when time.Time, msg string) {
 	lg.Unlock()
 }
 
+type outputMode int
+
+// DiscardNonColorEscSeq supports the divided color escape sequence.
+// But non-color escape sequence is not output.
+// Please use the OutputNonColorEscSeq If you want to output a non-color
+// escape sequences such as ncurses. However, it does not support the divided
+// color escape sequence.
+const (
+	_ outputMode = iota
+	DiscardNonColorEscSeq
+	OutputNonColorEscSeq
+)
+
+// NewAnsiColorWriter creates and initializes a new ansiColorWriter
+// using io.Writer w as its initial contents.
+// In the console of Windows, which change the foreground and background
+// colors of the text by the escape sequence.
+// In the console of other systems, which writes to w all text.
+func NewAnsiColorWriter(w io.Writer) io.Writer {
+	return NewModeAnsiColorWriter(w, DiscardNonColorEscSeq)
+}
+
+// NewModeAnsiColorWriter create and initializes a new ansiColorWriter
+// by specifying the outputMode.
+func NewModeAnsiColorWriter(w io.Writer, mode outputMode) io.Writer {
+	if _, ok := w.(*ansiColorWriter); !ok {
+		return &ansiColorWriter{
+			w:    w,
+			mode: mode,
+		}
+	}
+	return w
+}
+
+const (
+	y1  = `0123456789`
+	y2  = `0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789`
+	y3  = `0000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999`
+	y4  = `0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789`
+	mo1 = `000000000111`
+	mo2 = `123456789012`
+	d1  = `0000000001111111111222222222233`
+	d2  = `1234567890123456789012345678901`
+	h1  = `000000000011111111112222`
+	h2  = `012345678901234567890123`
+	mi1 = `000000000011111111112222222222333333333344444444445555555555`
+	mi2 = `012345678901234567890123456789012345678901234567890123456789`
+	s1  = `000000000011111111112222222222333333333344444444445555555555`
+	s2  = `012345678901234567890123456789012345678901234567890123456789`
+)
+
 func formatTimeHeader(when time.Time) ([]byte, int) {
 	y, mo, d := when.Date()
 	h, mi, s := when.Clock()
-	//len(2006/01/02 15:03:04)==19
+	//len("2006/01/02 15:04:05 ")==20
 	var buf [20]byte
-	t := 3
+
-	for y >= 10 {
+	buf[0] = y1[y/1000%10]
-		p := y / 10
+	buf[1] = y2[y/100]
-		buf[t] = byte('0' + y - p*10)
+	buf[2] = y3[y-y/100*100]
-		y = p
+	buf[3] = y4[y-y/100*100]
-		t--
-	}
-	buf[0] = byte('0' + y)
 	buf[4] = '/'
-	if mo > 9 {
+	buf[5] = mo1[mo-1]
-		buf[5] = '1'
+	buf[6] = mo2[mo-1]
-		buf[6] = byte('0' + mo - 9)
-	} else {
-		buf[5] = '0'
-		buf[6] = byte('0' + mo)
-	}
 	buf[7] = '/'
-	t = d / 10
+	buf[8] = d1[d-1]
-	buf[8] = byte('0' + t)
+	buf[9] = d2[d-1]
-	buf[9] = byte('0' + d - t*10)
 	buf[10] = ' '
-	t = h / 10
+	buf[11] = h1[h]
-	buf[11] = byte('0' + t)
+	buf[12] = h2[h]
-	buf[12] = byte('0' + h - t*10)
 	buf[13] = ':'
-	t = mi / 10
+	buf[14] = mi1[mi]
-	buf[14] = byte('0' + t)
+	buf[15] = mi2[mi]
-	buf[15] = byte('0' + mi - t*10)
 	buf[16] = ':'
-	t = s / 10
+	buf[17] = s1[s]
-	buf[17] = byte('0' + t)
+	buf[18] = s2[s]
-	buf[18] = byte('0' + s - t*10)
 	buf[19] = ' '
 
 	return buf[0:], d
 }
+
+var (
+	green   = string([]byte{27, 91, 57, 55, 59, 52, 50, 109})
+	white   = string([]byte{27, 91, 57, 48, 59, 52, 55, 109})
+	yellow  = string([]byte{27, 91, 57, 55, 59, 52, 51, 109})
+	red     = string([]byte{27, 91, 57, 55, 59, 52, 49, 109})
+	blue    = string([]byte{27, 91, 57, 55, 59, 52, 52, 109})
+	magenta = string([]byte{27, 91, 57, 55, 59, 52, 53, 109})
+	cyan    = string([]byte{27, 91, 57, 55, 59, 52, 54, 109})
+
+	w32Green   = string([]byte{27, 91, 52, 50, 109})
+	w32White   = string([]byte{27, 91, 52, 55, 109})
+	w32Yellow  = string([]byte{27, 91, 52, 51, 109})
+	w32Red     = string([]byte{27, 91, 52, 49, 109})
+	w32Blue    = string([]byte{27, 91, 52, 52, 109})
+	w32Magenta = string([]byte{27, 91, 52, 53, 109})
+	w32Cyan    = string([]byte{27, 91, 52, 54, 109})
+
+	reset = string([]byte{27, 91, 48, 109})
+)
+
+func ColorByStatus(cond bool, code int) string {
+	switch {
+	case code >= 200 && code < 300:
+		return map[bool]string{true: green, false: w32Green}[cond]
+	case code >= 300 && code < 400:
+		return map[bool]string{true: white, false: w32White}[cond]
+	case code >= 400 && code < 500:
+		return map[bool]string{true: yellow, false: w32Yellow}[cond]
+	default:
+		return map[bool]string{true: red, false: w32Red}[cond]
+	}
+}
+
+func ColorByMethod(cond bool, method string) string {
+	switch method {
+	case "GET":
+		return map[bool]string{true: blue, false: w32Blue}[cond]
+	case "POST":
+		return map[bool]string{true: cyan, false: w32Cyan}[cond]
+	case "PUT":
+		return map[bool]string{true: yellow, false: w32Yellow}[cond]
+	case "DELETE":
+		return map[bool]string{true: red, false: w32Red}[cond]
+	case "PATCH":
+		return map[bool]string{true: green, false: w32Green}[cond]
+	case "HEAD":
+		return map[bool]string{true: magenta, false: w32Magenta}[cond]
+	case "OPTIONS":
+		return map[bool]string{true: white, false: w32White}[cond]
+	default:
+		return reset
+	}
+}
+
+// Guard Mutex to guarantee atomicity of W32Debug(string) function
+var mu sync.Mutex
+
+// Helper method to output colored logs in Windows terminals
+func W32Debug(msg string) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	current := time.Now()
+	w := NewAnsiColorWriter(os.Stdout)
+
+	fmt.Fprintf(w, "[beego] %v %s\n", current.Format("2006/01/02 - 15:04:05"), msg)
+}

logs/logger_test.go

@@ -0,0 +1,75 @@
+// Copyright 2016 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"
+	"testing"
+	"time"
+)
+
+func TestFormatHeader_0(t *testing.T) {
+	tm := time.Now()
+	if tm.Year() >= 2100 {
+		t.FailNow()
+	}
+	dur := time.Second
+	for {
+		if tm.Year() >= 2100 {
+			break
+		}
+		h, _ := formatTimeHeader(tm)
+		if tm.Format("2006/01/02 15:04:05 ") != string(h) {
+			t.Log(tm)
+			t.FailNow()
+		}
+		tm = tm.Add(dur)
+		dur *= 2
+	}
+}
+
+func TestFormatHeader_1(t *testing.T) {
+	tm := time.Now()
+	year := tm.Year()
+	dur := time.Second
+	for {
+		if tm.Year() >= year+1 {
+			break
+		}
+		h, _ := formatTimeHeader(tm)
+		if tm.Format("2006/01/02 15:04:05 ") != string(h) {
+			t.Log(tm)
+			t.FailNow()
+		}
+		tm = tm.Add(dur)
+	}
+}
+
+func TestNewAnsiColor1(t *testing.T) {
+	inner := bytes.NewBufferString("")
+	w := NewAnsiColorWriter(inner)
+	if w == inner {
+		t.Errorf("Get %#v, want %#v", w, inner)
+	}
+}
+
+func TestNewAnsiColor2(t *testing.T) {
+	inner := bytes.NewBufferString("")
+	w1 := NewAnsiColorWriter(inner)
+	w2 := NewAnsiColorWriter(w1)
+	if w1 != w2 {
+		t.Errorf("Get %#v, want %#v", w1, w2)
+	}
+}

logs/multifile.go

@@ -112,5 +112,5 @@ func newFilesWriter() Logger {
 }
 
 func init() {
-	Register("multifile", newFilesWriter)
+	Register(AdapterMultiFile, newFilesWriter)
 }

logs/slack.go

@@ -0,0 +1,66 @@
+package logs
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// SLACKWriter implements beego LoggerInterface and is used to send jiaoliao webhook
+type SLACKWriter struct {
+	WebhookURL string `json:"webhookurl"`
+	Level      int    `json:"level"`
+}
+
+// newSLACKWriter create jiaoliao writer.
+func newSLACKWriter() Logger {
+	return &SLACKWriter{Level: LevelTrace}
+}
+
+// Init SLACKWriter with json config string
+func (s *SLACKWriter) Init(jsonconfig string) error {
+	err := json.Unmarshal([]byte(jsonconfig), s)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// WriteMsg write message in smtp writer.
+// it will send an email with subject and only this message.
+func (s *SLACKWriter) WriteMsg(when time.Time, msg string, level int) error {
+	if level > s.Level {
+		return nil
+	}
+
+	text := fmt.Sprintf("{\"text\": \"%s %s\"}", when.Format("2006-01-02 15:04:05"), msg)
+
+	form := url.Values{}
+	form.Add("payload", text)
+
+	resp, err := http.PostForm(s.WebhookURL, form)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("Post webhook failed %s %d", resp.Status, resp.StatusCode)
+	}
+	return nil
+}
+
+// Flush implementing method. empty.
+func (s *SLACKWriter) Flush() {
+	return
+}
+
+// Destroy implementing method. empty.
+func (s *SLACKWriter) Destroy() {
+	return
+}
+
+func init() {
+	Register(AdapterSlack, newSLACKWriter)
+}

logs/smtp.go

@@ -156,5 +156,5 @@ func (s *SMTPWriter) Destroy() {
 }
 
 func init() {
-	Register("smtp", newSMTPWriter)
+	Register(AdapterMail, newSMTPWriter)
 }

migration/migration.go

@@ -33,7 +33,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/astaxie/beego"
+	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/orm"
 )
 
@@ -90,7 +90,7 @@ func (m *Migration) Reset() {
 func (m *Migration) Exec(name, status string) error {
 	o := orm.NewOrm()
 	for _, s := range m.sqls {
-		beego.Info("exec sql:", s)
+		logs.Info("exec sql:", s)
 		r := o.Raw(s)
 		_, err := r.Exec()
 		if err != nil {
@@ -144,20 +144,20 @@ func Upgrade(lasttime int64) error {
 	i := 0
 	for _, v := range sm {
 		if v.created > lasttime {
-			beego.Info("start upgrade", v.name)
+			logs.Info("start upgrade", v.name)
 			v.m.Reset()
 			v.m.Up()
 			err := v.m.Exec(v.name, "up")
 			if err != nil {
-				beego.Error("execute error:", err)
+				logs.Error("execute error:", err)
 				time.Sleep(2 * time.Second)
 				return err
 			}
-			beego.Info("end upgrade:", v.name)
+			logs.Info("end upgrade:", v.name)
 			i++
 		}
 	}
-	beego.Info("total success upgrade:", i, " migration")
+	logs.Info("total success upgrade:", i, " migration")
 	time.Sleep(2 * time.Second)
 	return nil
 }
@@ -165,20 +165,20 @@ func Upgrade(lasttime int64) error {
 // Rollback rollback the migration by the name
 func Rollback(name string) error {
 	if v, ok := migrationMap[name]; ok {
-		beego.Info("start rollback")
+		logs.Info("start rollback")
 		v.Reset()
 		v.Down()
 		err := v.Exec(name, "down")
 		if err != nil {
-			beego.Error("execute error:", err)
+			logs.Error("execute error:", err)
 			time.Sleep(2 * time.Second)
 			return err
 		}
-		beego.Info("end rollback")
+		logs.Info("end rollback")
 		time.Sleep(2 * time.Second)
 		return nil
 	}
-	beego.Error("not exist the migrationMap name:" + name)
+	logs.Error("not exist the migrationMap name:" + name)
 	time.Sleep(2 * time.Second)
 	return errors.New("not exist the migrationMap name:" + name)
 }
@@ -191,23 +191,23 @@ func Reset() error {
 	for j := len(sm) - 1; j >= 0; j-- {
 		v := sm[j]
 		if isRollBack(v.name) {
-			beego.Info("skip the", v.name)
+			logs.Info("skip the", v.name)
 			time.Sleep(1 * time.Second)
 			continue
 		}
-		beego.Info("start reset:", v.name)
+		logs.Info("start reset:", v.name)
 		v.m.Reset()
 		v.m.Down()
 		err := v.m.Exec(v.name, "down")
 		if err != nil {
-			beego.Error("execute error:", err)
+			logs.Error("execute error:", err)
 			time.Sleep(2 * time.Second)
 			return err
 		}
 		i++
-		beego.Info("end reset:", v.name)
+		logs.Info("end reset:", v.name)
 	}
-	beego.Info("total success reset:", i, " migration")
+	logs.Info("total success reset:", i, " migration")
 	time.Sleep(2 * time.Second)
 	return nil
 }
@@ -216,7 +216,7 @@ func Reset() error {
 func Refresh() error {
 	err := Reset()
 	if err != nil {
-		beego.Error("execute error:", err)
+		logs.Error("execute error:", err)
 		time.Sleep(2 * time.Second)
 		return err
 	}
@@ -265,7 +265,7 @@ func isRollBack(name string) bool {
 	var maps []orm.Params
 	num, err := o.Raw("select * from migrations where `name` = ? order by id_migration desc", name).Values(&maps)
 	if err != nil {
-		beego.Info("get name has error", err)
+		logs.Info("get name has error", err)
 		return false
 	}
 	if num <= 0 {

mime.go

@@ -339,7 +339,7 @@ var mimemaps = map[string]string{
 	".pvu":         "paleovu/x-pv",
 	".pwz":         "application/vndms-powerpoint",
 	".py":          "text/x-scriptphyton",
-	".pyc":         "applicaiton/x-bytecodepython",
+	".pyc":         "application/x-bytecodepython",
 	".qcp":         "audio/vndqcelp",
 	".qd3":         "x-world/x-3dmf",
 	".qd3d":        "x-world/x-3dmf",

namespace.go

@@ -44,7 +44,7 @@ func NewNamespace(prefix string, params ...LinkNamespace) *Namespace {
 	return ns
 }
 
-// Cond set condtion function
+// Cond set condition function
 // if cond return true can run this namespace, else can't
 // usage:
 // ns.Cond(func (ctx *context.Context) bool{
@@ -60,7 +60,7 @@ func (n *Namespace) Cond(cond namespaceCond) *Namespace {
 			exception("405", ctx)
 		}
 	}
-	if v, ok := n.handlers.filters[BeforeRouter]; ok {
+	if v := n.handlers.filters[BeforeRouter]; len(v) > 0 {
 		mr := new(FilterRouter)
 		mr.tree = NewTree()
 		mr.pattern = "*"

orm/cmd_utils.go

@@ -52,9 +52,15 @@ checkColumn:
 	case TypeBooleanField:
 		col = T["bool"]
 	case TypeCharField:
+		if al.Driver == DRPostgres && fi.toText {
+			col = T["string-text"]
+		} else {
 			col = fmt.Sprintf(T["string"], fieldSize)
+		}
 	case TypeTextField:
 		col = T["string-text"]
+	case TypeTimeField:
+		col = T["time.Time-clock"]
 	case TypeDateField:
 		col = T["time.Time-date"]
 	case TypeDateTimeField:
@@ -88,6 +94,18 @@ checkColumn:
 		} else {
 			col = fmt.Sprintf(s, fi.digits, fi.decimals)
 		}
+	case TypeJSONField:
+		if al.Driver != DRPostgres {
+			fieldType = TypeCharField
+			goto checkColumn
+		}
+		col = T["json"]
+	case TypeJsonbField:
+		if al.Driver != DRPostgres {
+			fieldType = TypeCharField
+			goto checkColumn
+		}
+		col = T["jsonb"]
 	case RelForeignKey, RelOneToOne:
 		fieldType = fi.relModelInfo.fields.pk.fieldType
 		fieldSize = fi.relModelInfo.fields.pk.size
@@ -264,7 +282,7 @@ func getColumnDefault(fi *fieldInfo) string {
 
 	// These defaults will be useful if there no config value orm:"default" and NOT NULL is on
 	switch fi.fieldType {
-	case TypeDateField, TypeDateTimeField, TypeTextField:
+	case TypeTimeField, TypeDateField, TypeDateTimeField, TypeTextField:
 		return v
 
 	case TypeBitField, TypeSmallIntegerField, TypeIntegerField,
@@ -276,6 +294,8 @@ func getColumnDefault(fi *fieldInfo) string {
 	case TypeBooleanField:
 		t = " DEFAULT %s "
 		d = "FALSE"
+	case TypeJSONField, TypeJsonbField:
+		d = "{}"
 	}
 
 	if fi.colDefault {

orm/db.go

@@ -24,6 +24,7 @@ import (
 )
 
 const (
+	formatTime     = "15:04:05"
 	formatDate     = "2006-01-02"
 	formatDateTime = "2006-01-02 15:04:05"
 )
@@ -47,6 +48,7 @@ var (
 		"lte":         true,
 		"eq":          true,
 		"nq":          true,
+		"ne":	       true,
 		"startswith":  true,
 		"endswith":    true,
 		"istartswith": true,
@@ -71,12 +73,12 @@ type dbBase struct {
 var _ dbBaser = new(dbBase)
 
 // get struct columns values as interface slice.
-func (d *dbBase) collectValues(mi *modelInfo, ind reflect.Value, cols []string, skipAuto bool, insert bool, names *[]string, tz *time.Location) (values []interface{}, err error) {
+func (d *dbBase) collectValues(mi *modelInfo, ind reflect.Value, cols []string, skipAuto bool, insert bool, names *[]string, tz *time.Location) (values []interface{}, autoFields []string, err error) {
-	var columns []string
+	if names == nil {
-
+		ns := make([]string, 0, len(cols))
-	if names != nil {
+		names = &ns
-		columns = *names
 	}
+	values = make([]interface{}, 0, len(cols))
 
 	for _, column := range cols {
 		var fi *fieldInfo
@@ -90,18 +92,24 @@ func (d *dbBase) collectValues(mi *modelInfo, ind reflect.Value, cols []string,
 		}
 		value, err := d.collectFieldValue(mi, fi, ind, insert, tz)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 
-		if names != nil {
+		// ignore empty value auto field
-			columns = append(columns, column)
+		if insert && fi.auto {
+			if fi.fieldType&IsPositiveIntegerField > 0 {
+				if vu, ok := value.(uint64); !ok || vu == 0 {
+					continue
+				}
+			} else {
+				if vu, ok := value.(int64); !ok || vu == 0 {
+					continue
+				}
+			}
+			autoFields = append(autoFields, fi.column)
 		}
 
-		values = append(values, value)
+		*names, values = append(*names, column), append(values, value)
-	}
-
-	if names != nil {
-		*names = columns
 	}
 
 	return
@@ -134,7 +142,7 @@ func (d *dbBase) collectFieldValue(mi *modelInfo, fi *fieldInfo, ind reflect.Val
 				} else {
 					value = field.Bool()
 				}
-			case TypeCharField, TypeTextField:
+			case TypeCharField, TypeTextField, TypeJSONField, TypeJsonbField:
 				if ns, ok := field.Interface().(sql.NullString); ok {
 					value = nil
 					if ns.Valid {
@@ -169,7 +177,7 @@ func (d *dbBase) collectFieldValue(mi *modelInfo, fi *fieldInfo, ind reflect.Val
 						value = field.Float()
 					}
 				}
-			case TypeDateField, TypeDateTimeField:
+			case TypeTimeField, TypeDateField, TypeDateTimeField:
 				value = field.Interface()
 				if t, ok := value.(time.Time); ok {
 					d.ins.TimeToDB(&t, tz)
@@ -181,7 +189,7 @@ func (d *dbBase) collectFieldValue(mi *modelInfo, fi *fieldInfo, ind reflect.Val
 				}
 			default:
 				switch {
-				case fi.fieldType&IsPostiveIntegerField > 0:
+				case fi.fieldType&IsPositiveIntegerField > 0:
 					if field.Kind() == reflect.Ptr {
 						if field.IsNil() {
 							value = nil
@@ -223,7 +231,7 @@ func (d *dbBase) collectFieldValue(mi *modelInfo, fi *fieldInfo, ind reflect.Val
 			}
 		}
 		switch fi.fieldType {
-		case TypeDateField, TypeDateTimeField:
+		case TypeTimeField, TypeDateField, TypeDateTimeField:
 			if fi.autoNow || fi.autoNowAdd && insert {
 				if insert {
 					if t, ok := value.(time.Time); ok && !t.IsZero() {
@@ -236,10 +244,21 @@ func (d *dbBase) collectFieldValue(mi *modelInfo, fi *fieldInfo, ind reflect.Val
 				if fi.isFielder {
 					f := field.Addr().Interface().(Fielder)
 					f.SetRaw(tnow.In(DefaultTimeLoc))
+				} else if field.Kind() == reflect.Ptr {
+					v := tnow.In(DefaultTimeLoc)
+					field.Set(reflect.ValueOf(&v))
 				} else {
 					field.Set(reflect.ValueOf(tnow.In(DefaultTimeLoc)))
 				}
 			}
+		case TypeJSONField, TypeJsonbField:
+			if s, ok := value.(string); (ok && len(s) == 0) || value == nil {
+				if fi.colDefault && fi.initial.Exist() {
+					value = fi.initial.String()
+				} else {
+					value = nil
+				}
+			}
 		}
 	}
 	return value, nil
@@ -273,7 +292,7 @@ func (d *dbBase) PrepareInsert(q dbQuerier, mi *modelInfo) (stmtQuerier, string,
 
 // insert struct with prepared statement and given struct reflect value.
 func (d *dbBase) InsertStmt(stmt stmtQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location) (int64, error) {
-	values, err := d.collectValues(mi, ind, mi.fields.dbcols, true, true, nil, tz)
+	values, _, err := d.collectValues(mi, ind, mi.fields.dbcols, true, true, nil, tz)
 	if err != nil {
 		return 0, err
 	}
@@ -292,7 +311,7 @@ func (d *dbBase) InsertStmt(stmt stmtQuerier, mi *modelInfo, ind reflect.Value,
 }
 
 // query sql ,read records and persist in dbBaser.
-func (d *dbBase) Read(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location, cols []string) error {
+func (d *dbBase) Read(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location, cols []string, isForUpdate bool) error {
 	var whereCols []string
 	var args []interface{}
 
@@ -300,7 +319,7 @@ func (d *dbBase) Read(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Lo
 	if len(cols) > 0 {
 		var err error
 		whereCols = make([]string, 0, len(cols))
-		args, err = d.collectValues(mi, ind, cols, false, false, &whereCols, tz)
+		args, _, err = d.collectValues(mi, ind, cols, false, false, &whereCols, tz)
 		if err != nil {
 			return err
 		}
@@ -323,7 +342,12 @@ func (d *dbBase) Read(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Lo
 	sep = fmt.Sprintf("%s = ? AND %s", Q, Q)
 	wheres := strings.Join(whereCols, sep)
 
-	query := fmt.Sprintf("SELECT %s%s%s FROM %s%s%s WHERE %s%s%s = ?", Q, sels, Q, Q, mi.table, Q, Q, wheres, Q)
+	forUpdate := ""
+	if isForUpdate {
+		forUpdate = "FOR UPDATE"
+	}
+
+	query := fmt.Sprintf("SELECT %s%s%s FROM %s%s%s WHERE %s%s%s = ? %s", Q, sels, Q, Q, mi.table, Q, Q, wheres, Q, forUpdate)
 
 	refs := make([]interface{}, colsNum)
 	for i := range refs {
@@ -349,13 +373,21 @@ func (d *dbBase) Read(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Lo
 
 // execute insert sql dbQuerier with given struct reflect.Value.
 func (d *dbBase) Insert(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location) (int64, error) {
-	names := make([]string, 0, len(mi.fields.dbcols)-1)
+	names := make([]string, 0, len(mi.fields.dbcols))
-	values, err := d.collectValues(mi, ind, mi.fields.dbcols, true, true, &names, tz)
+	values, autoFields, err := d.collectValues(mi, ind, mi.fields.dbcols, false, true, &names, tz)
 	if err != nil {
 		return 0, err
 	}
 
-	return d.InsertValue(q, mi, false, names, values)
+	id, err := d.InsertValue(q, mi, false, names, values)
+	if err != nil {
+		return 0, err
+	}
+
+	if len(autoFields) > 0 {
+		err = d.ins.setval(q, mi, autoFields)
+	}
+	return id, err
 }
 
 // multi-insert sql with given slice struct reflect.Value.
@@ -369,7 +401,7 @@ func (d *dbBase) InsertMulti(q dbQuerier, mi *modelInfo, sind reflect.Value, bul
 
 	// typ := reflect.Indirect(mi.addrField).Type()
 
-	length := sind.Len()
+	length, autoFields := sind.Len(), make([]string, 0, 1)
 
 	for i := 1; i <= length; i++ {
 
@@ -381,16 +413,18 @@ func (d *dbBase) InsertMulti(q dbQuerier, mi *modelInfo, sind reflect.Value, bul
 		// }
 
 		if i == 1 {
-			vus, err := d.collectValues(mi, ind, mi.fields.dbcols, true, true, &names, tz)
+			var (
+				vus []interface{}
+				err error
+			)
+			vus, autoFields, err = d.collectValues(mi, ind, mi.fields.dbcols, false, true, &names, tz)
 			if err != nil {
 				return cnt, err
 			}
 			values = make([]interface{}, bulk*len(vus))
 			nums += copy(values, vus)
-
 		} else {
-
+			vus, _, err := d.collectValues(mi, ind, mi.fields.dbcols, false, true, nil, tz)
-			vus, err := d.collectValues(mi, ind, mi.fields.dbcols, true, true, nil, tz)
 			if err != nil {
 				return cnt, err
 			}
@@ -412,7 +446,12 @@ func (d *dbBase) InsertMulti(q dbQuerier, mi *modelInfo, sind reflect.Value, bul
 		}
 	}
 
-	return cnt, nil
+	var err error
+	if len(autoFields) > 0 {
+		err = d.ins.setval(q, mi, autoFields)
+	}
+
+	return cnt, err
 }
 
 // execute insert sql with given struct and given values.
@@ -455,6 +494,110 @@ func (d *dbBase) InsertValue(q dbQuerier, mi *modelInfo, isMulti bool, names []s
 	return id, err
 }
 
+// InsertOrUpdate a row
+// If your primary key or unique column conflict will update
+// If no will insert
+func (d *dbBase) InsertOrUpdate(q dbQuerier, mi *modelInfo, ind reflect.Value, a *alias, args ...string) (int64, error) {
+	args0 := ""
+	iouStr := ""
+	argsMap := map[string]string{}
+	switch a.Driver {
+	case DRMySQL:
+		iouStr = "ON DUPLICATE KEY UPDATE"
+	case DRPostgres:
+		if len(args) == 0 {
+			return 0, fmt.Errorf("`%s` use InsertOrUpdate must have a conflict column", a.DriverName)
+		} else {
+			args0 = strings.ToLower(args[0])
+			iouStr = fmt.Sprintf("ON CONFLICT (%s) DO UPDATE SET", args0)
+		}
+	default:
+		return 0, fmt.Errorf("`%s` nonsupport InsertOrUpdate in beego", a.DriverName)
+	}
+
+	//Get on the key-value pairs
+	for _, v := range args {
+		kv := strings.Split(v, "=")
+		if len(kv) == 2 {
+			argsMap[strings.ToLower(kv[0])] = kv[1]
+		}
+	}
+
+	isMulti := false
+	names := make([]string, 0, len(mi.fields.dbcols)-1)
+	Q := d.ins.TableQuote()
+	values, _, err := d.collectValues(mi, ind, mi.fields.dbcols, true, true, &names, a.TZ)
+
+	if err != nil {
+		return 0, err
+	}
+
+	marks := make([]string, len(names))
+	updateValues := make([]interface{}, 0)
+	updates := make([]string, len(names))
+	var conflitValue interface{}
+	for i, v := range names {
+		marks[i] = "?"
+		valueStr := argsMap[strings.ToLower(v)]
+		if v == args0 {
+			conflitValue = values[i]
+		}
+		if valueStr != "" {
+			switch a.Driver {
+			case DRMySQL:
+				updates[i] = v + "=" + valueStr
+			case DRPostgres:
+				if conflitValue != nil {
+					//postgres ON CONFLICT DO UPDATE SET can`t use colu=colu+values
+					updates[i] = fmt.Sprintf("%s=(select %s from %s where %s = ? )", v, valueStr, mi.table, args0)
+					updateValues = append(updateValues, conflitValue)
+				} else {
+					return 0, fmt.Errorf("`%s` must be in front of `%s` in your struct", args0, v)
+				}
+			}
+		} else {
+			updates[i] = v + "=?"
+			updateValues = append(updateValues, values[i])
+		}
+	}
+
+	values = append(values, updateValues...)
+
+	sep := fmt.Sprintf("%s, %s", Q, Q)
+	qmarks := strings.Join(marks, ", ")
+	qupdates := strings.Join(updates, ", ")
+	columns := strings.Join(names, sep)
+
+	multi := len(values) / len(names)
+
+	if isMulti {
+		qmarks = strings.Repeat(qmarks+"), (", multi-1) + qmarks
+	}
+	//conflitValue maybe is a int,can`t use fmt.Sprintf
+	query := fmt.Sprintf("INSERT INTO %s%s%s (%s%s%s) VALUES (%s) %s "+qupdates, Q, mi.table, Q, Q, columns, Q, qmarks, iouStr)
+
+	d.ins.ReplaceMarks(&query)
+
+	if isMulti || !d.ins.HasReturningID(mi, &query) {
+		res, err := q.Exec(query, values...)
+		if err == nil {
+			if isMulti {
+				return res.RowsAffected()
+			}
+			return res.LastInsertId()
+		}
+		return 0, err
+	}
+
+	row := q.QueryRow(query, values...)
+	var id int64
+	err = row.Scan(&id)
+	if err.Error() == `pq: syntax error at or near "ON"` {
+		err = fmt.Errorf("postgres version must 9.5 or higher")
+	}
+	return id, err
+}
+
 // execute update sql dbQuerier with given struct reflect.Value.
 func (d *dbBase) Update(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location, cols []string) (int64, error) {
 	pkName, pkValue, ok := getExistPk(mi, ind)
@@ -472,7 +615,7 @@ func (d *dbBase) Update(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.
 		setNames = make([]string, 0, len(cols))
 	}
 
-	setValues, err := d.collectValues(mi, ind, cols, true, false, &setNames, tz)
+	setValues, _, err := d.collectValues(mi, ind, cols, true, false, &setNames, tz)
 	if err != nil {
 		return 0, err
 	}
@@ -497,18 +640,36 @@ func (d *dbBase) Update(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.
 
 // execute delete sql dbQuerier with given struct reflect.Value.
 // delete index is pk.
-func (d *dbBase) Delete(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location) (int64, error) {
+func (d *dbBase) Delete(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Location, cols []string) (int64, error) {
-	pkName, pkValue, ok := getExistPk(mi, ind)
+	var whereCols []string
+	var args []interface{}
+	// if specify cols length > 0, then use it for where condition.
+	if len(cols) > 0 {
+		var err error
+		whereCols = make([]string, 0, len(cols))
+		args, _, err = d.collectValues(mi, ind, cols, false, false, &whereCols, tz)
+		if err != nil {
+			return 0, err
+		}
+	} else {
+		// default use pk value as where condtion.
+		pkColumn, pkValue, ok := getExistPk(mi, ind)
 		if ok == false {
 			return 0, ErrMissPK
 		}
+		whereCols = []string{pkColumn}
+		args = append(args, pkValue)
+	}
 
 	Q := d.ins.TableQuote()
 
-	query := fmt.Sprintf("DELETE FROM %s%s%s WHERE %s%s%s = ?", Q, mi.table, Q, Q, pkName, Q)
+	sep := fmt.Sprintf("%s = ? AND %s", Q, Q)
+	wheres := strings.Join(whereCols, sep)
+
+	query := fmt.Sprintf("DELETE FROM %s%s%s WHERE %s%s%s = ?", Q, mi.table, Q, Q, wheres, Q)
 
 	d.ins.ReplaceMarks(&query)
-	res, err := q.Exec(query, pkValue)
+	res, err := q.Exec(query, args...)
 	if err == nil {
 		num, err := res.RowsAffected()
 		if err != nil {
@@ -516,13 +677,13 @@ func (d *dbBase) Delete(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.
 		}
 		if num > 0 {
 			if mi.fields.pk.auto {
-				if mi.fields.pk.fieldType&IsPostiveIntegerField > 0 {
+				if mi.fields.pk.fieldType&IsPositiveIntegerField > 0 {
 					ind.FieldByIndex(mi.fields.pk.fieldIndex).SetUint(0)
 				} else {
 					ind.FieldByIndex(mi.fields.pk.fieldIndex).SetInt(0)
 				}
 			}
-			err := d.deleteRels(q, mi, []interface{}{pkValue}, tz)
+			err := d.deleteRels(q, mi, args, tz)
 			if err != nil {
 				return num, err
 			}
@@ -927,12 +1088,17 @@ func (d *dbBase) Count(q dbQuerier, qs *querySet, mi *modelInfo, cond *Condition
 	tables.parseRelated(qs.related, qs.relDepth)
 
 	where, args := tables.getCondSQL(cond, false, tz)
+	groupBy := tables.getGroupSQL(qs.groups)
 	tables.getOrderSQL(qs.orders)
 	join := tables.getJoinSQL()
 
 	Q := d.ins.TableQuote()
 
-	query := fmt.Sprintf("SELECT COUNT(*) FROM %s%s%s T0 %s%s", Q, mi.table, Q, join, where)
+	query := fmt.Sprintf("SELECT COUNT(*) FROM %s%s%s T0 %s%s%s", Q, mi.table, Q, join, where, groupBy)
+
+	if groupBy != "" {
+		query = fmt.Sprintf("SELECT COUNT(*) FROM (%s) AS T", query)
+	}
 
 	d.ins.ReplaceMarks(&query)
 
@@ -1071,13 +1237,13 @@ setValue:
 			}
 			value = b
 		}
-	case fieldType == TypeCharField || fieldType == TypeTextField:
+	case fieldType == TypeCharField || fieldType == TypeTextField || fieldType == TypeJSONField || fieldType == TypeJsonbField:
 		if str == nil {
 			value = ToStr(val)
 		} else {
 			value = str.String()
 		}
-	case fieldType == TypeDateField || fieldType == TypeDateTimeField:
+	case fieldType == TypeTimeField || fieldType == TypeDateField || fieldType == TypeDateTimeField:
 		if str == nil {
 			switch t := val.(type) {
 			case time.Time:
@@ -1097,15 +1263,20 @@ setValue:
 			if len(s) >= 19 {
 				s = s[:19]
 				t, err = time.ParseInLocation(formatDateTime, s, tz)
-			} else {
+			} else if len(s) >= 10 {
 				if len(s) > 10 {
 					s = s[:10]
 				}
 				t, err = time.ParseInLocation(formatDate, s, tz)
+			} else if len(s) >= 8 {
+				if len(s) > 8 {
+					s = s[:8]
+				}
+				t, err = time.ParseInLocation(formatTime, s, tz)
 			}
 			t = t.In(DefaultTimeLoc)
 
-			if err != nil && s != "0000-00-00" && s != "0000-00-00 00:00:00" {
+			if err != nil && s != "00:00:00" && s != "0000-00-00" && s != "0000-00-00 00:00:00" {
 				tErr = err
 				goto end
 			}
@@ -1140,7 +1311,7 @@ setValue:
 				tErr = err
 				goto end
 			}
-			if fieldType&IsPostiveIntegerField > 0 {
+			if fieldType&IsPositiveIntegerField > 0 {
 				v, _ := str.Uint64()
 				value = v
 			} else {
@@ -1212,7 +1383,7 @@ setValue:
 				field.SetBool(value.(bool))
 			}
 		}
-	case fieldType == TypeCharField || fieldType == TypeTextField:
+	case fieldType == TypeCharField || fieldType == TypeTextField || fieldType == TypeJSONField || fieldType == TypeJsonbField:
 		if isNative {
 			if ns, ok := field.Interface().(sql.NullString); ok {
 				if value == nil {
@@ -1234,13 +1405,19 @@ setValue:
 				field.SetString(value.(string))
 			}
 		}
-	case fieldType == TypeDateField || fieldType == TypeDateTimeField:
+	case fieldType == TypeTimeField || fieldType == TypeDateField || fieldType == TypeDateTimeField:
 		if isNative {
 			if value == nil {
 				value = time.Time{}
+			} else if field.Kind() == reflect.Ptr {
+				if value != nil {
+					v := value.(time.Time)
+					field.Set(reflect.ValueOf(&v))
 				}
+			} else {
 				field.Set(reflect.ValueOf(value))
 			}
+		}
 	case fieldType == TypePositiveBitField && field.Kind() == reflect.Ptr:
 		if value != nil {
 			v := uint8(value.(uint64))
@@ -1292,7 +1469,7 @@ setValue:
 			field.Set(reflect.ValueOf(&v))
 		}
 	case fieldType&IsIntegerField > 0:
-		if fieldType&IsPostiveIntegerField > 0 {
+		if fieldType&IsPositiveIntegerField > 0 {
 			if isNative {
 				if value == nil {
 					value = uint64(0)
@@ -1440,7 +1617,11 @@ func (d *dbBase) ReadValues(q dbQuerier, qs *querySet, mi *modelInfo, cond *Cond
 
 	sels := strings.Join(cols, ", ")
 
-	query := fmt.Sprintf("SELECT %s FROM %s%s%s T0 %s%s%s%s%s", sels, Q, mi.table, Q, join, where, groupBy, orderBy, limit)
+	sqlSelect := "SELECT"
+	if qs.distinct {
+		sqlSelect += " DISTINCT"
+	}
+	query := fmt.Sprintf("%s %s FROM %s%s%s T0 %s%s%s%s%s", sqlSelect, sels, Q, mi.table, Q, join, where, groupBy, orderBy, limit)
 
 	d.ins.ReplaceMarks(&query)
 
@@ -1562,6 +1743,11 @@ func (d *dbBase) HasReturningID(*modelInfo, *string) bool {
 	return false
 }
 
+// sync auto key
+func (d *dbBase) setval(db dbQuerier, mi *modelInfo, autoFields []string) error {
+	return nil
+}
+
 // convert time from db.
 func (d *dbBase) TimeFromDB(t *time.Time, tz *time.Location) {
 	*t = t.In(tz)

orm/db_alias.go

@@ -80,7 +80,7 @@ type _dbCache struct {
 func (ac *_dbCache) add(name string, al *alias) (added bool) {
 	ac.mux.Lock()
 	defer ac.mux.Unlock()
-	if _, ok := ac.cache[name]; ok == false {
+	if _, ok := ac.cache[name]; !ok {
 		ac.cache[name] = al
 		added = true
 	}

orm/db_mysql.go

@@ -16,6 +16,8 @@ package orm
 
 import (
 	"fmt"
+	"reflect"
+	"strings"
 )
 
 // mysql operators.
@@ -96,6 +98,83 @@ func (d *dbBaseMysql) IndexExists(db dbQuerier, table string, name string) bool
 	return cnt > 0
 }
 
+// InsertOrUpdate a row
+// If your primary key or unique column conflict will update
+// If no will insert
+// Add "`" for mysql sql building
+func (d *dbBaseMysql) InsertOrUpdate(q dbQuerier, mi *modelInfo, ind reflect.Value, a *alias, args ...string) (int64, error) {
+
+	iouStr := ""
+	argsMap := map[string]string{}
+
+	iouStr = "ON DUPLICATE KEY UPDATE"
+
+	//Get on the key-value pairs
+	for _, v := range args {
+		kv := strings.Split(v, "=")
+		if len(kv) == 2 {
+			argsMap[strings.ToLower(kv[0])] = kv[1]
+		}
+	}
+
+	isMulti := false
+	names := make([]string, 0, len(mi.fields.dbcols)-1)
+	Q := d.ins.TableQuote()
+	values, _, err := d.collectValues(mi, ind, mi.fields.dbcols, true, true, &names, a.TZ)
+
+	if err != nil {
+		return 0, err
+	}
+
+	marks := make([]string, len(names))
+	updateValues := make([]interface{}, 0)
+	updates := make([]string, len(names))
+
+	for i, v := range names {
+		marks[i] = "?"
+		valueStr := argsMap[strings.ToLower(v)]
+		if valueStr != "" {
+			updates[i] = "`" + v + "`" + "=" + valueStr
+		} else {
+			updates[i] = "`" + v + "`" + "=?"
+			updateValues = append(updateValues, values[i])
+		}
+	}
+
+	values = append(values, updateValues...)
+
+	sep := fmt.Sprintf("%s, %s", Q, Q)
+	qmarks := strings.Join(marks, ", ")
+	qupdates := strings.Join(updates, ", ")
+	columns := strings.Join(names, sep)
+
+	multi := len(values) / len(names)
+
+	if isMulti {
+		qmarks = strings.Repeat(qmarks+"), (", multi-1) + qmarks
+	}
+	//conflitValue maybe is a int,can`t use fmt.Sprintf
+	query := fmt.Sprintf("INSERT INTO %s%s%s (%s%s%s) VALUES (%s) %s "+qupdates, Q, mi.table, Q, Q, columns, Q, qmarks, iouStr)
+
+	d.ins.ReplaceMarks(&query)
+
+	if isMulti || !d.ins.HasReturningID(mi, &query) {
+		res, err := q.Exec(query, values...)
+		if err == nil {
+			if isMulti {
+				return res.RowsAffected()
+			}
+			return res.LastInsertId()
+		}
+		return 0, err
+	}
+
+	row := q.QueryRow(query, values...)
+	var id int64
+	err = row.Scan(&id)
+	return id, err
+}
+
 // create new mysql dbBaser.
 func newdbBaseMysql() dbBaser {
 	b := new(dbBaseMysql)

orm/db_postgres.go

@@ -56,6 +56,8 @@ var postgresTypes = map[string]string{
 	"uint64":          `bigint CHECK("%COL%" >= 0)`,
 	"float64":         "double precision",
 	"float64-decimal": "numeric(%d, %d)",
+	"json":            "json",
+	"jsonb":           "jsonb",
 }
 
 // postgresql dbBaser.
@@ -123,14 +125,35 @@ func (d *dbBasePostgres) ReplaceMarks(query *string) {
 }
 
 // make returning sql support for postgresql.
-func (d *dbBasePostgres) HasReturningID(mi *modelInfo, query *string) (has bool) {
+func (d *dbBasePostgres) HasReturningID(mi *modelInfo, query *string) bool {
-	if mi.fields.pk.auto {
+	fi := mi.fields.pk
+	if fi.fieldType&IsPositiveIntegerField == 0 && fi.fieldType&IsIntegerField == 0 {
+		return false
+	}
+
 	if query != nil {
-			*query = fmt.Sprintf(`%s RETURNING "%s"`, *query, mi.fields.pk.column)
+		*query = fmt.Sprintf(`%s RETURNING "%s"`, *query, fi.column)
 	}
-		has = true
+	return true
 }
-	return
+
+// sync auto key
+func (d *dbBasePostgres) setval(db dbQuerier, mi *modelInfo, autoFields []string) error {
+	if len(autoFields) == 0 {
+		return nil
+	}
+
+	Q := d.ins.TableQuote()
+	for _, name := range autoFields {
+		query := fmt.Sprintf("SELECT setval(pg_get_serial_sequence('%s', '%s'), (SELECT MAX(%s%s%s) FROM %s%s%s));",
+			mi.table, name,
+			Q, name, Q,
+			Q, mi.table, Q)
+		if _, err := db.Exec(query); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 // show table sql for postgresql.

orm/db_utils.go

@@ -33,14 +33,16 @@ func getExistPk(mi *modelInfo, ind reflect.Value) (column string, value interfac
 	fi := mi.fields.pk
 
 	v := ind.FieldByIndex(fi.fieldIndex)
-	if fi.fieldType&IsPostiveIntegerField > 0 {
+	if fi.fieldType&IsPositiveIntegerField > 0 {
 		vu := v.Uint()
 		exist = vu > 0
 		value = vu
 	} else if fi.fieldType&IsIntegerField > 0 {
 		vu := v.Int()
-		exist = vu > 0
+		exist = true
 		value = vu
+	} else if fi.fieldType&IsRelField > 0 {
+		_, value, exist = getExistPk(fi.relModelInfo, reflect.Indirect(v))
 	} else {
 		vu := v.String()
 		exist = vu != ""
@@ -74,24 +76,32 @@ outFor:
 		case reflect.String:
 			v := val.String()
 			if fi != nil {
-				if fi.fieldType == TypeDateField || fi.fieldType == TypeDateTimeField {
+				if fi.fieldType == TypeTimeField || fi.fieldType == TypeDateField || fi.fieldType == TypeDateTimeField {
 					var t time.Time
 					var err error
 					if len(v) >= 19 {
 						s := v[:19]
 						t, err = time.ParseInLocation(formatDateTime, s, DefaultTimeLoc)
-					} else {
+					} else if len(v) >= 10 {
 						s := v
 						if len(v) > 10 {
 							s = v[:10]
 						}
 						t, err = time.ParseInLocation(formatDate, s, tz)
+					} else {
+						s := v
+						if len(s) > 8 {
+							s = v[:8]
+						}
+						t, err = time.ParseInLocation(formatTime, s, tz)
 					}
 					if err == nil {
 						if fi.fieldType == TypeDateField {
 							v = t.In(tz).Format(formatDate)
-						} else {
+						} else if fi.fieldType == TypeDateTimeField {
 							v = t.In(tz).Format(formatDateTime)
+						} else {
+							v = t.In(tz).Format(formatTime)
 						}
 					}
 				}
@@ -137,6 +147,10 @@ outFor:
 			if v, ok := arg.(time.Time); ok {
 				if fi != nil && fi.fieldType == TypeDateField {
 					arg = v.In(tz).Format(formatDate)
+				} else if fi != nil && fi.fieldType == TypeDateTimeField {
+					arg = v.In(tz).Format(formatDateTime)
+				} else if fi != nil && fi.fieldType == TypeTimeField {
+					arg = v.In(tz).Format(formatTime)
 				} else {
 					arg = v.In(tz).Format(formatDateTime)
 				}
@@ -144,7 +158,7 @@ outFor:
 				typ := val.Type()
 				name := getFullName(typ)
 				var value interface{}
-				if mmi, ok := modelCache.getByFN(name); ok {
+				if mmi, ok := modelCache.getByFullName(name); ok {
 					if _, vu, exist := getExistPk(mmi, val); exist {
 						value = vu
 					}

orm/models.go

@@ -30,37 +30,16 @@ const (
 var (
 	modelCache = &_modelCache{
 		cache:           make(map[string]*modelInfo),
-		cacheByFN: make(map[string]*modelInfo),
+		cacheByFullName: make(map[string]*modelInfo),
-	}
-	supportTag = map[string]int{
-		"-":            1,
-		"null":         1,
-		"index":        1,
-		"unique":       1,
-		"pk":           1,
-		"auto":         1,
-		"auto_now":     1,
-		"auto_now_add": 1,
-		"size":         2,
-		"column":       2,
-		"default":      2,
-		"rel":          2,
-		"reverse":      2,
-		"rel_table":    2,
-		"rel_through":  2,
-		"digits":       2,
-		"decimals":     2,
-		"on_delete":    2,
-		"type":         2,
 	}
 )
 
 // model info collection
 type _modelCache struct {
-	sync.RWMutex
+	sync.RWMutex    // only used outsite for bootStrap
 	orders          []string
 	cache           map[string]*modelInfo
-	cacheByFN map[string]*modelInfo
+	cacheByFullName map[string]*modelInfo
 	done            bool
 }
 
@@ -88,9 +67,9 @@ func (mc *_modelCache) get(table string) (mi *modelInfo, ok bool) {
 	return
 }
 
-// get model info by field name
+// get model info by full name
-func (mc *_modelCache) getByFN(name string) (mi *modelInfo, ok bool) {
+func (mc *_modelCache) getByFullName(name string) (mi *modelInfo, ok bool) {
-	mi, ok = mc.cacheByFN[name]
+	mi, ok = mc.cacheByFullName[name]
 	return
 }
 
@@ -98,7 +77,7 @@ func (mc *_modelCache) getByFN(name string) (mi *modelInfo, ok bool) {
 func (mc *_modelCache) set(table string, mi *modelInfo) *modelInfo {
 	mii := mc.cache[table]
 	mc.cache[table] = mi
-	mc.cacheByFN[mi.fullName] = mi
+	mc.cacheByFullName[mi.fullName] = mi
 	if mii == nil {
 		mc.orders = append(mc.orders, table)
 	}
@@ -109,7 +88,7 @@ func (mc *_modelCache) set(table string, mi *modelInfo) *modelInfo {
 func (mc *_modelCache) clean() {
 	mc.orders = make([]string, 0)
 	mc.cache = make(map[string]*modelInfo)
-	mc.cacheByFN = make(map[string]*modelInfo)
+	mc.cacheByFullName = make(map[string]*modelInfo)
 	mc.done = false
 }
 

orm/models_boot.go

@@ -15,7 +15,6 @@
 package orm
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"reflect"
@@ -23,24 +22,34 @@ import (
 )
 
 // register models.
-// prefix means table name prefix.
+// PrefixOrSuffix means table name prefix or suffix.
-func registerModel(prefix string, model interface{}) {
+// isPrefix whether the prefix is prefix or suffix
+func registerModel(PrefixOrSuffix string, model interface{}, isPrefix bool) {
 	val := reflect.ValueOf(model)
-	ind := reflect.Indirect(val)
+	typ := reflect.Indirect(val).Type()
-	typ := ind.Type()
 
 	if val.Kind() != reflect.Ptr {
 		panic(fmt.Errorf("<orm.RegisterModel> cannot use non-ptr model struct `%s`", getFullName(typ)))
 	}
+	// For this case:
+	// u := &User{}
+	// registerModel(&u)
+	if typ.Kind() == reflect.Ptr {
+		panic(fmt.Errorf("<orm.RegisterModel> only allow ptr model struct, it looks you use two reference to the struct `%s`", typ))
+	}
 
 	table := getTableName(val)
 
-	if prefix != "" {
+	if PrefixOrSuffix != "" {
-		table = prefix + table
+		if isPrefix {
+			table = PrefixOrSuffix + table
+		} else {
+			table = table + PrefixOrSuffix
 		}
-
+	}
+	// models's fullname is pkgpath + struct name
 	name := getFullName(typ)
-	if _, ok := modelCache.getByFN(name); ok {
+	if _, ok := modelCache.getByFullName(name); ok {
 		fmt.Printf("<orm.RegisterModel> model `%s` repeat register, must be unique\n", name)
 		os.Exit(2)
 	}
@@ -50,34 +59,34 @@ func registerModel(prefix string, model interface{}) {
 		os.Exit(2)
 	}
 
-	info := newModelInfo(val)
+	mi := newModelInfo(val)
-	if info.fields.pk == nil {
+	if mi.fields.pk == nil {
 	outFor:
-		for _, fi := range info.fields.fieldsDB {
+		for _, fi := range mi.fields.fieldsDB {
 			if strings.ToLower(fi.name) == "id" {
 				switch fi.addrValue.Elem().Kind() {
 				case reflect.Int, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint32, reflect.Uint64:
 					fi.auto = true
 					fi.pk = true
-					info.fields.pk = fi
+					mi.fields.pk = fi
 					break outFor
 				}
 			}
 		}
 
-		if info.fields.pk == nil {
+		if mi.fields.pk == nil {
-			fmt.Printf("<orm.RegisterModel> `%s` need a primary key field\n", name)
+			fmt.Printf("<orm.RegisterModel> `%s` need a primary key field, default use 'id' if not set\n", name)
 			os.Exit(2)
 		}
 
 	}
 
-	info.table = table
+	mi.table = table
-	info.pkg = typ.PkgPath()
+	mi.pkg = typ.PkgPath()
-	info.model = model
+	mi.model = model
-	info.manual = true
+	mi.manual = true
 
-	modelCache.set(table, info)
+	modelCache.set(table, mi)
 }
 
 // boostrap models
@@ -85,31 +94,30 @@ func bootStrap() {
 	if modelCache.done {
 		return
 	}
-
 	var (
 		err    error
 		models map[string]*modelInfo
 	)
-
 	if dataBaseCache.getDefault() == nil {
 		err = fmt.Errorf("must have one register DataBase alias named `default`")
 		goto end
 	}
 
+	// set rel and reverse model
+	// RelManyToMany set the relTable
 	models = modelCache.all()
 	for _, mi := range models {
 		for _, fi := range mi.fields.columns {
 			if fi.rel || fi.reverse {
 				elm := fi.addrValue.Type().Elem()
-				switch fi.fieldType {
+				if fi.fieldType == RelReverseMany || fi.fieldType == RelManyToMany {
-				case RelReverseMany, RelManyToMany:
 					elm = elm.Elem()
 				}
-
+				// check the rel or reverse model already register
 				name := getFullName(elm)
-				mii, ok := modelCache.getByFN(name)
+				mii, ok := modelCache.getByFullName(name)
-				if ok == false || mii.pkg != elm.PkgPath() {
+				if !ok || mii.pkg != elm.PkgPath() {
-					err = fmt.Errorf("can not found rel in field `%s`, `%s` may be miss register", fi.fullName, elm.String())
+					err = fmt.Errorf("can not find rel in field `%s`, `%s` may be miss register", fi.fullName, elm.String())
 					goto end
 				}
 				fi.relModelInfo = mii
@@ -117,20 +125,17 @@ func bootStrap() {
 				switch fi.fieldType {
 				case RelManyToMany:
 					if fi.relThrough != "" {
-						msg := fmt.Sprintf("field `%s` wrong rel_through value `%s`", fi.fullName, fi.relThrough)
 						if i := strings.LastIndex(fi.relThrough, "."); i != -1 && len(fi.relThrough) > (i+1) {
 							pn := fi.relThrough[:i]
-							rmi, ok := modelCache.getByFN(fi.relThrough)
+							rmi, ok := modelCache.getByFullName(fi.relThrough)
 							if ok == false || pn != rmi.pkg {
-								err = errors.New(msg + " cannot find table")
+								err = fmt.Errorf("field `%s` wrong rel_through value `%s` cannot find table", fi.fullName, fi.relThrough)
 								goto end
 							}
-
 							fi.relThroughModelInfo = rmi
 							fi.relTable = rmi.table
-
 						} else {
-							err = errors.New(msg)
+							err = fmt.Errorf("field `%s` wrong rel_through value `%s`", fi.fullName, fi.relThrough)
 							goto end
 						}
 					} else {
@@ -138,7 +143,6 @@ func bootStrap() {
 						if fi.relTable != "" {
 							i.table = fi.relTable
 						}
-
 						if v := modelCache.set(i.table, i); v != nil {
 							err = fmt.Errorf("the rel table name `%s` already registered, cannot be use, please change one", fi.relTable)
 							goto end
@@ -153,6 +157,8 @@ func bootStrap() {
 		}
 	}
 
+	// check the rel filed while the relModelInfo also has filed point to current model
+	// if not exist, add a new field to the relModelInfo
 	models = modelCache.all()
 	for _, mi := range models {
 		for _, fi := range mi.fields.fieldsRel {
@@ -165,7 +171,6 @@ func bootStrap() {
 						break
 					}
 				}
-
 				if inModel == false {
 					rmi := fi.relModelInfo
 					ffi := new(fieldInfo)
@@ -216,7 +221,6 @@ func bootStrap() {
 						}
 					}
 				}
-
 				if fi.reverseFieldInfoTwo == nil {
 					err = fmt.Errorf("can not find m2m field for m2m model `%s`, ensure your m2m model defined correct",
 						fi.relThroughModelInfo.fullName)
@@ -300,17 +304,31 @@ end:
 
 // RegisterModel register models
 func RegisterModel(models ...interface{}) {
+	if modelCache.done {
+		panic(fmt.Errorf("RegisterModel must be run before BootStrap"))
+	}
 	RegisterModelWithPrefix("", models...)
 }
 
 // RegisterModelWithPrefix register models with a prefix
 func RegisterModelWithPrefix(prefix string, models ...interface{}) {
 	if modelCache.done {
-		panic(fmt.Errorf("RegisterModel must be run before BootStrap"))
+		panic(fmt.Errorf("RegisterModelWithPrefix must be run before BootStrap"))
 	}
 
 	for _, model := range models {
-		registerModel(prefix, model)
+		registerModel(prefix, model, true)
+	}
+}
+
+// RegisterModelWithSuffix register models with a suffix
+func RegisterModelWithSuffix(suffix string, models ...interface{}) {
+	if modelCache.done {
+		panic(fmt.Errorf("RegisterModelWithSuffix must be run before BootStrap"))
+	}
+
+	for _, model := range models {
+		registerModel(suffix, model, false)
 	}
 }
 
@@ -320,7 +338,6 @@ func BootStrap() {
 	if modelCache.done {
 		return
 	}
-
 	modelCache.Lock()
 	defer modelCache.Unlock()
 	bootStrap()

orm/models_fields.go

@@ -25,6 +25,7 @@ const (
 	TypeBooleanField = 1 << iota
 	TypeCharField
 	TypeTextField
+	TypeTimeField
 	TypeDateField
 	TypeDateTimeField
 	TypeBitField
@@ -37,6 +38,8 @@ const (
 	TypePositiveBigIntegerField
 	TypeFloatField
 	TypeDecimalField
+	TypeJSONField
+	TypeJsonbField
 	RelForeignKey
 	RelOneToOne
 	RelManyToMany
@@ -46,9 +49,9 @@ const (
 
 // Define some logic enum
 const (
-	IsIntegerField        = ^-TypePositiveBigIntegerField >> 4 << 5
+	IsIntegerField         = ^-TypePositiveBigIntegerField >> 5 << 6
-	IsPostiveIntegerField = ^-TypePositiveBigIntegerField >> 8 << 9
+	IsPositiveIntegerField = ^-TypePositiveBigIntegerField >> 9 << 10
-	IsRelField            = ^-RelReverseMany >> 14 << 15
+	IsRelField             = ^-RelReverseMany >> 17 << 18
 	IsFieldType            = ^-RelReverseMany<<1 + 1
 )
 
@@ -145,6 +148,65 @@ func (e *CharField) RawValue() interface{} {
 // verify CharField implement Fielder
 var _ Fielder = new(CharField)
 
+// TimeField A time, represented in go by a time.Time instance.
+// only time values like 10:00:00
+// Has a few extra, optional attr tag:
+//
+// auto_now:
+// Automatically set the field to now every time the object is saved. Useful for “last-modified” timestamps.
+// Note that the current date is always used; it’s not just a default value that you can override.
+//
+// auto_now_add:
+// Automatically set the field to now when the object is first created. Useful for creation of timestamps.
+// Note that the current date is always used; it’s not just a default value that you can override.
+//
+// eg: `orm:"auto_now"` or `orm:"auto_now_add"`
+type TimeField time.Time
+
+// Value return the time.Time
+func (e TimeField) Value() time.Time {
+	return time.Time(e)
+}
+
+// Set set the TimeField's value
+func (e *TimeField) Set(d time.Time) {
+	*e = TimeField(d)
+}
+
+// String convert time to string
+func (e *TimeField) String() string {
+	return e.Value().String()
+}
+
+// FieldType return enum type Date
+func (e *TimeField) FieldType() int {
+	return TypeDateField
+}
+
+// SetRaw convert the interface to time.Time. Allow string and time.Time
+func (e *TimeField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case time.Time:
+		e.Set(d)
+	case string:
+		v, err := timeParse(d, formatTime)
+		if err != nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<TimeField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return time value
+func (e *TimeField) RawValue() interface{} {
+	return e.Value()
+}
+
+var _ Fielder = new(TimeField)
+
 // DateField A date, represented in go by a time.Time instance.
 // only date values like 2006-01-02
 // Has a few extra, optional attr tag:
@@ -627,3 +689,87 @@ func (e *TextField) RawValue() interface{} {
 
 // verify TextField implement Fielder
 var _ Fielder = new(TextField)
+
+// JSONField postgres json field.
+type JSONField string
+
+// Value return JSONField value
+func (j JSONField) Value() string {
+	return string(j)
+}
+
+// Set the JSONField value
+func (j *JSONField) Set(d string) {
+	*j = JSONField(d)
+}
+
+// String convert JSONField to string
+func (j *JSONField) String() string {
+	return j.Value()
+}
+
+// FieldType return enum type
+func (j *JSONField) FieldType() int {
+	return TypeJSONField
+}
+
+// SetRaw convert interface string to string
+func (j *JSONField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case string:
+		j.Set(d)
+	default:
+		return fmt.Errorf("<JSONField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return JSONField value
+func (j *JSONField) RawValue() interface{} {
+	return j.Value()
+}
+
+// verify JSONField implement Fielder
+var _ Fielder = new(JSONField)
+
+// JsonbField postgres json field.
+type JsonbField string
+
+// Value return JsonbField value
+func (j JsonbField) Value() string {
+	return string(j)
+}
+
+// Set the JsonbField value
+func (j *JsonbField) Set(d string) {
+	*j = JsonbField(d)
+}
+
+// String convert JsonbField to string
+func (j *JsonbField) String() string {
+	return j.Value()
+}
+
+// FieldType return enum type
+func (j *JsonbField) FieldType() int {
+	return TypeJsonbField
+}
+
+// SetRaw convert interface string to string
+func (j *JsonbField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case string:
+		j.Set(d)
+	default:
+		return fmt.Errorf("<JsonbField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return JsonbField value
+func (j *JsonbField) RawValue() interface{} {
+	return j.Value()
+}
+
+// verify JsonbField implement Fielder
+var _ Fielder = new(JsonbField)

orm/models_info_f.go

@@ -104,7 +104,7 @@ type fieldInfo struct {
 	mi                  *modelInfo
 	fieldIndex          []int
 	fieldType           int
-	dbcol               bool
+	dbcol               bool // table column fk and onetoone
 	inModel             bool
 	name                string
 	fullName            string
@@ -116,12 +116,13 @@ type fieldInfo struct {
 	null                bool
 	index               bool
 	unique              bool
-	colDefault          bool
+	colDefault          bool  // whether has default tag
-	initial             StrTo
+	initial             StrTo // store the default value
 	size                int
+	toText              bool
 	autoNow             bool
 	autoNowAdd          bool
-	rel                 bool
+	rel                 bool // if type equal to RelForeignKey, RelOneToOne, RelManyToMany then true
 	reverse             bool
 	reverseField        string
 	reverseFieldInfo    *fieldInfo
@@ -133,7 +134,7 @@ type fieldInfo struct {
 	relModelInfo        *modelInfo
 	digits              int
 	decimals            int
-	isFielder           bool
+	isFielder           bool // implement Fielder interface
 	onDelete            string
 }
 
@@ -142,7 +143,7 @@ func newFieldInfo(mi *modelInfo, field reflect.Value, sf reflect.StructField, mN
 	var (
 		tag       string
 		tagValue  string
-		initial   StrTo
+		initial   StrTo // store the default value
 		fieldType int
 		attrs     map[string]bool
 		tags      map[string]string
@@ -151,6 +152,10 @@ func newFieldInfo(mi *modelInfo, field reflect.Value, sf reflect.StructField, mN
 
 	fi = new(fieldInfo)
 
+	// if field which CanAddr is the follow type
+	//  A value is addressable if it is an element of a slice,
+	//  an element of an addressable array, a field of an
+	//  addressable struct, or the result of dereferencing a pointer.
 	addrField = field
 	if field.CanAddr() && field.Kind() != reflect.Ptr {
 		addrField = field.Addr()
@@ -161,7 +166,7 @@ func newFieldInfo(mi *modelInfo, field reflect.Value, sf reflect.StructField, mN
 		}
 	}
 
-	parseStructTag(sf.Tag.Get(defaultStructTagName), &attrs, &tags)
+	attrs, tags = parseStructTag(sf.Tag.Get(defaultStructTagName))
 
 	if _, ok := attrs["-"]; ok {
 		return nil, errSkipField
@@ -187,7 +192,7 @@ checkType:
 		}
 		fieldType = f.FieldType()
 		if fieldType&IsRelField > 0 {
-			err = fmt.Errorf("unsupport rel type custom field")
+			err = fmt.Errorf("unsupport type custom field, please refer to https://github.com/astaxie/beego/blob/master/orm/models_fields.go#L24-L42")
 			goto end
 		}
 	default:
@@ -210,7 +215,7 @@ checkType:
 				}
 				break checkType
 			default:
-				err = fmt.Errorf("error")
+				err = fmt.Errorf("rel only allow these value: fk, one, m2m")
 				goto wrongTag
 			}
 		}
@@ -230,7 +235,7 @@ checkType:
 				}
 				break checkType
 			default:
-				err = fmt.Errorf("error")
+				err = fmt.Errorf("reverse only allow these value: one, many")
 				goto wrongTag
 			}
 		}
@@ -239,8 +244,15 @@ checkType:
 		if err != nil {
 			goto end
 		}
-		if fieldType == TypeCharField && tags["type"] == "text" {
+		if fieldType == TypeCharField {
+			switch tags["type"] {
+			case "text":
 				fieldType = TypeTextField
+			case "json":
+				fieldType = TypeJSONField
+			case "jsonb":
+				fieldType = TypeJsonbField
+			}
 		}
 		if fieldType == TypeFloatField && (digits != "" || decimals != "") {
 			fieldType = TypeDecimalField
@@ -248,8 +260,14 @@ checkType:
 		if fieldType == TypeDateTimeField && tags["type"] == "date" {
 			fieldType = TypeDateField
 		}
+		if fieldType == TypeTimeField && tags["type"] == "time" {
+			fieldType = TypeTimeField
+		}
 	}
 
+	// check the rel and reverse type
+	// rel should Ptr
+	// reverse should slice []*struct
 	switch fieldType {
 	case RelForeignKey, RelOneToOne, RelReverseOne:
 		if field.Kind() != reflect.Ptr {
@@ -339,7 +357,7 @@ checkType:
 
 	switch fieldType {
 	case TypeBooleanField:
-	case TypeCharField:
+	case TypeCharField, TypeJSONField, TypeJsonbField:
 		if size != "" {
 			v, e := StrTo(size).Int32()
 			if e != nil {
@@ -349,11 +367,12 @@ checkType:
 			}
 		} else {
 			fi.size = 255
+			fi.toText = true
 		}
 	case TypeTextField:
 		fi.index = false
 		fi.unique = false
-	case TypeDateField, TypeDateTimeField:
+	case TypeTimeField, TypeDateField, TypeDateTimeField:
 		if attrs["auto_now"] {
 			fi.autoNow = true
 		} else if attrs["auto_now_add"] {
@@ -387,14 +406,12 @@ checkType:
 
 	if fi.auto || fi.pk {
 		if fi.auto {
-
 			switch addrField.Elem().Kind() {
 			case reflect.Int, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint32, reflect.Uint64:
 			default:
 				err = fmt.Errorf("auto primary key only support int, int32, int64, uint, uint32, uint64 but found `%s`", addrField.Elem().Kind())
 				goto end
 			}
-
 			fi.pk = true
 		}
 		fi.null = false
@@ -406,8 +423,8 @@ checkType:
 		fi.index = false
 	}
 
-	if fi.auto || fi.pk || fi.unique || fieldType == TypeDateField || fieldType == TypeDateTimeField {
+	// can not set default for these type
-		// can not set default
+	if fi.auto || fi.pk || fi.unique || fieldType == TypeTimeField || fieldType == TypeDateField || fieldType == TypeDateTimeField {
 		initial.Clear()
 	}
 

orm/models_info_m.go

@@ -29,31 +29,25 @@ type modelInfo struct {
 	model     interface{}
 	fields    *fields
 	manual    bool
-	addrField reflect.Value
+	addrField reflect.Value //store the original struct value
 	uniques   []string
 	isThrough bool
 }
 
 // new model info
-func newModelInfo(val reflect.Value) (info *modelInfo) {
+func newModelInfo(val reflect.Value) (mi *modelInfo) {
-
+	mi = &modelInfo{}
-	info = &modelInfo{}
+	mi.fields = newFields()
-	info.fields = newFields()
-
 	ind := reflect.Indirect(val)
-	typ := ind.Type()
+	mi.addrField = val
-
+	mi.name = ind.Type().Name()
-	info.addrField = val
+	mi.fullName = getFullName(ind.Type())
-
+	addModelFields(mi, ind, "", []int{})
-	info.name = typ.Name()
-	info.fullName = getFullName(typ)
-
-	addModelFields(info, ind, "", []int{})
-
 	return
 }
 
-func addModelFields(info *modelInfo, ind reflect.Value, mName string, index []int) {
+// index: FieldByIndex returns the nested field corresponding to index
+func addModelFields(mi *modelInfo, ind reflect.Value, mName string, index []int) {
 	var (
 		err error
 		fi  *fieldInfo
@@ -63,43 +57,39 @@ func addModelFields(info *modelInfo, ind reflect.Value, mName string, index []in
 	for i := 0; i < ind.NumField(); i++ {
 		field := ind.Field(i)
 		sf = ind.Type().Field(i)
+		// if the field is unexported skip
 		if sf.PkgPath != "" {
 			continue
 		}
 		// add anonymous struct fields
 		if sf.Anonymous {
-			addModelFields(info, field, mName+"."+sf.Name, append(index, i))
+			addModelFields(mi, field, mName+"."+sf.Name, append(index, i))
 			continue
 		}
 
-		fi, err = newFieldInfo(info, field, sf, mName)
+		fi, err = newFieldInfo(mi, field, sf, mName)
-
-		if err != nil {
 		if err == errSkipField {
 			err = nil
 			continue
-			}
+		} else if err != nil {
 			break
 		}
-
+		//record current field index
-		added := info.fields.Add(fi)
+		fi.fieldIndex = append(index, i)
-		if added == false {
+		fi.mi = mi
+		fi.inModel = true
+		if mi.fields.Add(fi) == false {
 			err = fmt.Errorf("duplicate column name: %s", fi.column)
 			break
 		}
-
 		if fi.pk {
-			if info.fields.pk != nil {
+			if mi.fields.pk != nil {
 				err = fmt.Errorf("one model must have one pk field only")
 				break
 			} else {
-				info.fields.pk = fi
+				mi.fields.pk = fi
 			}
 		}
-
-		fi.fieldIndex = append(index, i)
-		fi.mi = info
-		fi.inModel = true
 	}
 
 	if err != nil {
@@ -110,23 +100,23 @@ func addModelFields(info *modelInfo, ind reflect.Value, mName string, index []in
 
 // combine related model info to new model info.
 // prepare for relation models query.
-func newM2MModelInfo(m1, m2 *modelInfo) (info *modelInfo) {
+func newM2MModelInfo(m1, m2 *modelInfo) (mi *modelInfo) {
-	info = new(modelInfo)
+	mi = new(modelInfo)
-	info.fields = newFields()
+	mi.fields = newFields()
-	info.table = m1.table + "_" + m2.table + "s"
+	mi.table = m1.table + "_" + m2.table + "s"
-	info.name = camelString(info.table)
+	mi.name = camelString(mi.table)
-	info.fullName = m1.pkg + "." + info.name
+	mi.fullName = m1.pkg + "." + mi.name
 
-	fa := new(fieldInfo)
+	fa := new(fieldInfo) // pk
-	f1 := new(fieldInfo)
+	f1 := new(fieldInfo) // m1 table RelForeignKey
-	f2 := new(fieldInfo)
+	f2 := new(fieldInfo) // m2 table RelForeignKey
 	fa.fieldType = TypeBigIntegerField
 	fa.auto = true
 	fa.pk = true
 	fa.dbcol = true
 	fa.name = "Id"
 	fa.column = "id"
-	fa.fullName = info.fullName + "." + fa.name
+	fa.fullName = mi.fullName + "." + fa.name
 
 	f1.dbcol = true
 	f2.dbcol = true
@@ -134,8 +124,8 @@ func newM2MModelInfo(m1, m2 *modelInfo) (info *modelInfo) {
 	f2.fieldType = RelForeignKey
 	f1.name = camelString(m1.table)
 	f2.name = camelString(m2.table)
-	f1.fullName = info.fullName + "." + f1.name
+	f1.fullName = mi.fullName + "." + f1.name
-	f2.fullName = info.fullName + "." + f2.name
+	f2.fullName = mi.fullName + "." + f2.name
 	f1.column = m1.table + "_id"
 	f2.column = m2.table + "_id"
 	f1.rel = true
@@ -144,14 +134,14 @@ func newM2MModelInfo(m1, m2 *modelInfo) (info *modelInfo) {
 	f2.relTable = m2.table
 	f1.relModelInfo = m1
 	f2.relModelInfo = m2
-	f1.mi = info
+	f1.mi = mi
-	f2.mi = info
+	f2.mi = mi
 
-	info.fields.Add(fa)
+	mi.fields.Add(fa)
-	info.fields.Add(f1)
+	mi.fields.Add(f1)
-	info.fields.Add(f2)
+	mi.fields.Add(f2)
-	info.fields.pk = fa
+	mi.fields.pk = fa
 
-	info.uniques = []string{f1.column, f2.column}
+	mi.uniques = []string{f1.column, f2.column}
 	return
 }

orm/models_test.go

@@ -78,40 +78,43 @@ func (e *SliceStringField) RawValue() interface{} {
 var _ Fielder = new(SliceStringField)
 
 // A json field.
-type JSONField struct {
+type JSONFieldTest struct {
 	Name string
 	Data string
 }
 
-func (e *JSONField) String() string {
+func (e *JSONFieldTest) String() string {
 	data, _ := json.Marshal(e)
 	return string(data)
 }
 
-func (e *JSONField) FieldType() int {
+func (e *JSONFieldTest) FieldType() int {
 	return TypeTextField
 }
 
-func (e *JSONField) SetRaw(value interface{}) error {
+func (e *JSONFieldTest) SetRaw(value interface{}) error {
 	switch d := value.(type) {
 	case string:
 		return json.Unmarshal([]byte(d), e)
 	default:
-		return fmt.Errorf("<JsonField.SetRaw> unknown value `%v`", value)
+		return fmt.Errorf("<JSONField.SetRaw> unknown value `%v`", value)
 	}
 }
 
-func (e *JSONField) RawValue() interface{} {
+func (e *JSONFieldTest) RawValue() interface{} {
 	return e.String()
 }
 
-var _ Fielder = new(JSONField)
+var _ Fielder = new(JSONFieldTest)
 
 type Data struct {
 	ID       int `orm:"column(id)"`
 	Boolean  bool
 	Char     string    `orm:"size(50)"`
 	Text     string    `orm:"type(text)"`
+	JSON     string    `orm:"type(json);default({\"name\":\"json\"})"`
+	Jsonb    string    `orm:"type(jsonb)"`
+	Time     time.Time `orm:"type(time)"`
 	Date     time.Time `orm:"type(date)"`
 	DateTime time.Time `orm:"column(datetime)"`
 	Byte     byte
@@ -136,6 +139,9 @@ type DataNull struct {
 	Boolean     bool            `orm:"null"`
 	Char        string          `orm:"null;size(50)"`
 	Text        string          `orm:"null;type(text)"`
+	JSON        string          `orm:"type(json);null"`
+	Jsonb       string          `orm:"type(jsonb);null"`
+	Time        time.Time       `orm:"null;type(time)"`
 	Date        time.Time       `orm:"null;type(date)"`
 	DateTime    time.Time       `orm:"null;column(datetime)"`
 	Byte        byte            `orm:"null"`
@@ -175,6 +181,9 @@ type DataNull struct {
 	Float32Ptr  *float32        `orm:"null"`
 	Float64Ptr  *float64        `orm:"null"`
 	DecimalPtr  *float64        `orm:"digits(8);decimals(4);null"`
+	TimePtr     *time.Time      `orm:"null;type(time)"`
+	DatePtr     *time.Time      `orm:"null;type(date)"`
+	DateTimePtr *time.Time      `orm:"null"`
 }
 
 type String string
@@ -237,7 +246,7 @@ type User struct {
 	ShouldSkip   string    `orm:"-"`
 	Nums         int
 	Langs        SliceStringField `orm:"size(100)"`
-	Extra        JSONField        `orm:"type(text)"`
+	Extra        JSONFieldTest    `orm:"type(text)"`
 	unexport     bool             `orm:"-"`
 	unexportBool bool
 }
@@ -375,6 +384,33 @@ func NewInLine() *InLine {
 	return new(InLine)
 }
 
+type InLineOneToOne struct {
+	// Common Fields
+	ModelBase
+
+	Note   string
+	InLine *InLine `orm:"rel(fk);column(inline)"`
+}
+
+func NewInLineOneToOne() *InLineOneToOne {
+	return new(InLineOneToOne)
+}
+
+type IntegerPk struct {
+	ID    int64 `orm:"pk"`
+	Value string
+}
+
+type UintPk struct {
+	ID   uint32 `orm:"pk"`
+	Name string
+}
+
+type PtrPk struct {
+	ID       *IntegerPk `orm:"pk;rel(one)"`
+	Positive bool
+}
+
 var DBARGS = struct {
 	Driver string
 	Source string

orm/models_utils.go

@@ -22,25 +22,47 @@ import (
 	"time"
 )
 
+// 1 is attr
+// 2 is tag
+var supportTag = map[string]int{
+	"-":            1,
+	"null":         1,
+	"index":        1,
+	"unique":       1,
+	"pk":           1,
+	"auto":         1,
+	"auto_now":     1,
+	"auto_now_add": 1,
+	"size":         2,
+	"column":       2,
+	"default":      2,
+	"rel":          2,
+	"reverse":      2,
+	"rel_table":    2,
+	"rel_through":  2,
+	"digits":       2,
+	"decimals":     2,
+	"on_delete":    2,
+	"type":         2,
+}
+
 // get reflect.Type name with package path.
 func getFullName(typ reflect.Type) string {
 	return typ.PkgPath() + "." + typ.Name()
 }
 
-// get table name. method, or field name. auto snaked.
+// getTableName get struct table name.
+// If the struct implement the TableName, then get the result as tablename
+// else use the struct name which will apply snakeString.
 func getTableName(val reflect.Value) string {
-	ind := reflect.Indirect(val)
+	if fun := val.MethodByName("TableName"); fun.IsValid() {
-	fun := val.MethodByName("TableName")
-	if fun.IsValid() {
 		vals := fun.Call([]reflect.Value{})
-		if len(vals) > 0 {
+		// has return and the first val is string
-			val := vals[0]
+		if len(vals) > 0 && vals[0].Kind() == reflect.String {
-			if val.Kind() == reflect.String {
+			return vals[0].String()
-				return val.String()
 		}
 	}
-	}
+	return snakeString(reflect.Indirect(val).Type().Name())
-	return snakeString(ind.Type().Name())
 }
 
 // get table engine, mysiam or innodb.
@@ -48,11 +70,8 @@ func getTableEngine(val reflect.Value) string {
 	fun := val.MethodByName("TableEngine")
 	if fun.IsValid() {
 		vals := fun.Call([]reflect.Value{})
-		if len(vals) > 0 {
+		if len(vals) > 0 && vals[0].Kind() == reflect.String {
-			val := vals[0]
+			return vals[0].String()
-			if val.Kind() == reflect.String {
-				return val.String()
-			}
 		}
 	}
 	return ""
@@ -63,15 +82,12 @@ func getTableIndex(val reflect.Value) [][]string {
 	fun := val.MethodByName("TableIndex")
 	if fun.IsValid() {
 		vals := fun.Call([]reflect.Value{})
-		if len(vals) > 0 {
+		if len(vals) > 0 && vals[0].CanInterface() {
-			val := vals[0]
+			if d, ok := vals[0].Interface().([][]string); ok {
-			if val.CanInterface() {
-				if d, ok := val.Interface().([][]string); ok {
 				return d
 			}
 		}
 	}
-	}
 	return nil
 }
 
@@ -80,15 +96,12 @@ func getTableUnique(val reflect.Value) [][]string {
 	fun := val.MethodByName("TableUnique")
 	if fun.IsValid() {
 		vals := fun.Call([]reflect.Value{})
-		if len(vals) > 0 {
+		if len(vals) > 0 && vals[0].CanInterface() {
-			val := vals[0]
+			if d, ok := vals[0].Interface().([][]string); ok {
-			if val.CanInterface() {
-				if d, ok := val.Interface().([][]string); ok {
 				return d
 			}
 		}
 	}
-	}
 	return nil
 }
 
@@ -137,6 +150,8 @@ func getFieldType(val reflect.Value) (ft int, err error) {
 		ft = TypeBooleanField
 	case reflect.TypeOf(new(string)):
 		ft = TypeCharField
+	case reflect.TypeOf(new(time.Time)):
+		ft = TypeDateTimeField
 	default:
 		elm := reflect.Indirect(val)
 		switch elm.Kind() {
@@ -187,21 +202,25 @@ func getFieldType(val reflect.Value) (ft int, err error) {
 }
 
 // parse struct tag string
-func parseStructTag(data string, attrs *map[string]bool, tags *map[string]string) {
+func parseStructTag(data string) (attrs map[string]bool, tags map[string]string) {
-	attr := make(map[string]bool)
+	attrs = make(map[string]bool)
-	tag := make(map[string]string)
+	tags = make(map[string]string)
 	for _, v := range strings.Split(data, defaultStructTagDelim) {
+		if v == "" {
+			continue
+		}
 		v = strings.TrimSpace(v)
-		if supportTag[v] == 1 {
+		if t := strings.ToLower(v); supportTag[t] == 1 {
-			attr[v] = true
+			attrs[t] = true
 		} else if i := strings.Index(v, "("); i > 0 && strings.Index(v, ")") == len(v)-1 {
-			name := v[:i]
+			name := t[:i]
 			if supportTag[name] == 2 {
 				v = v[i+1 : len(v)-1]
-				tag[name] = v
+				tags[name] = v
+			}
+		} else {
+			DebugLog.Println("unsupport orm tag", v)
 		}
 	}
-	}
+	return
-	*attrs = attr
-	*tags = tag
 }

orm/orm.go

@@ -68,7 +68,7 @@ const (
 // Define common vars
 var (
 	Debug            = false
-	DebugLog         = NewLog(os.Stderr)
+	DebugLog         = NewLog(os.Stdout)
 	DefaultRowsLimit = 1000
 	DefaultRelsDepth = 2
 	DefaultTimeLoc   = time.Local
@@ -104,7 +104,7 @@ func (o *orm) getMiInd(md interface{}, needPtr bool) (mi *modelInfo, ind reflect
 		panic(fmt.Errorf("<Ormer> cannot use non-ptr model struct `%s`", getFullName(typ)))
 	}
 	name := getFullName(typ)
-	if mi, ok := modelCache.getByFN(name); ok {
+	if mi, ok := modelCache.getByFullName(name); ok {
 		return mi, ind
 	}
 	panic(fmt.Errorf("<Ormer> table: `%s` not found, maybe not RegisterModel", name))
@@ -122,7 +122,17 @@ func (o *orm) getFieldInfo(mi *modelInfo, name string) *fieldInfo {
 // read data to model
 func (o *orm) Read(md interface{}, cols ...string) error {
 	mi, ind := o.getMiInd(md, true)
-	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols)
+	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols, false)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// read data to model, like Read(), but use "SELECT FOR UPDATE" form
+func (o *orm) ReadForUpdate(md interface{}, cols ...string) error {
+	mi, ind := o.getMiInd(md, true)
+	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols, true)
 	if err != nil {
 		return err
 	}
@@ -133,14 +143,23 @@ func (o *orm) Read(md interface{}, cols ...string) error {
 func (o *orm) ReadOrCreate(md interface{}, col1 string, cols ...string) (bool, int64, error) {
 	cols = append([]string{col1}, cols...)
 	mi, ind := o.getMiInd(md, true)
-	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols)
+	err := o.alias.DbBaser.Read(o.db, mi, ind, o.alias.TZ, cols, false)
 	if err == ErrNoRows {
 		// Create
 		id, err := o.Insert(md)
 		return (err == nil), id, err
 	}
 
-	return false, ind.FieldByIndex(mi.fields.pk.fieldIndex).Int(), err
+	id, vid := int64(0), ind.FieldByIndex(mi.fields.pk.fieldIndex)
+	if mi.fields.pk.fieldType&IsPositiveIntegerField > 0 {
+		id = int64(vid.Uint())
+	} else if mi.fields.pk.rel {
+		return o.ReadOrCreate(vid.Interface(), mi.fields.pk.relModelInfo.fields.pk.name)
+	} else {
+		id = vid.Int()
+	}
+
+	return false, id, err
 }
 
 // insert model data to database
@@ -159,7 +178,7 @@ func (o *orm) Insert(md interface{}) (int64, error) {
 // set auto pk field
 func (o *orm) setPk(mi *modelInfo, ind reflect.Value, id int64) {
 	if mi.fields.pk.auto {
-		if mi.fields.pk.fieldType&IsPostiveIntegerField > 0 {
+		if mi.fields.pk.fieldType&IsPositiveIntegerField > 0 {
 			ind.FieldByIndex(mi.fields.pk.fieldIndex).SetUint(uint64(id))
 		} else {
 			ind.FieldByIndex(mi.fields.pk.fieldIndex).SetInt(id)
@@ -184,7 +203,7 @@ func (o *orm) InsertMulti(bulk int, mds interface{}) (int64, error) {
 
 	if bulk <= 1 {
 		for i := 0; i < sind.Len(); i++ {
-			ind := sind.Index(i)
+			ind := reflect.Indirect(sind.Index(i))
 			mi, _ := o.getMiInd(ind.Interface(), false)
 			id, err := o.alias.DbBaser.Insert(o.db, mi, ind, o.alias.TZ)
 			if err != nil {
@@ -202,6 +221,19 @@ func (o *orm) InsertMulti(bulk int, mds interface{}) (int64, error) {
 	return cnt, nil
 }
 
+// InsertOrUpdate data to database
+func (o *orm) InsertOrUpdate(md interface{}, colConflitAndArgs ...string) (int64, error) {
+	mi, ind := o.getMiInd(md, true)
+	id, err := o.alias.DbBaser.InsertOrUpdate(o.db, mi, ind, o.alias, colConflitAndArgs...)
+	if err != nil {
+		return id, err
+	}
+
+	o.setPk(mi, ind, id)
+
+	return id, nil
+}
+
 // update model to database.
 // cols set the columns those want to update.
 func (o *orm) Update(md interface{}, cols ...string) (int64, error) {
@@ -214,9 +246,10 @@ func (o *orm) Update(md interface{}, cols ...string) (int64, error) {
 }
 
 // delete model in database
-func (o *orm) Delete(md interface{}) (int64, error) {
+// cols shows the delete conditions values read from. deafult is pk
+func (o *orm) Delete(md interface{}, cols ...string) (int64, error) {
 	mi, ind := o.getMiInd(md, true)
-	num, err := o.alias.DbBaser.Delete(o.db, mi, ind, o.alias.TZ)
+	num, err := o.alias.DbBaser.Delete(o.db, mi, ind, o.alias.TZ, cols)
 	if err != nil {
 		return num, err
 	}
@@ -407,7 +440,7 @@ func (o *orm) QueryTable(ptrStructOrTableName interface{}) (qs QuerySeter) {
 		}
 	} else {
 		name = getFullName(indirectType(reflect.TypeOf(ptrStructOrTableName)))
-		if mi, ok := modelCache.getByFN(name); ok {
+		if mi, ok := modelCache.getByFullName(name); ok {
 			qs = newQuerySet(o, mi)
 		}
 	}

orm/orm_conds.go

@@ -75,6 +75,19 @@ func (c *Condition) AndCond(cond *Condition) *Condition {
 	return c
 }
 
+// AndNotCond combine a AND NOT condition to current condition
+func (c *Condition) AndNotCond(cond *Condition) *Condition {
+	c = c.clone()
+	if c == cond {
+		panic(fmt.Errorf("<Condition.AndNotCond> cannot use self as sub cond"))
+	}
+
+	if cond != nil {
+		c.params = append(c.params, condValue{cond: cond, isCond: true, isNot: true})
+	}
+	return c
+}
+
 // Or add OR expression to condition
 func (c Condition) Or(expr string, args ...interface{}) *Condition {
 	if expr == "" || len(args) == 0 {
@@ -105,6 +118,19 @@ func (c *Condition) OrCond(cond *Condition) *Condition {
 	return c
 }
 
+// OrNotCond combine a OR NOT condition to current condition
+func (c *Condition) OrNotCond(cond *Condition) *Condition {
+	c = c.clone()
+	if c == cond {
+		panic(fmt.Errorf("<Condition.OrNotCond> cannot use self as sub cond"))
+	}
+
+	if cond != nil {
+		c.params = append(c.params, condValue{cond: cond, isCond: true, isNot: true, isOr: true})
+	}
+	return c
+}
+
 // IsEmpty check the condition arguments are empty or not.
 func (c *Condition) IsEmpty() bool {
 	return len(c.params) == 0

orm/orm_log.go

@@ -31,7 +31,7 @@ type Log struct {
 // NewLog set io.Writer to create a Logger.
 func NewLog(out io.Writer) *Log {
 	d := new(Log)
-	d.Logger = log.New(out, "[ORM]", 1e9)
+	d.Logger = log.New(out, "[ORM]", log.LstdFlags)
 	return d
 }
 
@@ -42,7 +42,7 @@ func debugLogQueies(alias *alias, operaton, query string, t time.Time, err error
 	if err != nil {
 		flag = "FAIL"
 	}
-	con := fmt.Sprintf(" - %s - [Queries/%s] - [%s / %11s / %7.1fms] - [%s]", t.Format(formatDateTime), alias.Name, flag, operaton, elsp, query)
+	con := fmt.Sprintf(" -[Queries/%s] - [%s / %11s / %7.1fms] - [%s]", alias.Name, flag, operaton, elsp, query)
 	cons := make([]string, 0, len(args))
 	for _, arg := range args {
 		cons = append(cons, fmt.Sprintf("%v", arg))

orm/orm_object.go

@@ -50,7 +50,7 @@ func (o *insertSet) Insert(md interface{}) (int64, error) {
 	}
 	if id > 0 {
 		if o.mi.fields.pk.auto {
-			if o.mi.fields.pk.fieldType&IsPostiveIntegerField > 0 {
+			if o.mi.fields.pk.fieldType&IsPositiveIntegerField > 0 {
 				ind.FieldByIndex(o.mi.fields.pk.fieldIndex).SetUint(uint64(id))
 			} else {
 				ind.FieldByIndex(o.mi.fields.pk.fieldIndex).SetInt(id)

orm/orm_queryset.go

@@ -153,6 +153,11 @@ func (o querySet) SetCond(cond *Condition) QuerySeter {
 	return &o
 }
 
+// get condition from QuerySeter
+func (o querySet) GetCond() *Condition {
+	return o.cond
+}
+
 // return QuerySeter execution result number
 func (o *querySet) Count() (int64, error) {
 	return o.orm.alias.DbBaser.Count(o.orm.db, o, o.mi, o.cond, o.orm.alias.TZ)
@@ -192,16 +197,18 @@ func (o *querySet) All(container interface{}, cols ...string) (int64, error) {
 // query one row data and map to containers.
 // cols means the columns when querying.
 func (o *querySet) One(container interface{}, cols ...string) error {
+	o.limit = 1
 	num, err := o.orm.alias.DbBaser.ReadBatch(o.orm.db, o, o.mi, o.cond, container, o.orm.alias.TZ, cols)
 	if err != nil {
 		return err
 	}
-	if num > 1 {
-		return ErrMultiRows
-	}
 	if num == 0 {
 		return ErrNoRows
 	}
+
+	if num > 1 {
+		return ErrMultiRows
+	}
 	return nil
 }
 

orm/orm_raw.go

@@ -286,7 +286,7 @@ func (o *rawSet) QueryRow(containers ...interface{}) error {
 
 			structMode = true
 			fn := getFullName(typ)
-			if mi, ok := modelCache.getByFN(fn); ok {
+			if mi, ok := modelCache.getByFullName(fn); ok {
 				sMi = mi
 			}
 		} else {
@@ -342,19 +342,22 @@ func (o *rawSet) QueryRow(containers ...interface{}) error {
 				for _, col := range columns {
 					if fi := sMi.fields.GetByColumn(col); fi != nil {
 						value := reflect.ValueOf(columnsMp[col]).Elem().Interface()
-						o.setFieldValue(ind.FieldByIndex(fi.fieldIndex), value)
+						field := ind.FieldByIndex(fi.fieldIndex)
+						if fi.fieldType&IsRelField > 0 {
+							mf := reflect.New(fi.relModelInfo.addrField.Elem().Type())
+							field.Set(mf)
+							field = mf.Elem().FieldByIndex(fi.relModelInfo.fields.pk.fieldIndex)
+						}
+						o.setFieldValue(field, value)
 					}
 				}
 			} else {
 				for i := 0; i < ind.NumField(); i++ {
 					f := ind.Field(i)
 					fe := ind.Type().Field(i)
-
+					_, tags := parseStructTag(fe.Tag.Get(defaultStructTagName))
-					var attrs map[string]bool
-					var tags map[string]string
-					parseStructTag(fe.Tag.Get("orm"), &attrs, &tags)
 					var col string
-					if col = tags["column"]; len(col) == 0 {
+					if col = tags["column"]; col == "" {
 						col = snakeString(fe.Name)
 					}
 					if v, ok := columnsMp[col]; ok {
@@ -416,7 +419,7 @@ func (o *rawSet) QueryRows(containers ...interface{}) (int64, error) {
 
 			structMode = true
 			fn := getFullName(typ)
-			if mi, ok := modelCache.getByFN(fn); ok {
+			if mi, ok := modelCache.getByFullName(fn); ok {
 				sMi = mi
 			}
 		} else {
@@ -480,19 +483,22 @@ func (o *rawSet) QueryRows(containers ...interface{}) (int64, error) {
 				for _, col := range columns {
 					if fi := sMi.fields.GetByColumn(col); fi != nil {
 						value := reflect.ValueOf(columnsMp[col]).Elem().Interface()
-						o.setFieldValue(ind.FieldByIndex(fi.fieldIndex), value)
+						field := ind.FieldByIndex(fi.fieldIndex)
+						if fi.fieldType&IsRelField > 0 {
+							mf := reflect.New(fi.relModelInfo.addrField.Elem().Type())
+							field.Set(mf)
+							field = mf.Elem().FieldByIndex(fi.relModelInfo.fields.pk.fieldIndex)
+						}
+						o.setFieldValue(field, value)
 					}
 				}
 			} else {
 				for i := 0; i < ind.NumField(); i++ {
 					f := ind.Field(i)
 					fe := ind.Type().Field(i)
-
+					_, tags := parseStructTag(fe.Tag.Get(defaultStructTagName))
-					var attrs map[string]bool
-					var tags map[string]string
-					parseStructTag(fe.Tag.Get("orm"), &attrs, &tags)
 					var col string
-					if col = tags["column"]; len(col) == 0 {
+					if col = tags["column"]; col == "" {
 						col = snakeString(fe.Name)
 					}
 					if v, ok := columnsMp[col]; ok {

orm/orm_test.go

@@ -19,6 +19,7 @@ import (
 	"database/sql"
 	"fmt"
 	"io/ioutil"
+	"math"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -33,6 +34,7 @@ var _ = os.PathSeparator
 var (
 	testDate     = formatDate + " -0700"
 	testDateTime = formatDateTime + " -0700"
+	testTime     = formatTime + " -0700"
 )
 
 type argAny []interface{}
@@ -188,6 +190,10 @@ func TestSyncDb(t *testing.T) {
 	RegisterModel(new(Permission))
 	RegisterModel(new(GroupPermissions))
 	RegisterModel(new(InLine))
+	RegisterModel(new(InLineOneToOne))
+	RegisterModel(new(IntegerPk))
+	RegisterModel(new(UintPk))
+	RegisterModel(new(PtrPk))
 
 	err := RunSyncdb("default", true, Debug)
 	throwFail(t, err)
@@ -208,6 +214,10 @@ func TestRegisterModels(t *testing.T) {
 	RegisterModel(new(Permission))
 	RegisterModel(new(GroupPermissions))
 	RegisterModel(new(InLine))
+	RegisterModel(new(InLineOneToOne))
+	RegisterModel(new(IntegerPk))
+	RegisterModel(new(UintPk))
+	RegisterModel(new(PtrPk))
 
 	BootStrap()
 
@@ -219,7 +229,7 @@ func TestModelSyntax(t *testing.T) {
 	user := &User{}
 	ind := reflect.ValueOf(user).Elem()
 	fn := getFullName(ind.Type())
-	mi, ok := modelCache.getByFN(fn)
+	mi, ok := modelCache.getByFullName(fn)
 	throwFail(t, AssertIs(ok, true))
 
 	mi, ok = modelCache.get("user")
@@ -233,6 +243,9 @@ var DataValues = map[string]interface{}{
 	"Boolean":  true,
 	"Char":     "char",
 	"Text":     "text",
+	"JSON":     `{"name":"json"}`,
+	"Jsonb":    `{"name": "jsonb"}`,
+	"Time":     time.Now(),
 	"Date":     time.Now(),
 	"DateTime": time.Now(),
 	"Byte":     byte(1<<8 - 1),
@@ -257,10 +270,12 @@ func TestDataTypes(t *testing.T) {
 	ind := reflect.Indirect(reflect.ValueOf(&d))
 
 	for name, value := range DataValues {
+		if name == "JSON" {
+			continue
+		}
 		e := ind.FieldByName(name)
 		e.Set(reflect.ValueOf(value))
 	}
-
 	id, err := dORM.Insert(&d)
 	throwFail(t, err)
 	throwFail(t, AssertIs(id, 1))
@@ -281,6 +296,9 @@ func TestDataTypes(t *testing.T) {
 		case "DateTime":
 			vu = vu.(time.Time).In(DefaultTimeLoc).Format(testDateTime)
 			value = value.(time.Time).In(DefaultTimeLoc).Format(testDateTime)
+		case "Time":
+			vu = vu.(time.Time).In(DefaultTimeLoc).Format(testTime)
+			value = value.(time.Time).In(DefaultTimeLoc).Format(testTime)
 		}
 		throwFail(t, AssertIs(vu == value, true), value, vu)
 	}
@@ -299,10 +317,18 @@ func TestNullDataTypes(t *testing.T) {
 	throwFail(t, err)
 	throwFail(t, AssertIs(id, 1))
 
+	data := `{"ok":1,"data":{"arr":[1,2],"msg":"gopher"}}`
+	d = DataNull{ID: 1, JSON: data}
+	num, err := dORM.Update(&d)
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 1))
+
 	d = DataNull{ID: 1}
 	err = dORM.Read(&d)
 	throwFail(t, err)
 
+	throwFail(t, AssertIs(d.JSON, data))
+
 	throwFail(t, AssertIs(d.NullBool.Valid, false))
 	throwFail(t, AssertIs(d.NullString.Valid, false))
 	throwFail(t, AssertIs(d.NullInt64.Valid, false))
@@ -326,6 +352,9 @@ func TestNullDataTypes(t *testing.T) {
 	throwFail(t, AssertIs(d.Float32Ptr, nil))
 	throwFail(t, AssertIs(d.Float64Ptr, nil))
 	throwFail(t, AssertIs(d.DecimalPtr, nil))
+	throwFail(t, AssertIs(d.TimePtr, nil))
+	throwFail(t, AssertIs(d.DatePtr, nil))
+	throwFail(t, AssertIs(d.DateTimePtr, nil))
 
 	_, err = dORM.Raw(`INSERT INTO data_null (boolean) VALUES (?)`, nil).Exec()
 	throwFail(t, err)
@@ -352,6 +381,9 @@ func TestNullDataTypes(t *testing.T) {
 	float32Ptr := float32(42.0)
 	float64Ptr := float64(42.0)
 	decimalPtr := float64(42.0)
+	timePtr := time.Now()
+	datePtr := time.Now()
+	dateTimePtr := time.Now()
 
 	d = DataNull{
 		DateTime:    time.Now(),
@@ -377,6 +409,9 @@ func TestNullDataTypes(t *testing.T) {
 		Float32Ptr:  &float32Ptr,
 		Float64Ptr:  &float64Ptr,
 		DecimalPtr:  &decimalPtr,
+		TimePtr:     &timePtr,
+		DatePtr:     &datePtr,
+		DateTimePtr: &dateTimePtr,
 	}
 
 	id, err = dORM.Insert(&d)
@@ -417,6 +452,9 @@ func TestNullDataTypes(t *testing.T) {
 	throwFail(t, AssertIs(*d.Float32Ptr, float32Ptr))
 	throwFail(t, AssertIs(*d.Float64Ptr, float64Ptr))
 	throwFail(t, AssertIs(*d.DecimalPtr, decimalPtr))
+	throwFail(t, AssertIs((*d.TimePtr).Format(testTime), timePtr.Format(testTime)))
+	throwFail(t, AssertIs((*d.DatePtr).Format(testDate), datePtr.Format(testDate)))
+	throwFail(t, AssertIs((*d.DateTimePtr).Format(testDateTime), dateTimePtr.Format(testDateTime)))
 }
 
 func TestDataCustomTypes(t *testing.T) {
@@ -541,6 +579,10 @@ func TestCRUD(t *testing.T) {
 	err = dORM.Read(&ub)
 	throwFail(t, err)
 	throwFail(t, AssertIs(ub.Name, "name"))
+
+	num, err = dORM.Delete(&ub, "name")
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 1))
 }
 
 func TestInsertTestData(t *testing.T) {
@@ -869,6 +911,16 @@ func TestSetCond(t *testing.T) {
 	num, err = qs.SetCond(cond2).Count()
 	throwFail(t, err)
 	throwFail(t, AssertIs(num, 2))
+
+	cond3 := cond.AndNotCond(cond.And("status__in", 1))
+	num, err = qs.SetCond(cond3).Count()
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 2))
+
+	cond4 := cond.And("user_name", "slene").OrNotCond(cond.And("user_name", "slene"))
+	num, err = qs.SetCond(cond4).Count()
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 3))
 }
 
 func TestLimit(t *testing.T) {
@@ -969,12 +1021,19 @@ func TestOne(t *testing.T) {
 	var user User
 	qs := dORM.QueryTable("user")
 	err := qs.One(&user)
-	throwFail(t, AssertIs(err, ErrMultiRows))
+	throwFail(t, err)
 
 	user = User{}
 	err = qs.OrderBy("Id").Limit(1).One(&user)
 	throwFailNow(t, err)
 	throwFail(t, AssertIs(user.UserName, "slene"))
+	throwFail(t, AssertNot(err, ErrMultiRows))
+
+	user = User{}
+	err = qs.OrderBy("-Id").Limit(100).One(&user)
+	throwFailNow(t, err)
+	throwFail(t, AssertIs(user.UserName, "nobody"))
+	throwFail(t, AssertNot(err, ErrMultiRows))
 
 	err = qs.Filter("user_name", "nothing").One(&user)
 	throwFail(t, AssertIs(err, ErrNoRows))
@@ -1514,6 +1573,7 @@ func TestRawQueryRow(t *testing.T) {
 		Boolean  bool
 		Char     string
 		Text     string
+		Time     time.Time
 		Date     time.Time
 		DateTime time.Time
 		Byte     byte
@@ -1542,14 +1602,14 @@ func TestRawQueryRow(t *testing.T) {
 	Q := dDbBaser.TableQuote()
 
 	cols := []string{
-		"id", "boolean", "char", "text", "date", "datetime", "byte", "rune", "int", "int8", "int16", "int32",
+		"id", "boolean", "char", "text", "time", "date", "datetime", "byte", "rune", "int", "int8", "int16", "int32",
 		"int64", "uint", "uint8", "uint16", "uint32", "uint64", "float32", "float64", "decimal",
 	}
 	sep := fmt.Sprintf("%s, %s", Q, Q)
 	query := fmt.Sprintf("SELECT %s%s%s FROM data WHERE id = ?", Q, strings.Join(cols, sep), Q)
 	var id int
 	values := []interface{}{
-		&id, &Boolean, &Char, &Text, &Date, &DateTime, &Byte, &Rune, &Int, &Int8, &Int16, &Int32,
+		&id, &Boolean, &Char, &Text, &Time, &Date, &DateTime, &Byte, &Rune, &Int, &Int8, &Int16, &Int32,
 		&Int64, &Uint, &Uint8, &Uint16, &Uint32, &Uint64, &Float32, &Float64, &Decimal,
 	}
 	err := dORM.Raw(query, 1).QueryRow(values...)
@@ -1560,6 +1620,10 @@ func TestRawQueryRow(t *testing.T) {
 		switch col {
 		case "id":
 			throwFail(t, AssertIs(id, 1))
+		case "time":
+			v = v.(time.Time).In(DefaultTimeLoc)
+			value := dataValues[col].(time.Time).In(DefaultTimeLoc)
+			throwFail(t, AssertIs(v, value, testTime))
 		case "date":
 			v = v.(time.Time).In(DefaultTimeLoc)
 			value := dataValues[col].(time.Time).In(DefaultTimeLoc)
@@ -1607,6 +1671,9 @@ func TestQueryRows(t *testing.T) {
 		e := ind.FieldByName(name)
 		vu := e.Interface()
 		switch name {
+		case "Time":
+			vu = vu.(time.Time).In(DefaultTimeLoc).Format(testTime)
+			value = value.(time.Time).In(DefaultTimeLoc).Format(testTime)
 		case "Date":
 			vu = vu.(time.Time).In(DefaultTimeLoc).Format(testDate)
 			value = value.(time.Time).In(DefaultTimeLoc).Format(testDate)
@@ -1631,6 +1698,9 @@ func TestQueryRows(t *testing.T) {
 		e := ind.FieldByName(name)
 		vu := e.Interface()
 		switch name {
+		case "Time":
+			vu = vu.(time.Time).In(DefaultTimeLoc).Format(testTime)
+			value = value.(time.Time).In(DefaultTimeLoc).Format(testTime)
 		case "Date":
 			vu = vu.(time.Time).In(DefaultTimeLoc).Format(testDate)
 			value = value.(time.Time).In(DefaultTimeLoc).Format(testDate)
@@ -1952,3 +2022,299 @@ func TestInLine(t *testing.T) {
 	throwFail(t, AssertIs(il.Created.In(DefaultTimeLoc), inline.Created.In(DefaultTimeLoc), testDate))
 	throwFail(t, AssertIs(il.Updated.In(DefaultTimeLoc), inline.Updated.In(DefaultTimeLoc), testDateTime))
 }
+
+func TestInLineOneToOne(t *testing.T) {
+	name := "121"
+	email := "121@go.com"
+	inline := NewInLine()
+	inline.Name = name
+	inline.Email = email
+
+	id, err := dORM.Insert(inline)
+	throwFail(t, err)
+	throwFail(t, AssertIs(id, 2))
+
+	note := "one2one"
+	il121 := NewInLineOneToOne()
+	il121.Note = note
+	il121.InLine = inline
+	_, err = dORM.Insert(il121)
+	throwFail(t, err)
+	throwFail(t, AssertIs(il121.ID, 1))
+
+	il := NewInLineOneToOne()
+	err = dORM.QueryTable(il).Filter("Id", 1).RelatedSel().One(il)
+
+	throwFail(t, err)
+	throwFail(t, AssertIs(il.Note, note))
+	throwFail(t, AssertIs(il.InLine.ID, id))
+	throwFail(t, AssertIs(il.InLine.Name, name))
+	throwFail(t, AssertIs(il.InLine.Email, email))
+
+	rinline := NewInLine()
+	err = dORM.QueryTable(rinline).Filter("InLineOneToOne__Id", 1).One(rinline)
+
+	throwFail(t, err)
+	throwFail(t, AssertIs(rinline.ID, id))
+	throwFail(t, AssertIs(rinline.Name, name))
+	throwFail(t, AssertIs(rinline.Email, email))
+}
+
+func TestIntegerPk(t *testing.T) {
+	its := []IntegerPk{
+		{ID: math.MinInt64, Value: "-"},
+		{ID: 0, Value: "0"},
+		{ID: math.MaxInt64, Value: "+"},
+	}
+
+	num, err := dORM.InsertMulti(len(its), its)
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, len(its)))
+
+	for _, intPk := range its {
+		out := IntegerPk{ID: intPk.ID}
+		err = dORM.Read(&out)
+		throwFail(t, err)
+		throwFail(t, AssertIs(out.Value, intPk.Value))
+	}
+
+	num, err = dORM.InsertMulti(1, []*IntegerPk{{
+		ID: 1, Value: "ok",
+	}})
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 1))
+}
+
+func TestInsertAuto(t *testing.T) {
+	u := &User{
+		UserName: "autoPre",
+		Email:    "autoPre@gmail.com",
+	}
+
+	id, err := dORM.Insert(u)
+	throwFail(t, err)
+
+	id += 100
+	su := &User{
+		ID:       int(id),
+		UserName: "auto",
+		Email:    "auto@gmail.com",
+	}
+
+	nid, err := dORM.Insert(su)
+	throwFail(t, err)
+	throwFail(t, AssertIs(nid, id))
+
+	users := []User{
+		{ID: int(id + 100), UserName: "auto_100"},
+		{ID: int(id + 110), UserName: "auto_110"},
+		{ID: int(id + 120), UserName: "auto_120"},
+	}
+	num, err := dORM.InsertMulti(100, users)
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 3))
+
+	u = &User{
+		UserName: "auto_121",
+	}
+
+	nid, err = dORM.Insert(u)
+	throwFail(t, err)
+	throwFail(t, AssertIs(nid, id+120+1))
+}
+
+func TestUintPk(t *testing.T) {
+	name := "go"
+	u := &UintPk{
+		ID:   8,
+		Name: name,
+	}
+
+	created, pk, err := dORM.ReadOrCreate(u, "ID")
+	throwFail(t, err)
+	throwFail(t, AssertIs(created, true))
+	throwFail(t, AssertIs(u.Name, name))
+
+	nu := &UintPk{ID: 8}
+	created, pk, err = dORM.ReadOrCreate(nu, "ID")
+	throwFail(t, err)
+	throwFail(t, AssertIs(created, false))
+	throwFail(t, AssertIs(nu.ID, u.ID))
+	throwFail(t, AssertIs(pk, u.ID))
+	throwFail(t, AssertIs(nu.Name, name))
+
+	dORM.Delete(u)
+}
+
+func TestPtrPk(t *testing.T) {
+	parent := &IntegerPk{ID: 10, Value: "10"}
+
+	id, _ := dORM.Insert(parent)
+	if !IsMysql {
+		// MySql does not support last_insert_id in this case: see #2382
+		throwFail(t, AssertIs(id, 10))
+	}
+
+	ptr := PtrPk{ID: parent, Positive: true}
+	num, err := dORM.InsertMulti(2, []PtrPk{ptr})
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 1))
+	throwFail(t, AssertIs(ptr.ID, parent))
+
+	nptr := &PtrPk{ID: parent}
+	created, pk, err := dORM.ReadOrCreate(nptr, "ID")
+	throwFail(t, err)
+	throwFail(t, AssertIs(created, false))
+	throwFail(t, AssertIs(pk, 10))
+	throwFail(t, AssertIs(nptr.ID, parent))
+	throwFail(t, AssertIs(nptr.Positive, true))
+
+	nptr = &PtrPk{Positive: true}
+	created, pk, err = dORM.ReadOrCreate(nptr, "Positive")
+	throwFail(t, err)
+	throwFail(t, AssertIs(created, false))
+	throwFail(t, AssertIs(pk, 10))
+	throwFail(t, AssertIs(nptr.ID, parent))
+
+	nptr.Positive = false
+	num, err = dORM.Update(nptr)
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 1))
+	throwFail(t, AssertIs(nptr.ID, parent))
+	throwFail(t, AssertIs(nptr.Positive, false))
+
+	num, err = dORM.Delete(nptr)
+	throwFail(t, err)
+	throwFail(t, AssertIs(num, 1))
+}
+
+func TestSnake(t *testing.T) {
+	cases := map[string]string{
+		"i":           "i",
+		"I":           "i",
+		"iD":          "i_d",
+		"ID":          "i_d",
+		"NO":          "n_o",
+		"NOO":         "n_o_o",
+		"NOOooOOoo":   "n_o_ooo_o_ooo",
+		"OrderNO":     "order_n_o",
+		"tagName":     "tag_name",
+		"tag_Name":    "tag__name",
+		"tag_name":    "tag_name",
+		"_tag_name":   "_tag_name",
+		"tag_666name": "tag_666name",
+		"tag_666Name": "tag_666_name",
+	}
+	for name, want := range cases {
+		got := snakeString(name)
+		throwFail(t, AssertIs(got, want))
+	}
+}
+
+func TestIgnoreCaseTag(t *testing.T) {
+	type testTagModel struct {
+		ID     int    `orm:"pk"`
+		NOO    string `orm:"column(n)"`
+		Name01 string `orm:"NULL"`
+		Name02 string `orm:"COLUMN(Name)"`
+		Name03 string `orm:"Column(name)"`
+	}
+	modelCache.clean()
+	RegisterModel(&testTagModel{})
+	info, ok := modelCache.get("test_tag_model")
+	throwFail(t, AssertIs(ok, true))
+	throwFail(t, AssertNot(info, nil))
+	if t == nil {
+		return
+	}
+	throwFail(t, AssertIs(info.fields.GetByName("NOO").column, "n"))
+	throwFail(t, AssertIs(info.fields.GetByName("Name01").null, true))
+	throwFail(t, AssertIs(info.fields.GetByName("Name02").column, "Name"))
+	throwFail(t, AssertIs(info.fields.GetByName("Name03").column, "name"))
+}
+func TestInsertOrUpdate(t *testing.T) {
+	RegisterModel(new(User))
+	user := User{UserName: "unique_username133", Status: 1, Password: "o"}
+	user1 := User{UserName: "unique_username133", Status: 2, Password: "o"}
+	user2 := User{UserName: "unique_username133", Status: 3, Password: "oo"}
+	dORM.Insert(&user)
+	test := User{UserName: "unique_username133"}
+	fmt.Println(dORM.Driver().Name())
+	if dORM.Driver().Name() == "sqlite3" {
+		fmt.Println("sqlite3 is nonsupport")
+		return
+	}
+	//test1
+	_, err := dORM.InsertOrUpdate(&user1, "user_name")
+	if err != nil {
+		fmt.Println(err)
+		if err.Error() == "postgres version must 9.5 or higher" || err.Error() == "`sqlite3` nonsupport InsertOrUpdate in beego" {
+		} else {
+			throwFailNow(t, err)
+		}
+	} else {
+		dORM.Read(&test, "user_name")
+		throwFailNow(t, AssertIs(user1.Status, test.Status))
+	}
+	//test2
+	_, err = dORM.InsertOrUpdate(&user2, "user_name")
+	if err != nil {
+		fmt.Println(err)
+		if err.Error() == "postgres version must 9.5 or higher" || err.Error() == "`sqlite3` nonsupport InsertOrUpdate in beego" {
+		} else {
+			throwFailNow(t, err)
+		}
+	} else {
+		dORM.Read(&test, "user_name")
+		throwFailNow(t, AssertIs(user2.Status, test.Status))
+		throwFailNow(t, AssertIs(user2.Password, strings.TrimSpace(test.Password)))
+	}
+	//test3 +
+	_, err = dORM.InsertOrUpdate(&user2, "user_name", "status=status+1")
+	if err != nil {
+		fmt.Println(err)
+		if err.Error() == "postgres version must 9.5 or higher" || err.Error() == "`sqlite3` nonsupport InsertOrUpdate in beego" {
+		} else {
+			throwFailNow(t, err)
+		}
+	} else {
+		dORM.Read(&test, "user_name")
+		throwFailNow(t, AssertIs(user2.Status+1, test.Status))
+	}
+	//test4 -
+	_, err = dORM.InsertOrUpdate(&user2, "user_name", "status=status-1")
+	if err != nil {
+		fmt.Println(err)
+		if err.Error() == "postgres version must 9.5 or higher" || err.Error() == "`sqlite3` nonsupport InsertOrUpdate in beego" {
+		} else {
+			throwFailNow(t, err)
+		}
+	} else {
+		dORM.Read(&test, "user_name")
+		throwFailNow(t, AssertIs((user2.Status+1)-1, test.Status))
+	}
+	//test5 *
+	_, err = dORM.InsertOrUpdate(&user2, "user_name", "status=status*3")
+	if err != nil {
+		fmt.Println(err)
+		if err.Error() == "postgres version must 9.5 or higher" || err.Error() == "`sqlite3` nonsupport InsertOrUpdate in beego" {
+		} else {
+			throwFailNow(t, err)
+		}
+	} else {
+		dORM.Read(&test, "user_name")
+		throwFailNow(t, AssertIs(((user2.Status+1)-1)*3, test.Status))
+	}
+	//test6 /
+	_, err = dORM.InsertOrUpdate(&user2, "user_name", "Status=Status/3")
+	if err != nil {
+		fmt.Println(err)
+		if err.Error() == "postgres version must 9.5 or higher" || err.Error() == "`sqlite3` nonsupport InsertOrUpdate in beego" {
+		} else {
+			throwFailNow(t, err)
+		}
+	} else {
+		dORM.Read(&test, "user_name")
+		throwFailNow(t, AssertIs((((user2.Status+1)-1)*3)/3, test.Status))
+	}
+}

orm/qb.go

@@ -19,6 +19,7 @@ import "errors"
 // QueryBuilder is the Query builder interface
 type QueryBuilder interface {
 	Select(fields ...string) QueryBuilder
+	ForUpdate() QueryBuilder
 	From(tables ...string) QueryBuilder
 	InnerJoin(table string) QueryBuilder
 	LeftJoin(table string) QueryBuilder

orm/qb_mysql.go

@@ -34,6 +34,12 @@ func (qb *MySQLQueryBuilder) Select(fields ...string) QueryBuilder {
 	return qb
 }
 
+// ForUpdate add the FOR UPDATE clause
+func (qb *MySQLQueryBuilder) ForUpdate() QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "FOR UPDATE")
+	return qb
+}
+
 // From join the tables
 func (qb *MySQLQueryBuilder) From(tables ...string) QueryBuilder {
 	qb.Tokens = append(qb.Tokens, "FROM", strings.Join(tables, CommaSpace))

orm/qb_tidb.go

@@ -31,6 +31,12 @@ func (qb *TiDBQueryBuilder) Select(fields ...string) QueryBuilder {
 	return qb
 }
 
+// ForUpdate add the FOR UPDATE clause
+func (qb *TiDBQueryBuilder) ForUpdate() QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "FOR UPDATE")
+	return qb
+}
+
 // From join the tables
 func (qb *TiDBQueryBuilder) From(tables ...string) QueryBuilder {
 	qb.Tokens = append(qb.Tokens, "FROM", strings.Join(tables, CommaSpace))

orm/types.go

@@ -45,6 +45,9 @@ type Ormer interface {
 	// 	u = &User{UserName: "astaxie", Password: "pass"}
 	//	err = Ormer.Read(u, "UserName")
 	Read(md interface{}, cols ...string) error
+	// Like Read(), but with "FOR UPDATE" clause, useful in transaction.
+	// Some databases are not support this feature.
+	ReadForUpdate(md interface{}, cols ...string) error
 	// Try to read a row from the database, or insert one if it doesn't exist
 	ReadOrCreate(md interface{}, col1 string, cols ...string) (bool, int64, error)
 	// insert model data to database
@@ -53,6 +56,11 @@ type Ormer interface {
 	//  id, err = Ormer.Insert(user)
 	//  user must a pointer and Insert will set user's pk field
 	Insert(interface{}) (int64, error)
+	// mysql:InsertOrUpdate(model) or InsertOrUpdate(model,"colu=colu+value")
+	// if colu type is integer : can use(+-*/), string : convert(colu,"value")
+	// postgres: InsertOrUpdate(model,"conflictColumnName") or InsertOrUpdate(model,"conflictColumnName","colu=colu+value")
+	// if colu type is integer : can use(+-*/), string : colu || "value"
+	InsertOrUpdate(md interface{}, colConflitAndArgs ...string) (int64, error)
 	// insert some models to database
 	InsertMulti(bulk int, mds interface{}) (int64, error)
 	// update model to database.
@@ -66,7 +74,7 @@ type Ormer interface {
 	//	num, err = Ormer.Update(&user, "Langs", "Extra")
 	Update(md interface{}, cols ...string) (int64, error)
 	// delete model in database
-	Delete(md interface{}) (int64, error)
+	Delete(md interface{}, cols ...string) (int64, error)
 	// load related models to md model.
 	// args are limit, offset int and order string.
 	//
@@ -137,6 +145,16 @@ type QuerySeter interface {
 	//	//sql-> WHERE T0.`profile_id` IS NOT NULL AND NOT T0.`Status` IN (?) OR T1.`age` >  2000
 	//	num, err := qs.SetCond(cond1).Count()
 	SetCond(*Condition) QuerySeter
+	// get condition from QuerySeter.
+	// sql's where condition
+	//  cond := orm.NewCondition()
+	//  cond = cond.And("profile__isnull", false).AndNot("status__in", 1)
+	//  qs = qs.SetCond(cond)
+	//  cond = qs.GetCond()
+	//  cond := cond.Or("profile__age__gt", 2000)
+	//  //sql-> WHERE T0.`profile_id` IS NOT NULL AND NOT T0.`Status` IN (?) OR T1.`age` >  2000
+	//  num, err := qs.SetCond(cond).Count()
+	GetCond() *Condition
 	// add LIMIT value.
 	// args[0] means offset, e.g. LIMIT num,offset.
 	// if Limit <= 0 then Limit will be set to default limit ,eg 1000
@@ -389,13 +407,14 @@ type txEnder interface {
 
 // base database struct
 type dbBaser interface {
-	Read(dbQuerier, *modelInfo, reflect.Value, *time.Location, []string) error
+	Read(dbQuerier, *modelInfo, reflect.Value, *time.Location, []string, bool) error
 	Insert(dbQuerier, *modelInfo, reflect.Value, *time.Location) (int64, error)
+	InsertOrUpdate(dbQuerier, *modelInfo, reflect.Value, *alias, ...string) (int64, error)
 	InsertMulti(dbQuerier, *modelInfo, reflect.Value, int, *time.Location) (int64, error)
 	InsertValue(dbQuerier, *modelInfo, bool, []string, []interface{}) (int64, error)
 	InsertStmt(stmtQuerier, *modelInfo, reflect.Value, *time.Location) (int64, error)
 	Update(dbQuerier, *modelInfo, reflect.Value, *time.Location, []string) (int64, error)
-	Delete(dbQuerier, *modelInfo, reflect.Value, *time.Location) (int64, error)
+	Delete(dbQuerier, *modelInfo, reflect.Value, *time.Location, []string) (int64, error)
 	ReadBatch(dbQuerier, *querySet, *modelInfo, *Condition, interface{}, *time.Location, []string) (int64, error)
 	SupportUpdateJoin() bool
 	UpdateBatch(dbQuerier, *querySet, *modelInfo, *Condition, Params, *time.Location) (int64, error)
@@ -420,4 +439,5 @@ type dbBaser interface {
 	ShowColumnsQuery(string) string
 	IndexExists(dbQuerier, string, string) bool
 	collectFieldValue(*modelInfo, *fieldInfo, reflect.Value, bool, *time.Location) (interface{}, error)
+	setval(dbQuerier, *modelInfo, []string) error
 }

orm/utils.go

@@ -16,6 +16,7 @@ package orm
 
 import (
 	"fmt"
+	"math/big"
 	"reflect"
 	"strconv"
 	"strings"
@@ -87,6 +88,14 @@ func (f StrTo) Int32() (int32, error) {
 // Int64 string to int64
 func (f StrTo) Int64() (int64, error) {
 	v, err := strconv.ParseInt(f.String(), 10, 64)
+	if err != nil {
+		i := new(big.Int)
+		ni, ok := i.SetString(f.String(), 10) // octal
+		if !ok {
+			return int64(v), err
+		}
+		return ni.Int64(), nil
+	}
 	return int64(v), err
 }
 
@@ -117,6 +126,14 @@ func (f StrTo) Uint32() (uint32, error) {
 // Uint64 string to uint64
 func (f StrTo) Uint64() (uint64, error) {
 	v, err := strconv.ParseUint(f.String(), 10, 64)
+	if err != nil {
+		i := new(big.Int)
+		ni, ok := i.SetString(f.String(), 10)
+		if !ok {
+			return uint64(v), err
+		}
+		return ni.Uint64(), nil
+	}
 	return uint64(v), err
 }
 
@@ -181,7 +198,7 @@ func ToInt64(value interface{}) (d int64) {
 	return
 }
 
-// snake string, XxYy to xx_yy
+// snake string, XxYy to xx_yy , XxYY to xx_yy
 func snakeString(s string) string {
 	data := make([]byte, 0, len(s)*2)
 	j := false
@@ -202,22 +219,17 @@ func snakeString(s string) string {
 // camel string, xx_yy to XxYy
 func camelString(s string) string {
 	data := make([]byte, 0, len(s))
-	j := false
+	flag, num := true, len(s)-1
-	k := false
-	num := len(s) - 1
 	for i := 0; i <= num; i++ {
 		d := s[i]
-		if k == false && d >= 'A' && d <= 'Z' {
+		if d == '_' {
-			k = true
+			flag = true
-		}
-		if d >= 'a' && d <= 'z' && (j || k == false) {
-			d = d - 32
-			j = false
-			k = true
-		}
-		if k && d == '_' && num > i && s[i+1] >= 'a' && s[i+1] <= 'z' {
-			j = true
 			continue
+		} else if flag == true {
+			if d >= 'a' && d <= 'z' {
+				d = d - 32
+			}
+			flag = false
 		}
 		data = append(data, d)
 	}