fix #1221

Revert "Revert "fix multiple filters execute issue""

.go_style

@@ -1,16 +0,0 @@
-{
-    "file_line": 500,
-    "func_line": 80,
-    "params_num":4,
-    "results_num":3,
-    "formated": true,
-    "pkg_name": true,
-    "camel_name":true,
-    "ignore":[
-        "a/*",
-        "b/*/c/*.go"
-    ],
-    "fatal":[
-        "formated"
-    ]
-}

README.md

@@ -1,32 +1,37 @@
-## beego
+## Beego
 
 [![Build Status](https://drone.io/github.com/astaxie/beego/status.png)](https://drone.io/github.com/astaxie/beego/latest)
+[![GoDoc](http://godoc.org/github.com/astaxie/beego?status.svg)](http://godoc.org/github.com/astaxie/beego)
 
-beego is an open-source, high-performance, modularity, full-stack web framework.
+beego is an open-source, high-performance, modular, full-stack web framework.
 
 More info [beego.me](http://beego.me)
 
+## Installation
+
+    go get github.com/astaxie/beego
+
 ## Features
 
 * RESTful support
 * MVC architecture
-* modularity
-* auto API documents
-* annotation router
-* namespace
-* powerful develop tools
-* full stack for web & API
+* Modularity
+* Auto API documents
+* Annotation router
+* Namespace
+* Powerful development tools
+* Full stack for Web & API
 
 ## Documentation
 
-[English](http://beego.me/docs/intro/)
+* [English](http://beego.me/docs/intro/)
+* [中文文档](http://beego.me/docs/intro/)
 
-[API](http://godoc.org/github.com/astaxie/beego)
-
-[中文文档](http://beego.me/docs/intro/)
+## Community
 
+* [http://beego.me/community](http://beego.me/community)
 
 ## LICENSE
 
 beego is licensed under the Apache Licence, Version 2.0
-(http://www.apache.org/licenses/LICENSE-2.0.html).
+(http://www.apache.org/licenses/LICENSE-2.0.html).

admin.go

@@ -19,9 +19,11 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"os"
 	"text/template"
 	"time"
 
+	"github.com/astaxie/beego/grace"
 	"github.com/astaxie/beego/toolbox"
 	"github.com/astaxie/beego/utils"
 )
@@ -113,8 +115,6 @@ func listConf(rw http.ResponseWriter, r *http.Request) {
 			m["SessionName"] = SessionName
 			m["SessionGCMaxLifetime"] = SessionGCMaxLifetime
 			m["SessionSavePath"] = SessionSavePath
-			m["SessionHashFunc"] = SessionHashFunc
-			m["SessionHashKey"] = SessionHashKey
 			m["SessionCookieLifeTime"] = SessionCookieLifeTime
 			m["UseFcgi"] = UseFcgi
 			m["MaxMemory"] = MaxMemory
@@ -142,121 +142,116 @@ func listConf(rw http.ResponseWriter, r *http.Request) {
 			tmpl.Execute(rw, data)
 
 		case "router":
-			resultList := new([][]string)
+			content := make(map[string]interface{})
 
-			var result = []string{
-				fmt.Sprintf("header"),
+			var fields = []string{
 				fmt.Sprintf("Router Pattern"),
 				fmt.Sprintf("Methods"),
 				fmt.Sprintf("Controller"),
 			}
-			*resultList = append(*resultList, result)
+			content["Fields"] = fields
 
+			methods := []string{}
+			methodsData := make(map[string]interface{})
 			for method, t := range BeeApp.Handlers.routers {
-				var result = []string{
-					fmt.Sprintf("success"),
-					fmt.Sprintf("Method: %s", method),
-					fmt.Sprintf(""),
-					fmt.Sprintf(""),
-				}
-				*resultList = append(*resultList, result)
+
+				resultList := new([][]string)
 
 				printTree(resultList, t)
+
+				methods = append(methods, method)
+				methodsData[method] = resultList
 			}
-			data["Content"] = resultList
+
+			content["Data"] = methodsData
+			content["Methods"] = methods
+			data["Content"] = content
 			data["Title"] = "Routers"
+
 			tmpl := template.Must(template.New("dashboard").Parse(dashboardTpl))
 			tmpl = template.Must(tmpl.Parse(routerAndFilterTpl))
 			tmpl = template.Must(tmpl.Parse(defaultScriptsTpl))
 			tmpl.Execute(rw, data)
 		case "filter":
-			resultList := new([][]string)
+			content := make(map[string]interface{})
 
-			var result = []string{
-				fmt.Sprintf("header"),
+			var fields = []string{
 				fmt.Sprintf("Router Pattern"),
 				fmt.Sprintf("Filter Function"),
 			}
-			*resultList = append(*resultList, result)
+			content["Fields"] = fields
+
+			filterTypes := []string{}
+			filterTypeData := make(map[string]interface{})
 
 			if BeeApp.Handlers.enableFilter {
-				var result = []string{
-					fmt.Sprintf("success"),
-					fmt.Sprintf("Before Router"),
-					fmt.Sprintf(""),
-				}
-				*resultList = append(*resultList, result)
+				var filterType string
 
 				if bf, ok := BeeApp.Handlers.filters[BeforeRouter]; ok {
+					filterType = "Before Router"
+					filterTypes = append(filterTypes, filterType)
+					resultList := new([][]string)
 					for _, f := range bf {
 
 						var result = []string{
-							fmt.Sprintf(""),
 							fmt.Sprintf("%s", f.pattern),
 							fmt.Sprintf("%s", utils.GetFuncName(f.filterFunc)),
 						}
 						*resultList = append(*resultList, result)
-
 					}
+					filterTypeData[filterType] = resultList
 				}
-				result = []string{
-					fmt.Sprintf("success"),
-					fmt.Sprintf("Before Exec"),
-					fmt.Sprintf(""),
-				}
-				*resultList = append(*resultList, result)
+
 				if bf, ok := BeeApp.Handlers.filters[BeforeExec]; ok {
+					filterType = "Before Exec"
+					filterTypes = append(filterTypes, filterType)
+					resultList := new([][]string)
 					for _, f := range bf {
 
 						var result = []string{
-							fmt.Sprintf(""),
 							fmt.Sprintf("%s", f.pattern),
 							fmt.Sprintf("%s", utils.GetFuncName(f.filterFunc)),
 						}
 						*resultList = append(*resultList, result)
-
 					}
+					filterTypeData[filterType] = resultList
 				}
-				result = []string{
-					fmt.Sprintf("success"),
-					fmt.Sprintf("AfterExec Exec"),
-					fmt.Sprintf(""),
-				}
-				*resultList = append(*resultList, result)
 
 				if bf, ok := BeeApp.Handlers.filters[AfterExec]; ok {
+					filterType = "After Exec"
+					filterTypes = append(filterTypes, filterType)
+					resultList := new([][]string)
 					for _, f := range bf {
 
 						var result = []string{
-							fmt.Sprintf(""),
 							fmt.Sprintf("%s", f.pattern),
 							fmt.Sprintf("%s", utils.GetFuncName(f.filterFunc)),
 						}
 						*resultList = append(*resultList, result)
-
 					}
+					filterTypeData[filterType] = resultList
 				}
-				result = []string{
-					fmt.Sprintf("success"),
-					fmt.Sprintf("Finish Router"),
-					fmt.Sprintf(""),
-				}
-				*resultList = append(*resultList, result)
 
 				if bf, ok := BeeApp.Handlers.filters[FinishRouter]; ok {
+					filterType = "Finish Router"
+					filterTypes = append(filterTypes, filterType)
+					resultList := new([][]string)
 					for _, f := range bf {
 
 						var result = []string{
-							fmt.Sprintf(""),
 							fmt.Sprintf("%s", f.pattern),
 							fmt.Sprintf("%s", utils.GetFuncName(f.filterFunc)),
 						}
 						*resultList = append(*resultList, result)
-
 					}
+					filterTypeData[filterType] = resultList
 				}
 			}
-			data["Content"] = resultList
+
+			content["Data"] = filterTypeData
+			content["Methods"] = filterTypes
+
+			data["Content"] = content
 			data["Title"] = "Filters"
 			tmpl := template.Must(template.New("dashboard").Parse(dashboardTpl))
 			tmpl = template.Must(tmpl.Parse(routerAndFilterTpl))
@@ -281,7 +276,6 @@ func printTree(resultList *[][]string, t *Tree) {
 		if v, ok := l.runObject.(*controllerInfo); ok {
 			if v.routerType == routerTypeBeego {
 				var result = []string{
-					fmt.Sprintf(""),
 					fmt.Sprintf("%s", v.pattern),
 					fmt.Sprintf("%s", v.methods),
 					fmt.Sprintf("%s", v.controllerType),
@@ -289,7 +283,6 @@ func printTree(resultList *[][]string, t *Tree) {
 				*resultList = append(*resultList, result)
 			} else if v.routerType == routerTypeRESTFul {
 				var result = []string{
-					fmt.Sprintf(""),
 					fmt.Sprintf("%s", v.pattern),
 					fmt.Sprintf("%s", v.methods),
 					fmt.Sprintf(""),
@@ -297,7 +290,6 @@ func printTree(resultList *[][]string, t *Tree) {
 				*resultList = append(*resultList, result)
 			} else if v.routerType == routerTypeHandler {
 				var result = []string{
-					fmt.Sprintf(""),
 					fmt.Sprintf("%s", v.pattern),
 					fmt.Sprintf(""),
 					fmt.Sprintf(""),
@@ -343,7 +335,6 @@ func profIndex(rw http.ResponseWriter, r *http.Request) {
 			tmpl = template.Must(tmpl.Parse(defaultScriptsTpl))
 		}
 		tmpl.Execute(rw, data)
-	} else {
 	}
 }
 
@@ -352,13 +343,15 @@ func profIndex(rw http.ResponseWriter, r *http.Request) {
 func healthcheck(rw http.ResponseWriter, req *http.Request) {
 	data := make(map[interface{}]interface{})
 
-	resultList := new([][]string)
-	var result = []string{
-		fmt.Sprintf("header"),
+	var result = []string{}
+	fields := []string{
 		fmt.Sprintf("Name"),
+		fmt.Sprintf("Message"),
 		fmt.Sprintf("Status"),
 	}
-	*resultList = append(*resultList, result)
+	resultList := new([][]string)
+
+	content := make(map[string]interface{})
 
 	for name, h := range toolbox.AdminCheckList {
 		if err := h.Check(); err != nil {
@@ -379,7 +372,9 @@ func healthcheck(rw http.ResponseWriter, req *http.Request) {
 		*resultList = append(*resultList, result)
 	}
 
-	data["Content"] = resultList
+	content["Fields"] = fields
+	content["Data"] = resultList
+	data["Content"] = content
 	data["Title"] = "Health Check"
 	tmpl := template.Must(template.New("dashboard").Parse(dashboardTpl))
 	tmpl = template.Must(tmpl.Parse(healthCheckTpl))
@@ -403,32 +398,36 @@ func taskStatus(rw http.ResponseWriter, req *http.Request) {
 			if err != nil {
 				data["Message"] = []string{"error", fmt.Sprintf("%s", err)}
 			}
-			data["Message"] = []string{"success", fmt.Sprintf("%s run success,Now the Status is %s", taskname, t.GetStatus())}
+			data["Message"] = []string{"success", fmt.Sprintf("%s run success,Now the Status is <br>%s", taskname, t.GetStatus())}
 		} else {
 			data["Message"] = []string{"warning", fmt.Sprintf("there's no task which named: %s", taskname)}
 		}
 	}
 
 	// List Tasks
+	content := make(map[string]interface{})
 	resultList := new([][]string)
-	var result = []string{
-		fmt.Sprintf("header"),
+	var result = []string{}
+	var fields = []string{
 		fmt.Sprintf("Task Name"),
 		fmt.Sprintf("Task Spec"),
-		fmt.Sprintf("Task Function"),
+		fmt.Sprintf("Task Status"),
+		fmt.Sprintf("Last Time"),
+		fmt.Sprintf(""),
 	}
-	*resultList = append(*resultList, result)
 	for tname, tk := range toolbox.AdminTaskList {
 		result = []string{
-			fmt.Sprintf(""),
 			fmt.Sprintf("%s", tname),
+			fmt.Sprintf("%s", tk.GetSpec()),
 			fmt.Sprintf("%s", tk.GetStatus()),
 			fmt.Sprintf("%s", tk.GetPrev().String()),
 		}
 		*resultList = append(*resultList, result)
 	}
 
-	data["Content"] = resultList
+	content["Fields"] = fields
+	content["Data"] = resultList
+	data["Content"] = content
 	data["Title"] = "Tasks"
 	tmpl := template.Must(template.New("dashboard").Parse(dashboardTpl))
 	tmpl = template.Must(tmpl.Parse(tasksTpl))
@@ -460,8 +459,15 @@ func (admin *adminApp) Run() {
 	for p, f := range admin.routers {
 		http.Handle(p, f)
 	}
-	err := http.ListenAndServe(addr, nil)
+	BeeLogger.Info("Admin server Running on %s", addr)
+
+	var err error
+	if Graceful {
+		err = grace.ListenAndServe(addr, nil)
+	} else {
+		err = http.ListenAndServe(addr, nil)
+	}
 	if err != nil {
-		BeeLogger.Critical("Admin ListenAndServe: ", err)
+		BeeLogger.Critical("Admin ListenAndServe: ", err, fmt.Sprintf("%d", os.Getpid()))
 	}
 }

adminui.go

@@ -61,31 +61,35 @@ var gcAjaxTpl = `
 {{end}}
 `
 
-var qpsTpl = `
-{{define "content"}}
+var qpsTpl = `{{define "content"}}
 <h1>Requests statistics</h1>
 <table class="table table-striped table-hover ">
-{{range $i, $slice := .Content}}
-<tr>
-{{range $j, $elem := $slice}}
-{{if eq $i 0}}
-<th>
-{{else}}
-<td>
-{{end}}
-{{$elem}}
-{{if eq $i 0}}
-</th>
-{{else}}
-</td>
-{{end}}
-{{end}}
+	<thead>
+	<tr>
+	{{range .Content.Fields}}
+		<th>
+		{{.}}
+		</th>
+	{{end}}
+	</tr>
+	</thead>
+
+	<tbody>
+	{{range $i, $elem := .Content.Data}}
+
+	<tr>
+		{{range $elem}}
+			<td>
+			{{.}}
+			</td>
+		{{end}}
+	</tr>
+
+	{{end}}
+	</tbody>
 
-</tr>
-{{end}}
 </table>
-{{end}}
-`
+{{end}}`
 
 var configTpl = `
 {{define "content"}}
@@ -98,49 +102,51 @@ var configTpl = `
 {{end}}
 `
 
-var routerAndFilterTpl = `
-{{define "content"}}
+var routerAndFilterTpl = `{{define "content"}}
+
 
 <h1>{{.Title}}</h1>
+
+{{range .Content.Methods}}
+
+<div class="panel panel-default">
+<div class="panel-heading lead success"><strong>{{.}}</strong></div>
+<div class="panel-body">
 <table class="table table-striped table-hover ">
-{{range $i, $slice := .Content}}
-<tr>
+	<thead>
+	<tr>
+	{{range $.Content.Fields}}
+		<th>
+		{{.}}
+		</th>
+	{{end}}
+	</tr>
+	</thead>
 
-{{ $header := index $slice 0}}
-{{if eq "header" $header }}
-	{{range $j, $elem := $slice}}
-	{{if ne $j 0}}
-	<th>
-	{{$elem}}
-	</th>
-	{{end}}
-	{{end}}
-{{else if eq "success" $header}}
-	{{range $j, $elem := $slice}}
-	{{if ne $j 0}}
-	<th class="success">
-	{{$elem}}
-	</th>
-	{{end}}
-	{{end}}
-{{else}}
-	{{range $j, $elem := $slice}}
-	{{if ne $j 0}}
-	<td>
-	{{$elem}}
-	</td>
-	{{end}}
-	{{end}}
-{{end}}
+	<tbody>
+	{{$slice := index $.Content.Data .}}
+	{{range $i, $elem := $slice}}
+
+	<tr>
+		{{range $elem}}
+			<td>
+			{{.}}
+			</td>
+		{{end}}
+	</tr>
+
+	{{end}}
+	</tbody>
 
-</tr>
-{{end}}
 </table>
+</div>
+</div>
 {{end}}
-`
 
-var tasksTpl = `
-{{define "content"}}
+
+{{end}}`
+
+var tasksTpl = `{{define "content"}}
 
 <h1>{{.Title}}</h1>
 
@@ -161,59 +167,51 @@ bg-warning
 
 
 <table class="table table-striped table-hover ">
-{{range $i, $slice := .Content}}
+<thead>
 <tr>
-
-{{ $header := index $slice 0}}
-{{if eq "header" $header }}
-	{{range $j, $elem := $slice}}
-	{{if ne $j 0}}
-	<th>
-	{{$elem}}
-	</th>
-	{{end}}
-	{{end}}
-	<th>
-	Run Task
-	</th>
-{{else}}
-	{{range $j, $elem := $slice}}
-	{{if ne $j 0}}
-	<td>
-	{{$elem}}
-	</td>
-	{{end}}
-	{{end}}
-	<td>
-	<a class="btn btn-primary btn-sm" href="/task?taskname={{index $slice 1}}">Run</a>
-	</td>
+{{range .Content.Fields}}
+<th>
+{{.}}
+</th>
 {{end}}
+</tr>
+</thead>
 
+<tbody>
+{{range $i, $slice := .Content.Data}}
+<tr>
+	{{range $slice}}
+	<td>
+	{{.}}
+	</td>
+	{{end}}
+	<td>
+	<a class="btn btn-primary btn-sm" href="/task?taskname={{index $slice 0}}">Run</a>
+	</td>
 </tr>
 {{end}}
+</tbody>
 </table>
-{{end}}
-`
+
+{{end}}`
 
 var healthCheckTpl = `
 {{define "content"}}
 
 <h1>{{.Title}}</h1>
 <table class="table table-striped table-hover ">
-{{range $i, $slice := .Content}}
-
-{{ $header := index $slice 0}}
-{{if eq "header" $header }}
+<thead>
 <tr>
-	{{range $j, $elem := $slice}}
-	{{if ne $j 0}}
+{{range .Content.Fields}}
 	<th>
-	{{$elem}}
+	{{.}}
 	</th>
-	{{end}}
-	{{end}}
+{{end}}
 </tr>
-{{else}} 
+</thead>
+<tbody>
+{{range $i, $slice := .Content.Data}}
+	{{ $header := index $slice 0}}
 	{{ if eq "success" $header}}
 	<tr class="success">
 	{{else if eq "error" $header}}
@@ -228,10 +226,13 @@ var healthCheckTpl = `
 		</td>
 		{{end}}
 		{{end}}
+		<td>
+		{{$header}}
+		</td>
 	</tr>
 {{end}}
 
-{{end}}
+</tbody>
 </table>
 {{end}}`
 
@@ -251,7 +252,8 @@ Welcome to Beego Admin Dashboard
 
 </title>
 
-<link href="http://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css" rel="stylesheet">
+<link href="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css" rel="stylesheet">
+<link href="//cdn.datatables.net/plug-ins/725b2a2115b/integration/bootstrap/3/dataTables.bootstrap.css" rel="stylesheet">
 
 <style type="text/css">
 ul.nav li.dropdown:hover > ul.dropdown-menu {
@@ -336,9 +338,17 @@ Healthcheck
 {{template "content" .}}
 </div>
 
-<script src="http://code.jquery.com/jquery-1.11.1.min.js"></script>
-<script src="http://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
+<script src="//code.jquery.com/jquery-1.11.1.min.js"></script>
+<script src="//maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
+<script src="//cdn.datatables.net/1.10.2/js/jquery.dataTables.min.js"></script>
+<script src="//cdn.datatables.net/plug-ins/725b2a2115b/integration/bootstrap/3/dataTables.bootstrap.js
+"></script>
 
+<script type="text/javascript">
+$(document).ready(function() {
+    $('.table').dataTable();
+});
+</script>
 {{template "scripts" .}}
 </body>
 </html>

app.go

@@ -19,14 +19,13 @@ import (
 	"net"
 	"net/http"
 	"net/http/fcgi"
+	"os"
 	"time"
 
-	"github.com/astaxie/beego/context"
+	"github.com/astaxie/beego/grace"
+	"github.com/astaxie/beego/utils"
 )
 
-// FilterFunc defines filter function type.
-type FilterFunc func(*context.Context)
-
 // App defines beego application with a new PatternServeMux.
 type App struct {
 	Handlers *ControllerRegistor
@@ -48,8 +47,6 @@ func (app *App) Run() {
 		addr = fmt.Sprintf("%s:%d", HttpAddr, HttpPort)
 	}
 
-	BeeLogger.Info("Running on %s", addr)
-
 	var (
 		err error
 		l   net.Listener
@@ -57,48 +54,119 @@ func (app *App) Run() {
 	endRunning := make(chan bool, 1)
 
 	if UseFcgi {
-		if HttpPort == 0 {
-			l, err = net.Listen("unix", addr)
+		if UseStdIo {
+			err = fcgi.Serve(nil, app.Handlers) // standard I/O
+			if err == nil {
+				BeeLogger.Info("Use FCGI via standard I/O")
+			} else {
+				BeeLogger.Info("Cannot use FCGI via standard I/O", err)
+			}
 		} else {
-			l, err = net.Listen("tcp", addr)
+			if HttpPort == 0 {
+				// remove the Socket file before start
+				if utils.FileExists(addr) {
+					os.Remove(addr)
+				}
+				l, err = net.Listen("unix", addr)
+			} else {
+				l, err = net.Listen("tcp", addr)
+			}
+			if err != nil {
+				BeeLogger.Critical("Listen: ", err)
+			}
+			err = fcgi.Serve(l, app.Handlers)
 		}
-		if err != nil {
-			BeeLogger.Critical("Listen: ", err)
-		}
-		err = fcgi.Serve(l, app.Handlers)
 	} else {
-		app.Server.Addr = addr
-		app.Server.Handler = app.Handlers
-		app.Server.ReadTimeout = time.Duration(HttpServerTimeOut) * time.Second
-		app.Server.WriteTimeout = time.Duration(HttpServerTimeOut) * time.Second
+		if Graceful {
+			app.Server.Addr = addr
+			app.Server.Handler = app.Handlers
+			app.Server.ReadTimeout = time.Duration(HttpServerTimeOut) * time.Second
+			app.Server.WriteTimeout = time.Duration(HttpServerTimeOut) * time.Second
+			if EnableHttpTLS {
+				go func() {
+					time.Sleep(20 * time.Microsecond)
+					if HttpsPort != 0 {
+						addr = fmt.Sprintf("%s:%d", HttpAddr, HttpsPort)
+						app.Server.Addr = addr
+					}
+					server := grace.NewServer(addr, app.Handlers)
+					server.Server = app.Server
+					err := server.ListenAndServeTLS(HttpCertFile, HttpKeyFile)
+					if err != nil {
+						BeeLogger.Critical("ListenAndServeTLS: ", err, fmt.Sprintf("%d", os.Getpid()))
+						time.Sleep(100 * time.Microsecond)
+						endRunning <- true
+					}
+				}()
+			}
+			if EnableHttpListen {
+				go func() {
+					server := grace.NewServer(addr, app.Handlers)
+					server.Server = app.Server
+					if ListenTCP4 && HttpAddr == "" {
+						server.Network = "tcp4"
+					}
+					err := server.ListenAndServe()
+					if err != nil {
+						BeeLogger.Critical("ListenAndServe: ", err, fmt.Sprintf("%d", os.Getpid()))
+						time.Sleep(100 * time.Microsecond)
+						endRunning <- true
+					}
+				}()
+			}
+		} else {
+			app.Server.Addr = addr
+			app.Server.Handler = app.Handlers
+			app.Server.ReadTimeout = time.Duration(HttpServerTimeOut) * time.Second
+			app.Server.WriteTimeout = time.Duration(HttpServerTimeOut) * time.Second
 
-		if EnableHttpTLS {
-			go func() {
-				time.Sleep(20 * time.Microsecond)
-				if HttpsPort != 0 {
-					app.Server.Addr = fmt.Sprintf("%s:%d", HttpAddr, HttpsPort)
-				}
-				err := app.Server.ListenAndServeTLS(HttpCertFile, HttpKeyFile)
-				if err != nil {
-					BeeLogger.Critical("ListenAndServeTLS: ", err)
-					time.Sleep(100 * time.Microsecond)
-					endRunning <- true
-				}
-			}()
+			if EnableHttpTLS {
+				go func() {
+					time.Sleep(20 * time.Microsecond)
+					if HttpsPort != 0 {
+						app.Server.Addr = fmt.Sprintf("%s:%d", HttpAddr, HttpsPort)
+					}
+					BeeLogger.Info("https server Running on %s", app.Server.Addr)
+					err := app.Server.ListenAndServeTLS(HttpCertFile, HttpKeyFile)
+					if err != nil {
+						BeeLogger.Critical("ListenAndServeTLS: ", err)
+						time.Sleep(100 * time.Microsecond)
+						endRunning <- true
+					}
+				}()
+			}
+
+			if EnableHttpListen {
+				go func() {
+					app.Server.Addr = addr
+					BeeLogger.Info("http server Running on %s", app.Server.Addr)
+					if ListenTCP4 && HttpAddr == "" {
+						ln, err := net.Listen("tcp4", app.Server.Addr)
+						if err != nil {
+							BeeLogger.Critical("ListenAndServe: ", err)
+							time.Sleep(100 * time.Microsecond)
+							endRunning <- true
+							return
+						}
+						err = app.Server.Serve(ln)
+						if err != nil {
+							BeeLogger.Critical("ListenAndServe: ", err)
+							time.Sleep(100 * time.Microsecond)
+							endRunning <- true
+							return
+						}
+					} else {
+						err := app.Server.ListenAndServe()
+						if err != nil {
+							BeeLogger.Critical("ListenAndServe: ", err)
+							time.Sleep(100 * time.Microsecond)
+							endRunning <- true
+						}
+					}
+				}()
+			}
 		}
 
-		if EnableHttpListen {
-			go func() {
-				app.Server.Addr = addr
-				err := app.Server.ListenAndServe()
-				if err != nil {
-					BeeLogger.Critical("ListenAndServe: ", err)
-					time.Sleep(100 * time.Microsecond)
-					endRunning <- true
-				}
-			}()
-		}
 	}
-
 	<-endRunning
 }

beego.go

@@ -14,13 +14,13 @@
 
 // beego is an open-source, high-performance, modularity, full-stack web framework
 //
-//		package main
+// package main
 //
-// 		import "github.com/astaxie/beego"
+// import "github.com/astaxie/beego"
 //
-//		 func main() {
-//  			  beego.Run()
-// 		}
+// func main() {
+//  	beego.Run()
+// }
 //
 // more infomation: http://beego.me
 package beego
@@ -33,83 +33,15 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/astaxie/beego/middleware"
 	"github.com/astaxie/beego/session"
 )
 
 // beego web framework version.
-const VERSION = "1.4.0"
+const VERSION = "1.5.0"
 
 type hookfunc func() error //hook function to run
 var hooks []hookfunc       //hook function slice to store the hookfunc
 
-type groupRouter struct {
-	pattern        string
-	controller     ControllerInterface
-	mappingMethods string
-}
-
-// RouterGroups which will store routers
-type GroupRouters []groupRouter
-
-// Get a new GroupRouters
-func NewGroupRouters() GroupRouters {
-	return make(GroupRouters, 0)
-}
-
-// Add Router in the GroupRouters
-// it is for plugin or module to register router
-func (gr *GroupRouters) AddRouter(pattern string, c ControllerInterface, mappingMethod ...string) {
-	var newRG groupRouter
-	if len(mappingMethod) > 0 {
-		newRG = groupRouter{
-			pattern,
-			c,
-			mappingMethod[0],
-		}
-	} else {
-		newRG = groupRouter{
-			pattern,
-			c,
-			"",
-		}
-	}
-	*gr = append(*gr, newRG)
-}
-
-func (gr *GroupRouters) AddAuto(c ControllerInterface) {
-	newRG := groupRouter{
-		"",
-		c,
-		"",
-	}
-	*gr = append(*gr, newRG)
-}
-
-// AddGroupRouter with the prefix
-// it will register the router in BeeApp
-// the follow code is write in modules:
-// GR:=NewGroupRouters()
-// GR.AddRouter("/login",&UserController,"get:Login")
-// GR.AddRouter("/logout",&UserController,"get:Logout")
-// GR.AddRouter("/register",&UserController,"get:Reg")
-// the follow code is write in app:
-// import "github.com/beego/modules/auth"
-// AddRouterGroup("/admin", auth.GR)
-func AddGroupRouter(prefix string, groups GroupRouters) *App {
-	for _, v := range groups {
-		if v.pattern == "" {
-			BeeApp.Handlers.AddAutoPrefix(prefix, v.controller)
-		} else if v.mappingMethods != "" {
-			BeeApp.Handlers.Add(prefix+v.pattern, v.controller, v.mappingMethods)
-		} else {
-			BeeApp.Handlers.Add(prefix+v.pattern, v.controller)
-		}
-
-	}
-	return BeeApp
-}
-
 // Router adds a patterned controller handler to BeeApp.
 // it's an alias method of App.Router.
 // usage:
@@ -280,15 +212,6 @@ func Handler(rootpath string, h http.Handler, options ...interface{}) *App {
 	return BeeApp
 }
 
-// ErrorHandler registers http.HandlerFunc to each http err code string.
-// usage:
-// 	beego.ErrorHandler("404",NotFound)
-//	beego.ErrorHandler("500",InternalServerError)
-func Errorhandler(err string, h http.HandlerFunc) *App {
-	middleware.Errorhandler(err, h)
-	return BeeApp
-}
-
 // SetViewsPath sets view directory path in beego application.
 func SetViewsPath(path string) *App {
 	ViewsPath = path
@@ -308,15 +231,20 @@ func SetStaticPath(url string, path string) *App {
 
 // DelStaticPath removes the static folder setting in this url pattern in beego application.
 func DelStaticPath(url string) *App {
+	if !strings.HasPrefix(url, "/") {
+		url = "/" + url
+	}
+	url = strings.TrimRight(url, "/")
 	delete(StaticDir, url)
 	return BeeApp
 }
 
 // InsertFilter adds a FilterFunc with pattern condition and action constant.
 // The pos means action constant including
-// beego.BeforeRouter, beego.AfterStatic, beego.BeforeExec, beego.AfterExec and beego.FinishRouter.
-func InsertFilter(pattern string, pos int, filter FilterFunc) *App {
-	BeeApp.Handlers.InsertFilter(pattern, pos, filter)
+// beego.BeforeStatic, beego.BeforeRouter, beego.BeforeExec, beego.AfterExec and beego.FinishRouter.
+// The bool params is for setting the returnOnOutput value (false allows multiple filters to execute)
+func InsertFilter(pattern string, pos int, filter FilterFunc, params ...bool) *App {
+	BeeApp.Handlers.InsertFilter(pattern, pos, filter, params...)
 	return BeeApp
 }
 
@@ -359,6 +287,9 @@ func initBeforeHttpRun() {
 		}
 	}
 
+	//init mime
+	AddAPPStartHook(initMime)
+
 	// do hooks function
 	for _, hk := range hooks {
 		err := hk()
@@ -373,10 +304,8 @@ func initBeforeHttpRun() {
 		if sessionConfig == "" {
 			sessionConfig = `{"cookieName":"` + SessionName + `",` +
 				`"gclifetime":` + strconv.FormatInt(SessionGCMaxLifetime, 10) + `,` +
-				`"providerConfig":"` + SessionSavePath + `",` +
+				`"providerConfig":"` + filepath.ToSlash(SessionSavePath) + `",` +
 				`"secure":` + strconv.FormatBool(EnableHttpTLS) + `,` +
-				`"sessionIDHashFunc":"` + SessionHashFunc + `",` +
-				`"sessionIDHashKey":"` + SessionHashKey + `",` +
 				`"enableSetCookie":` + strconv.FormatBool(SessionAutoSetCookie) + `,` +
 				`"domain":"` + SessionDomain + `",` +
 				`"cookieLifeTime":` + strconv.Itoa(SessionCookieLifeTime) + `}`
@@ -396,23 +325,18 @@ func initBeforeHttpRun() {
 		}
 	}
 
-	middleware.VERSION = VERSION
-	middleware.AppName = AppName
-	middleware.RegisterErrorHandler()
+	registerDefaultErrorHandler()
 
 	if EnableDocs {
 		Get("/docs", serverDocs)
 		Get("/docs/*", serverDocs)
 	}
-
-	//init mime
-	AddAPPStartHook(initMime)
 }
 
 // this function is for test package init
 func TestBeegoInit(apppath string) {
 	AppPath = apppath
-	RunMode = "test"
+	os.Setenv("BEEGO_RUNMODE", "test")
 	AppConfigPath = filepath.Join(AppPath, "conf", "app.conf")
 	err := ParseConfig()
 	if err != nil && !os.IsNotExist(err) {

cache/cache.go

@@ -47,6 +47,8 @@ import (
 type Cache interface {
 	// get cached value by key.
 	Get(key string) interface{}
+	// GetMulti is a batch version of Get.
+	GetMulti(keys []string) []interface{}
 	// set cached value with key and expire time.
 	Put(key string, val interface{}, timeout int64) error
 	// delete cached value by key.
@@ -81,13 +83,13 @@ func Register(name string, adapter Cache) {
 // Create a new cache driver by adapter name and config string.
 // config need to be correct JSON as string: {"interval":360}.
 // it will start gc automatically.
-func NewCache(adapterName, config string) (adapter Cache, e error) {
+func NewCache(adapterName, config string) (adapter Cache, err error) {
 	adapter, ok := adapters[adapterName]
 	if !ok {
-		e = fmt.Errorf("cache: unknown adapter name %q (forgot to import?)", adapterName)
+		err = fmt.Errorf("cache: unknown adapter name %q (forgot to import?)", adapterName)
 		return
 	}
-	err := adapter.StartAndGC(config)
+	err = adapter.StartAndGC(config)
 	if err != nil {
 		adapter = nil
 	}

cache/cache_test.go

@@ -15,6 +15,7 @@
 package cache
 
 import (
+	"os"
 	"testing"
 	"time"
 )
@@ -64,10 +65,39 @@ func TestCache(t *testing.T) {
 	if bm.IsExist("astaxie") {
 		t.Error("delete err")
 	}
+
+	//test GetMulti
+	if err = bm.Put("astaxie", "author", 10); err != nil {
+		t.Error("set Error", err)
+	}
+	if !bm.IsExist("astaxie") {
+		t.Error("check err")
+	}
+	if v := bm.Get("astaxie"); v.(string) != "author" {
+		t.Error("get err")
+	}
+
+	if err = bm.Put("astaxie1", "author1", 10); err != nil {
+		t.Error("set Error", err)
+	}
+	if !bm.IsExist("astaxie1") {
+		t.Error("check err")
+	}
+
+	vv := bm.GetMulti([]string{"astaxie", "astaxie1"})
+	if len(vv) != 2 {
+		t.Error("GetMulti ERROR")
+	}
+	if vv[0].(string) != "author" {
+		t.Error("GetMulti ERROR")
+	}
+	if vv[1].(string) != "author1" {
+		t.Error("GetMulti ERROR")
+	}
 }
 
 func TestFileCache(t *testing.T) {
-	bm, err := NewCache("file", `{"CachePath":"/cache","FileSuffix":".bin","DirectoryLevel":2,"EmbedExpiry":0}`)
+	bm, err := NewCache("file", `{"CachePath":"cache","FileSuffix":".bin","DirectoryLevel":2,"EmbedExpiry":0}`)
 	if err != nil {
 		t.Error("init err")
 	}
@@ -101,6 +131,7 @@ func TestFileCache(t *testing.T) {
 	if bm.IsExist("astaxie") {
 		t.Error("delete err")
 	}
+
 	//test string
 	if err = bm.Put("astaxie", "author", 10); err != nil {
 		t.Error("set Error", err)
@@ -108,8 +139,28 @@ func TestFileCache(t *testing.T) {
 	if !bm.IsExist("astaxie") {
 		t.Error("check err")
 	}
-
 	if v := bm.Get("astaxie"); v.(string) != "author" {
 		t.Error("get err")
 	}
+
+	//test GetMulti
+	if err = bm.Put("astaxie1", "author1", 10); err != nil {
+		t.Error("set Error", err)
+	}
+	if !bm.IsExist("astaxie1") {
+		t.Error("check err")
+	}
+
+	vv := bm.GetMulti([]string{"astaxie", "astaxie1"})
+	if len(vv) != 2 {
+		t.Error("GetMulti ERROR")
+	}
+	if vv[0].(string) != "author" {
+		t.Error("GetMulti ERROR")
+	}
+	if vv[1].(string) != "author1" {
+		t.Error("GetMulti ERROR")
+	}
+
+	os.RemoveAll("cache")
 }

cache/file.go

@@ -92,8 +92,6 @@ func (fc *FileCache) StartAndGC(config string) error {
 
 // Init will make new dir for file cache if not exist.
 func (fc *FileCache) Init() {
-	app := filepath.Dir(os.Args[0])
-	fc.CachePath = filepath.Join(app, fc.CachePath)
 	if ok, _ := exists(fc.CachePath); !ok { // todo : error handle
 		_ = os.MkdirAll(fc.CachePath, os.ModePerm) // todo : error handle
 	}
@@ -134,6 +132,16 @@ func (fc *FileCache) Get(key string) interface{} {
 	return to.Data
 }
 
+// GetMulti gets values from file cache.
+// if non-exist or expired, return empty string.
+func (fc *FileCache) GetMulti(keys []string) []interface{} {
+	var rc []interface{}
+	for _, key := range keys {
+		rc = append(rc, fc.Get(key))
+	}
+	return rc
+}
+
 // Put value into file cache.
 // timeout means how long to keep this file, unit of ms.
 // if timeout equals FileCacheEmbedExpiry(default is 0), cache this item forever.

cache/memcache/memcache.go

@@ -63,6 +63,32 @@ func (rc *MemcacheCache) Get(key string) interface{} {
 	return nil
 }
 
+// get value from memcache.
+func (rc *MemcacheCache) GetMulti(keys []string) []interface{} {
+	size := len(keys)
+	var rv []interface{}
+	if rc.conn == nil {
+		if err := rc.connectInit(); err != nil {
+			for i := 0; i < size; i++ {
+				rv = append(rv, err)
+			}
+			return rv
+		}
+	}
+	mv, err := rc.conn.GetMulti(keys)
+	if err == nil {
+		for _, v := range mv {
+			rv = append(rv, string(v.Value))
+		}
+		return rv
+	} else {
+		for i := 0; i < size; i++ {
+			rv = append(rv, err)
+		}
+		return rv
+	}
+}
+
 // put value to memcache. only support string.
 func (rc *MemcacheCache) Put(key string, val interface{}, timeout int64) error {
 	if rc.conn == nil {

cache/memcache/memcache_test.go

@@ -0,0 +1,106 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package memcache
+
+import (
+	_ "github.com/bradfitz/gomemcache/memcache"
+
+	"github.com/astaxie/beego/cache"
+	"strconv"
+	"testing"
+	"time"
+)
+
+func TestRedisCache(t *testing.T) {
+	bm, err := cache.NewCache("memcache", `{"conn": "127.0.0.1:11211"}`)
+	if err != nil {
+		t.Error("init err")
+	}
+	if err = bm.Put("astaxie", "1", 10); err != nil {
+		t.Error("set Error", err)
+	}
+	if !bm.IsExist("astaxie") {
+		t.Error("check err")
+	}
+
+	time.Sleep(10 * time.Second)
+
+	if bm.IsExist("astaxie") {
+		t.Error("check err")
+	}
+	if err = bm.Put("astaxie", "1", 10); err != nil {
+		t.Error("set Error", err)
+	}
+
+	if v, err := strconv.Atoi(bm.Get("astaxie").(string)); err != nil || v != 1 {
+		t.Error("get err")
+	}
+
+	if err = bm.Incr("astaxie"); err != nil {
+		t.Error("Incr Error", err)
+	}
+
+	if v, err := strconv.Atoi(bm.Get("astaxie").(string)); err != nil || v != 2 {
+		t.Error("get err")
+	}
+
+	if err = bm.Decr("astaxie"); err != nil {
+		t.Error("Decr Error", err)
+	}
+
+	if v, err := strconv.Atoi(bm.Get("astaxie").(string)); err != nil || v != 1 {
+		t.Error("get err")
+	}
+	bm.Delete("astaxie")
+	if bm.IsExist("astaxie") {
+		t.Error("delete err")
+	}
+
+	//test string
+	if err = bm.Put("astaxie", "author", 10); err != nil {
+		t.Error("set Error", err)
+	}
+	if !bm.IsExist("astaxie") {
+		t.Error("check err")
+	}
+
+	if v := bm.Get("astaxie").(string); v != "author" {
+		t.Error("get err")
+	}
+
+	//test GetMulti
+	if err = bm.Put("astaxie1", "author1", 10); err != nil {
+		t.Error("set Error", err)
+	}
+	if !bm.IsExist("astaxie1") {
+		t.Error("check err")
+	}
+
+	vv := bm.GetMulti([]string{"astaxie", "astaxie1"})
+	if len(vv) != 2 {
+		t.Error("GetMulti ERROR")
+	}
+	if vv[0].(string) != "author" {
+		t.Error("GetMulti ERROR")
+	}
+	if vv[1].(string) != "author1" {
+		t.Error("GetMulti ERROR")
+	}
+
+	// test clear all
+	if err = bm.ClearAll(); err != nil {
+		t.Error("clear all err")
+	}
+}

cache/memory.go

@@ -64,6 +64,16 @@ func (bc *MemoryCache) Get(name string) interface{} {
 	return nil
 }
 
+// GetMulti gets caches from memory.
+// if non-existed or expired, return nil.
+func (bc *MemoryCache) GetMulti(names []string) []interface{} {
+	var rc []interface{}
+	for _, name := range names {
+		rc = append(rc, bc.Get(name))
+	}
+	return rc
+}
+
 // Put cache to memory.
 // if expired is 0, it will be cleaned by next gc operation ( default gc clock is 1 minute).
 func (bc *MemoryCache) Put(name string, value interface{}, expired int64) error {
@@ -202,7 +212,7 @@ func (bc *MemoryCache) vaccuum() {
 		if bc.items == nil {
 			return
 		}
-		for name, _ := range bc.items {
+		for name := range bc.items {
 			bc.item_expired(name)
 		}
 	}

cache/redis/redis.go

@@ -32,6 +32,7 @@ package redis
 import (
 	"encoding/json"
 	"errors"
+	"strconv"
 	"time"
 
 	"github.com/garyburd/redigo/redis"
@@ -48,7 +49,9 @@ var (
 type RedisCache struct {
 	p        *redis.Pool // redis connection pool
 	conninfo string
+	dbNum    int
 	key      string
+	password string
 }
 
 // create new redis cache with default collection name.
@@ -72,17 +75,49 @@ func (rc *RedisCache) Get(key string) interface{} {
 	return nil
 }
 
+// GetMulti get cache from redis.
+func (rc *RedisCache) GetMulti(keys []string) []interface{} {
+	size := len(keys)
+	var rv []interface{}
+	c := rc.p.Get()
+	defer c.Close()
+	var err error
+	for _, key := range keys {
+		err = c.Send("GET", key)
+		if err != nil {
+			goto ERROR
+		}
+	}
+	if err = c.Flush(); err != nil {
+		goto ERROR
+	}
+	for i := 0; i < size; i++ {
+		if v, err := c.Receive(); err == nil {
+			rv = append(rv, v.([]byte))
+		} else {
+			rv = append(rv, err)
+		}
+	}
+	return rv
+ERROR:
+	rv = rv[0:0]
+	for i := 0; i < size; i++ {
+		rv = append(rv, nil)
+	}
+
+	return rv
+}
+
 // put cache to redis.
 func (rc *RedisCache) Put(key string, val interface{}, timeout int64) error {
 	var err error
-	if _, err = rc.do("SET", key, val); err != nil {
+	if _, err = rc.do("SETEX", key, timeout, val); err != nil {
 		return err
 	}
 
 	if _, err = rc.do("HSET", rc.key, key, true); err != nil {
 		return err
 	}
-	_, err = rc.do("EXPIRE", key, timeout)
 	return err
 }
 
@@ -138,7 +173,7 @@ func (rc *RedisCache) ClearAll() error {
 }
 
 // start redis cache adapter.
-// config is like {"key":"collection key","conn":"connection info"}
+// config is like {"key":"collection key","conn":"connection info","dbNum":"0"}
 // the cache item in redis are stored forever,
 // so no gc operation.
 func (rc *RedisCache) StartAndGC(config string) error {
@@ -148,13 +183,20 @@ func (rc *RedisCache) StartAndGC(config string) error {
 	if _, ok := cf["key"]; !ok {
 		cf["key"] = DefaultKey
 	}
-
 	if _, ok := cf["conn"]; !ok {
 		return errors.New("config has no conn key")
 	}
-
+	if _, ok := cf["dbNum"]; !ok {
+		cf["dbNum"] = "0"
+	}
+	if _, ok := cf["password"]; !ok {
+		cf["password"] = ""
+	}
 	rc.key = cf["key"]
 	rc.conninfo = cf["conn"]
+	rc.dbNum, _ = strconv.Atoi(cf["dbNum"])
+	rc.password = cf["password"]
+
 	rc.connectInit()
 
 	c := rc.p.Get()
@@ -167,6 +209,22 @@ func (rc *RedisCache) StartAndGC(config string) error {
 func (rc *RedisCache) connectInit() {
 	dialFunc := func() (c redis.Conn, err error) {
 		c, err = redis.Dial("tcp", rc.conninfo)
+		if err != nil {
+			return nil, err
+		}
+
+		if rc.password != "" {
+			if _, err := c.Do("AUTH", rc.password); err != nil {
+				c.Close()
+				return nil, err
+			}
+		}
+
+		_, selecterr := c.Do("SELECT", rc.dbNum)
+		if selecterr != nil {
+			c.Close()
+			return nil, selecterr
+		}
 		return
 	}
 	// initialize a new pool

cache/redis/redis_test.go

@@ -67,6 +67,7 @@ func TestRedisCache(t *testing.T) {
 	if bm.IsExist("astaxie") {
 		t.Error("delete err")
 	}
+
 	//test string
 	if err = bm.Put("astaxie", "author", 10); err != nil {
 		t.Error("set Error", err)
@@ -78,6 +79,26 @@ func TestRedisCache(t *testing.T) {
 	if v, _ := redis.String(bm.Get("astaxie"), err); v != "author" {
 		t.Error("get err")
 	}
+
+	//test GetMulti
+	if err = bm.Put("astaxie1", "author1", 10); err != nil {
+		t.Error("set Error", err)
+	}
+	if !bm.IsExist("astaxie1") {
+		t.Error("check err")
+	}
+
+	vv := bm.GetMulti([]string{"astaxie", "astaxie1"})
+	if len(vv) != 2 {
+		t.Error("GetMulti ERROR")
+	}
+	if v, _ := redis.String(vv[0], nil); v != "author" {
+		t.Error("GetMulti ERROR")
+	}
+	if v, _ := redis.String(vv[1], nil); v != "author1" {
+		t.Error("GetMulti ERROR")
+	}
+
 	// test clear all
 	if err = bm.ClearAll(); err != nil {
 		t.Error("clear all err")

config.go

@@ -15,7 +15,6 @@
 package beego
 
 import (
-	"errors"
 	"fmt"
 	"html/template"
 	"os"
@@ -41,6 +40,7 @@ var (
 	EnableHttpListen       bool
 	HttpAddr               string
 	HttpPort               int
+	ListenTCP4             bool
 	EnableHttpTLS          bool
 	HttpsPort              int
 	HttpCertFile           string
@@ -48,20 +48,19 @@ var (
 	RecoverPanic           bool // flag of auto recover panic
 	AutoRender             bool // flag of render template automatically
 	ViewsPath              string
-	RunMode                string // run mode, "dev" or "prod"
-	AppConfig              config.ConfigContainer
+	AppConfig              *beegoAppConfig
+	RunMode                string           // run mode, "dev" or "prod"
 	GlobalSessions         *session.Manager // global session mananger
 	SessionOn              bool             // flag of starting session auto. default is false.
 	SessionProvider        string           // default session provider, memory, mysql , redis ,etc.
 	SessionName            string           // the cookie name when saving session id into cookie.
 	SessionGCMaxLifetime   int64            // session gc time for auto cleaning expired session.
 	SessionSavePath        string           // if use mysql/redis/file provider, define save path to connection info.
-	SessionHashFunc        string           // session hash generation func.
-	SessionHashKey         string           // session hash salt string.
 	SessionCookieLifeTime  int              // the life time of session id in cookie.
 	SessionAutoSetCookie   bool             // auto setcookie
 	SessionDomain          string           // the cookie domain default is empty
 	UseFcgi                bool
+	UseStdIo               bool
 	MaxMemory              int64
 	EnableGzip             bool // flag of enable gzip
 	DirectoryIndex         bool // flag of display directory index. default is false.
@@ -81,8 +80,140 @@ var (
 	FlashSeperator         string // used to seperate flash key:value
 	AppConfigProvider      string // config provider
 	EnableDocs             bool   // enable generate docs & server docs API Swagger
+	RouterCaseSensitive    bool   // router case sensitive default is true
+	AccessLogs             bool   // print access logs, default is false
+	Graceful               bool   // use graceful start the server
 )
 
+type beegoAppConfig struct {
+	innerConfig config.ConfigContainer
+}
+
+func newAppConfig(AppConfigProvider, AppConfigPath string) (*beegoAppConfig, error) {
+	ac, err := config.NewConfig(AppConfigProvider, AppConfigPath)
+	if err != nil {
+		return nil, err
+	}
+	rac := &beegoAppConfig{ac}
+	return rac, nil
+}
+
+func (b *beegoAppConfig) Set(key, val string) error {
+	err := b.innerConfig.Set(RunMode+"::"+key, val)
+	if err == nil {
+		return err
+	}
+	return b.innerConfig.Set(key, val)
+}
+
+func (b *beegoAppConfig) String(key string) string {
+	v := b.innerConfig.String(RunMode + "::" + key)
+	if v == "" {
+		return b.innerConfig.String(key)
+	}
+	return v
+}
+
+func (b *beegoAppConfig) Strings(key string) []string {
+	v := b.innerConfig.Strings(RunMode + "::" + key)
+	if v[0] == "" {
+		return b.innerConfig.Strings(key)
+	}
+	return v
+}
+
+func (b *beegoAppConfig) Int(key string) (int, error) {
+	v, err := b.innerConfig.Int(RunMode + "::" + key)
+	if err != nil {
+		return b.innerConfig.Int(key)
+	}
+	return v, nil
+}
+
+func (b *beegoAppConfig) Int64(key string) (int64, error) {
+	v, err := b.innerConfig.Int64(RunMode + "::" + key)
+	if err != nil {
+		return b.innerConfig.Int64(key)
+	}
+	return v, nil
+}
+
+func (b *beegoAppConfig) Bool(key string) (bool, error) {
+	v, err := b.innerConfig.Bool(RunMode + "::" + key)
+	if err != nil {
+		return b.innerConfig.Bool(key)
+	}
+	return v, nil
+}
+
+func (b *beegoAppConfig) Float(key string) (float64, error) {
+	v, err := b.innerConfig.Float(RunMode + "::" + key)
+	if err != nil {
+		return b.innerConfig.Float(key)
+	}
+	return v, nil
+}
+
+func (b *beegoAppConfig) DefaultString(key string, defaultval string) string {
+	v := b.String(key)
+	if v != "" {
+		return v
+	}
+	return defaultval
+}
+
+func (b *beegoAppConfig) DefaultStrings(key string, defaultval []string) []string {
+	v := b.Strings(key)
+	if len(v) != 0 {
+		return v
+	}
+	return defaultval
+}
+
+func (b *beegoAppConfig) DefaultInt(key string, defaultval int) int {
+	v, err := b.Int(key)
+	if err == nil {
+		return v
+	}
+	return defaultval
+}
+
+func (b *beegoAppConfig) DefaultInt64(key string, defaultval int64) int64 {
+	v, err := b.Int64(key)
+	if err == nil {
+		return v
+	}
+	return defaultval
+}
+
+func (b *beegoAppConfig) DefaultBool(key string, defaultval bool) bool {
+	v, err := b.Bool(key)
+	if err == nil {
+		return v
+	}
+	return defaultval
+}
+
+func (b *beegoAppConfig) DefaultFloat(key string, defaultval float64) float64 {
+	v, err := b.Float(key)
+	if err == nil {
+		return v
+	}
+	return defaultval
+}
+
+func (b *beegoAppConfig) DIY(key string) (interface{}, error) {
+	return b.innerConfig.DIY(key)
+}
+
+func (b *beegoAppConfig) GetSection(section string) (map[string]string, error) {
+	return b.innerConfig.GetSection(section)
+}
+
+func (b *beegoAppConfig) SaveConfigFile(filename string) error {
+	return b.innerConfig.SaveConfigFile(filename)
+}
+
 func init() {
 	// create beego application
 	BeeApp = NewApp()
@@ -134,12 +265,11 @@ func init() {
 	SessionName = "beegosessionID"
 	SessionGCMaxLifetime = 3600
 	SessionSavePath = ""
-	SessionHashFunc = "sha1"
-	SessionHashKey = "beegoserversessionkey"
 	SessionCookieLifeTime = 0 //set cookie default is the brower life
 	SessionAutoSetCookie = true
 
 	UseFcgi = false
+	UseStdIo = false
 
 	MaxMemory = 1 << 26 //64MB
 
@@ -164,6 +294,8 @@ func init() {
 	FlashName = "BEEGO_FLASH"
 	FlashSeperator = "BEEGOFLASH"
 
+	RouterCaseSensitive = true
+
 	runtime.GOMAXPROCS(runtime.NumCPU())
 
 	// init BeeLogger
@@ -172,262 +304,214 @@ func init() {
 	if err != nil {
 		fmt.Println("init console log error:", err)
 	}
+	SetLogFuncCall(true)
 
 	err = ParseConfig()
-	if err != nil && !os.IsNotExist(err) {
+	if err != nil && os.IsNotExist(err) {
 		// for init if doesn't have app.conf will not panic
-		Info(err)
+		ac := config.NewFakeConfig()
+		AppConfig = &beegoAppConfig{ac}
+		Warning(err)
 	}
 }
 
 // ParseConfig parsed default config file.
 // now only support ini, next will support json.
 func ParseConfig() (err error) {
-	AppConfig, err = config.NewConfig(AppConfigProvider, AppConfigPath)
+	AppConfig, err = newAppConfig(AppConfigProvider, AppConfigPath)
 	if err != nil {
-		AppConfig = config.NewFakeConfig()
 		return err
-	} else {
+	}
+	envRunMode := os.Getenv("BEEGO_RUNMODE")
+	// set the runmode first
+	if envRunMode != "" {
+		RunMode = envRunMode
+	} else if runmode := AppConfig.String("RunMode"); runmode != "" {
+		RunMode = runmode
+	}
 
-		if v, err := GetConfig("string", "HttpAddr"); err == nil {
-			HttpAddr = v.(string)
+	HttpAddr = AppConfig.String("HttpAddr")
+
+	if v, err := AppConfig.Int("HttpPort"); err == nil {
+		HttpPort = v
+	}
+
+	if v, err := AppConfig.Bool("ListenTCP4"); err == nil {
+		ListenTCP4 = v
+	}
+
+	if v, err := AppConfig.Bool("EnableHttpListen"); err == nil {
+		EnableHttpListen = v
+	}
+
+	if maxmemory, err := AppConfig.Int64("MaxMemory"); err == nil {
+		MaxMemory = maxmemory
+	}
+
+	if appname := AppConfig.String("AppName"); appname != "" {
+		AppName = appname
+	}
+
+	if autorender, err := AppConfig.Bool("AutoRender"); err == nil {
+		AutoRender = autorender
+	}
+
+	if autorecover, err := AppConfig.Bool("RecoverPanic"); err == nil {
+		RecoverPanic = autorecover
+	}
+
+	if views := AppConfig.String("ViewsPath"); views != "" {
+		ViewsPath = views
+	}
+
+	if sessionon, err := AppConfig.Bool("SessionOn"); err == nil {
+		SessionOn = sessionon
+	}
+
+	if sessProvider := AppConfig.String("SessionProvider"); sessProvider != "" {
+		SessionProvider = sessProvider
+	}
+
+	if sessName := AppConfig.String("SessionName"); sessName != "" {
+		SessionName = sessName
+	}
+
+	if sesssavepath := AppConfig.String("SessionSavePath"); sesssavepath != "" {
+		SessionSavePath = sesssavepath
+	}
+
+	if sessMaxLifeTime, err := AppConfig.Int64("SessionGCMaxLifetime"); err == nil && sessMaxLifeTime != 0 {
+		SessionGCMaxLifetime = sessMaxLifeTime
+	}
+
+	if sesscookielifetime, err := AppConfig.Int("SessionCookieLifeTime"); err == nil && sesscookielifetime != 0 {
+		SessionCookieLifeTime = sesscookielifetime
+	}
+
+	if usefcgi, err := AppConfig.Bool("UseFcgi"); err == nil {
+		UseFcgi = usefcgi
+	}
+
+	if enablegzip, err := AppConfig.Bool("EnableGzip"); err == nil {
+		EnableGzip = enablegzip
+	}
+
+	if directoryindex, err := AppConfig.Bool("DirectoryIndex"); err == nil {
+		DirectoryIndex = directoryindex
+	}
+
+	if timeout, err := AppConfig.Int64("HttpServerTimeOut"); err == nil {
+		HttpServerTimeOut = timeout
+	}
+
+	if errorsshow, err := AppConfig.Bool("ErrorsShow"); err == nil {
+		ErrorsShow = errorsshow
+	}
+
+	if copyrequestbody, err := AppConfig.Bool("CopyRequestBody"); err == nil {
+		CopyRequestBody = copyrequestbody
+	}
+
+	if xsrfkey := AppConfig.String("XSRFKEY"); xsrfkey != "" {
+		XSRFKEY = xsrfkey
+	}
+
+	if enablexsrf, err := AppConfig.Bool("EnableXSRF"); err == nil {
+		EnableXSRF = enablexsrf
+	}
+
+	if expire, err := AppConfig.Int("XSRFExpire"); err == nil {
+		XSRFExpire = expire
+	}
+
+	if tplleft := AppConfig.String("TemplateLeft"); tplleft != "" {
+		TemplateLeft = tplleft
+	}
+
+	if tplright := AppConfig.String("TemplateRight"); tplright != "" {
+		TemplateRight = tplright
+	}
+
+	if httptls, err := AppConfig.Bool("EnableHttpTLS"); err == nil {
+		EnableHttpTLS = httptls
+	}
+
+	if httpsport, err := AppConfig.Int("HttpsPort"); err == nil {
+		HttpsPort = httpsport
+	}
+
+	if certfile := AppConfig.String("HttpCertFile"); certfile != "" {
+		HttpCertFile = certfile
+	}
+
+	if keyfile := AppConfig.String("HttpKeyFile"); keyfile != "" {
+		HttpKeyFile = keyfile
+	}
+
+	if serverName := AppConfig.String("BeegoServerName"); serverName != "" {
+		BeegoServerName = serverName
+	}
+
+	if flashname := AppConfig.String("FlashName"); flashname != "" {
+		FlashName = flashname
+	}
+
+	if flashseperator := AppConfig.String("FlashSeperator"); flashseperator != "" {
+		FlashSeperator = flashseperator
+	}
+
+	if sd := AppConfig.String("StaticDir"); sd != "" {
+		for k := range StaticDir {
+			delete(StaticDir, k)
 		}
-
-		if v, err := GetConfig("int", "HttpPort"); err == nil {
-			HttpPort = v.(int)
-		}
-
-		if v, err := GetConfig("bool", "EnableHttpListen"); err == nil {
-			EnableHttpListen = v.(bool)
-		}
-
-		if maxmemory, err := GetConfig("int64", "MaxMemory"); err == nil {
-			MaxMemory = maxmemory.(int64)
-		}
-
-		if appname, _ := GetConfig("string", "AppName"); appname != "" {
-			AppName = appname.(string)
-		}
-
-		if runmode, _ := GetConfig("string", "RunMode"); runmode != "" {
-			RunMode = runmode.(string)
-		}
-
-		if autorender, err := GetConfig("bool", "AutoRender"); err == nil {
-			AutoRender = autorender.(bool)
-		}
-
-		if autorecover, err := GetConfig("bool", "RecoverPanic"); err == nil {
-			RecoverPanic = autorecover.(bool)
-		}
-
-		if views, _ := GetConfig("string", "ViewsPath"); views != "" {
-			ViewsPath = views.(string)
-		}
-
-		if sessionon, err := GetConfig("bool", "SessionOn"); err == nil {
-			SessionOn = sessionon.(bool)
-		}
-
-		if sessProvider, _ := GetConfig("string", "SessionProvider"); sessProvider != "" {
-			SessionProvider = sessProvider.(string)
-		}
-
-		if sessName, _ := GetConfig("string", "SessionName"); sessName != "" {
-			SessionName = sessName.(string)
-		}
-
-		if sesssavepath, _ := GetConfig("string", "SessionSavePath"); sesssavepath != "" {
-			SessionSavePath = sesssavepath.(string)
-		}
-
-		if sesshashfunc, _ := GetConfig("string", "SessionHashFunc"); sesshashfunc != "" {
-			SessionHashFunc = sesshashfunc.(string)
-		}
-
-		if sesshashkey, _ := GetConfig("string", "SessionHashKey"); sesshashkey != "" {
-			SessionHashKey = sesshashkey.(string)
-		}
-
-		if sessMaxLifeTime, err := GetConfig("int64", "SessionGCMaxLifetime"); err == nil && sessMaxLifeTime != 0 {
-			SessionGCMaxLifetime = sessMaxLifeTime.(int64)
-		}
-
-		if sesscookielifetime, err := GetConfig("int", "SessionCookieLifeTime"); err == nil && sesscookielifetime != 0 {
-			SessionCookieLifeTime = sesscookielifetime.(int)
-		}
-
-		if usefcgi, err := GetConfig("bool", "UseFcgi"); err == nil {
-			UseFcgi = usefcgi.(bool)
-		}
-
-		if enablegzip, err := GetConfig("bool", "EnableGzip"); err == nil {
-			EnableGzip = enablegzip.(bool)
-		}
-
-		if directoryindex, err := GetConfig("bool", "DirectoryIndex"); err == nil {
-			DirectoryIndex = directoryindex.(bool)
-		}
-
-		if timeout, err := GetConfig("int64", "HttpServerTimeOut"); err == nil {
-			HttpServerTimeOut = timeout.(int64)
-		}
-
-		if errorsshow, err := GetConfig("bool", "ErrorsShow"); err == nil {
-			ErrorsShow = errorsshow.(bool)
-		}
-
-		if copyrequestbody, err := GetConfig("bool", "CopyRequestBody"); err == nil {
-			CopyRequestBody = copyrequestbody.(bool)
-		}
-
-		if xsrfkey, _ := GetConfig("string", "XSRFKEY"); xsrfkey != "" {
-			XSRFKEY = xsrfkey.(string)
-		}
-
-		if enablexsrf, err := GetConfig("bool", "EnableXSRF"); err == nil {
-			EnableXSRF = enablexsrf.(bool)
-		}
-
-		if expire, err := GetConfig("int", "XSRFExpire"); err == nil {
-			XSRFExpire = expire.(int)
-		}
-
-		if tplleft, _ := GetConfig("string", "TemplateLeft"); tplleft != "" {
-			TemplateLeft = tplleft.(string)
-		}
-
-		if tplright, _ := GetConfig("string", "TemplateRight"); tplright != "" {
-			TemplateRight = tplright.(string)
-		}
-
-		if httptls, err := GetConfig("bool", "EnableHttpTLS"); err == nil {
-			EnableHttpTLS = httptls.(bool)
-		}
-
-		if httpsport, err := GetConfig("int", "HttpsPort"); err == nil {
-			HttpsPort = httpsport.(int)
-		}
-
-		if certfile, _ := GetConfig("string", "HttpCertFile"); certfile != "" {
-			HttpCertFile = certfile.(string)
-		}
-
-		if keyfile, _ := GetConfig("string", "HttpKeyFile"); keyfile != "" {
-			HttpKeyFile = keyfile.(string)
-		}
-
-		if serverName, _ := GetConfig("string", "BeegoServerName"); serverName != "" {
-			BeegoServerName = serverName.(string)
-		}
-
-		if flashname, _ := GetConfig("string", "FlashName"); flashname != "" {
-			FlashName = flashname.(string)
-		}
-
-		if flashseperator, _ := GetConfig("string", "FlashSeperator"); flashseperator != "" {
-			FlashSeperator = flashseperator.(string)
-		}
-
-		if sd, _ := GetConfig("string", "StaticDir"); sd != "" {
-			for k := range StaticDir {
-				delete(StaticDir, k)
+		sds := strings.Fields(sd)
+		for _, v := range sds {
+			if url2fsmap := strings.SplitN(v, ":", 2); len(url2fsmap) == 2 {
+				StaticDir["/"+strings.TrimRight(url2fsmap[0], "/")] = url2fsmap[1]
+			} else {
+				StaticDir["/"+strings.TrimRight(url2fsmap[0], "/")] = url2fsmap[0]
 			}
-			sds := strings.Fields(sd.(string))
-			for _, v := range sds {
-				if url2fsmap := strings.SplitN(v, ":", 2); len(url2fsmap) == 2 {
-					StaticDir["/"+strings.TrimRight(url2fsmap[0], "/")] = url2fsmap[1]
-				} else {
-					StaticDir["/"+strings.TrimRight(url2fsmap[0], "/")] = url2fsmap[0]
+		}
+	}
+
+	if sgz := AppConfig.String("StaticExtensionsToGzip"); sgz != "" {
+		extensions := strings.Split(sgz, ",")
+		if len(extensions) > 0 {
+			StaticExtensionsToGzip = []string{}
+			for _, ext := range extensions {
+				if len(ext) == 0 {
+					continue
 				}
-			}
-		}
-
-		if sgz, _ := GetConfig("string", "StaticExtensionsToGzip"); sgz != "" {
-			extensions := strings.Split(sgz.(string), ",")
-			if len(extensions) > 0 {
-				StaticExtensionsToGzip = []string{}
-				for _, ext := range extensions {
-					if len(ext) == 0 {
-						continue
-					}
-					extWithDot := ext
-					if extWithDot[:1] != "." {
-						extWithDot = "." + extWithDot
-					}
-					StaticExtensionsToGzip = append(StaticExtensionsToGzip, extWithDot)
+				extWithDot := ext
+				if extWithDot[:1] != "." {
+					extWithDot = "." + extWithDot
 				}
+				StaticExtensionsToGzip = append(StaticExtensionsToGzip, extWithDot)
 			}
 		}
+	}
 
-		if enableadmin, err := GetConfig("bool", "EnableAdmin"); err == nil {
-			EnableAdmin = enableadmin.(bool)
-		}
+	if enableadmin, err := AppConfig.Bool("EnableAdmin"); err == nil {
+		EnableAdmin = enableadmin
+	}
 
-		if adminhttpaddr, _ := GetConfig("string", "AdminHttpAddr"); adminhttpaddr != "" {
-			AdminHttpAddr = adminhttpaddr.(string)
-		}
+	if adminhttpaddr := AppConfig.String("AdminHttpAddr"); adminhttpaddr != "" {
+		AdminHttpAddr = adminhttpaddr
+	}
 
-		if adminhttpport, err := GetConfig("int", "AdminHttpPort"); err == nil {
-			AdminHttpPort = adminhttpport.(int)
-		}
+	if adminhttpport, err := AppConfig.Int("AdminHttpPort"); err == nil {
+		AdminHttpPort = adminhttpport
+	}
 
-		if enabledocs, err := GetConfig("bool", "EnableDocs"); err == nil {
-			EnableDocs = enabledocs.(bool)
-		}
+	if enabledocs, err := AppConfig.Bool("EnableDocs"); err == nil {
+		EnableDocs = enabledocs
+	}
+
+	if casesensitive, err := AppConfig.Bool("RouterCaseSensitive"); err == nil {
+		RouterCaseSensitive = casesensitive
+	}
+	if graceful, err := AppConfig.Bool("Graceful"); err == nil {
+		Graceful = graceful
 	}
 	return nil
 }
-
-// Getconfig throw the Runmode
-// [dev]
-// name = astaixe
-// IsEnable = false
-// [prod]
-// name = slene
-// IsEnable = true
-//
-// usage:
-// GetConfig("string", "name")
-// GetConfig("bool", "IsEnable")
-func GetConfig(typ, key string) (interface{}, error) {
-	switch typ {
-	case "string":
-		v := AppConfig.String(RunMode + "::" + key)
-		if v == "" {
-			v = AppConfig.String(key)
-		}
-		return v, nil
-	case "strings":
-		v := AppConfig.Strings(RunMode + "::" + key)
-		if len(v) == 0 {
-			v = AppConfig.Strings(key)
-		}
-		return v, nil
-	case "int":
-		v, err := AppConfig.Int(RunMode + "::" + key)
-		if err != nil || v == 0 {
-			return AppConfig.Int(key)
-		}
-		return v, nil
-	case "bool":
-		v, err := AppConfig.Bool(RunMode + "::" + key)
-		if err != nil {
-			return AppConfig.Bool(key)
-		}
-		return v, nil
-	case "int64":
-		v, err := AppConfig.Int64(RunMode + "::" + key)
-		if err != nil || v == 0 {
-			return AppConfig.Int64(key)
-		}
-		return v, nil
-	case "float":
-		v, err := AppConfig.Float(RunMode + "::" + key)
-		if err != nil || v == 0 {
-			return AppConfig.Float(key)
-		}
-		return v, nil
-	}
-	return "", errors.New("not support type")
-}

config/ini.go

@@ -48,6 +48,10 @@ type IniConfig struct {
 
 // ParseFile creates a new Config and parses the file configuration from the named file.
 func (ini *IniConfig) Parse(name string) (ConfigContainer, error) {
+	return ini.parseFile(name)
+}
+
+func (ini *IniConfig) parseFile(name string) (*IniConfigContainer, error) {
 	file, err := os.Open(name)
 	if err != nil {
 		return nil, err
@@ -66,6 +70,13 @@ func (ini *IniConfig) Parse(name string) (ConfigContainer, error) {
 
 	var comment bytes.Buffer
 	buf := bufio.NewReader(file)
+	// check the BOM
+	head, err := buf.Peek(3)
+	if err == nil && head[0] == 239 && head[1] == 187 && head[2] == 191 {
+		for i := 1; i <= 3; i++ {
+			buf.ReadByte()
+		}
+	}
 	section := DEFAULT_SECTION
 	for {
 		line, _, err := buf.ReadLine()
@@ -108,13 +119,48 @@ func (ini *IniConfig) Parse(name string) (ConfigContainer, error) {
 			cfg.data[section] = make(map[string]string)
 		}
 		keyValue := bytes.SplitN(line, bEqual, 2)
+
+		key := string(bytes.TrimSpace(keyValue[0])) // key name case insensitive
+		key = strings.ToLower(key)
+
+		// 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) {
+					otherfile = path.Join(path.Dir(name), 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)
+					}
+					for k, v := range dt {
+						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
+			}
+		}
+
+		if len(keyValue) != 2 {
+			return nil, errors.New("read the content error: \"" + string(line) + "\", should key = val")
+		}
 		val := bytes.TrimSpace(keyValue[1])
 		if bytes.HasPrefix(val, bDQuote) {
 			val = bytes.Trim(val, `"`)
 		}
 
-		key := string(bytes.TrimSpace(keyValue[0])) // key name case insensitive
-		key = strings.ToLower(key)
 		cfg.data[section][key] = string(val)
 		if comment.Len() > 0 {
 			cfg.keyComment[section+"."+key] = comment.String()
@@ -147,7 +193,7 @@ type IniConfigContainer struct {
 
 // Bool returns the boolean value for a given key.
 func (c *IniConfigContainer) Bool(key string) (bool, error) {
-	return strconv.ParseBool(c.getdata(strings.ToLower(key)))
+	return strconv.ParseBool(c.getdata(key))
 }
 
 // DefaultBool returns the boolean value for a given key.
@@ -162,7 +208,7 @@ func (c *IniConfigContainer) DefaultBool(key string, defaultval bool) bool {
 
 // Int returns the integer value for a given key.
 func (c *IniConfigContainer) Int(key string) (int, error) {
-	return strconv.Atoi(c.getdata(strings.ToLower(key)))
+	return strconv.Atoi(c.getdata(key))
 }
 
 // DefaultInt returns the integer value for a given key.
@@ -177,7 +223,7 @@ func (c *IniConfigContainer) DefaultInt(key string, defaultval int) int {
 
 // Int64 returns the int64 value for a given key.
 func (c *IniConfigContainer) Int64(key string) (int64, error) {
-	return strconv.ParseInt(c.getdata(strings.ToLower(key)), 10, 64)
+	return strconv.ParseInt(c.getdata(key), 10, 64)
 }
 
 // DefaultInt64 returns the int64 value for a given key.
@@ -192,7 +238,7 @@ func (c *IniConfigContainer) DefaultInt64(key string, defaultval int64) int64 {
 
 // Float returns the float value for a given key.
 func (c *IniConfigContainer) Float(key string) (float64, error) {
-	return strconv.ParseFloat(c.getdata(strings.ToLower(key)), 64)
+	return strconv.ParseFloat(c.getdata(key), 64)
 }
 
 // DefaultFloat returns the float64 value for a given key.
@@ -207,8 +253,7 @@ func (c *IniConfigContainer) DefaultFloat(key string, defaultval float64) float6
 
 // String returns the string value for a given key.
 func (c *IniConfigContainer) String(key string) string {
-	key = strings.ToLower(key)
-	return c.getdata(strings.ToLower(key))
+	return c.getdata(key)
 }
 
 // DefaultString returns the string value for a given key.
@@ -255,21 +300,8 @@ func (c *IniConfigContainer) SaveConfigFile(filename string) (err error) {
 	defer f.Close()
 
 	buf := bytes.NewBuffer(nil)
-	for section, dt := range c.data {
-		// Write section comments.
-		if v, ok := c.sectionComment[section]; ok {
-			if _, err = buf.WriteString(string(bNumComment) + v + lineBreak); err != nil {
-				return err
-			}
-		}
-
-		if section != DEFAULT_SECTION {
-			// Write section name.
-			if _, err = buf.WriteString(string(sectionStart) + section + string(sectionEnd) + lineBreak); err != nil {
-				return err
-			}
-		}
-
+	// Save default section at first place
+	if dt, ok := c.data[DEFAULT_SECTION]; ok {
 		for key, val := range dt {
 			if key != " " {
 				// Write key comments.
@@ -291,6 +323,43 @@ func (c *IniConfigContainer) SaveConfigFile(filename string) (err error) {
 			return err
 		}
 	}
+	// Save named sections
+	for section, dt := range c.data {
+		if section != DEFAULT_SECTION {
+			// Write section comments.
+			if v, ok := c.sectionComment[section]; ok {
+				if _, err = buf.WriteString(string(bNumComment) + v + lineBreak); err != nil {
+					return err
+				}
+			}
+
+			// Write section name.
+			if _, err = buf.WriteString(string(sectionStart) + section + string(sectionEnd) + lineBreak); err != nil {
+				return err
+			}
+
+			for key, val := range dt {
+				if key != " " {
+					// Write key comments.
+					if v, ok := c.keyComment[key]; ok {
+						if _, err = buf.WriteString(string(bNumComment) + v + lineBreak); err != nil {
+							return err
+						}
+					}
+
+					// Write key and value.
+					if _, err = buf.WriteString(key + string(bEqual) + val + lineBreak); err != nil {
+						return err
+					}
+				}
+			}
+
+			// Put a line between sections.
+			if _, err = buf.WriteString(lineBreak); err != nil {
+				return err
+			}
+		}
+	}
 
 	if _, err = buf.WriteTo(f); err != nil {
 		return err
@@ -338,15 +407,15 @@ func (c *IniConfigContainer) DIY(key string) (v interface{}, err error) {
 
 // section.key or key
 func (c *IniConfigContainer) getdata(key string) string {
-	c.RLock()
-	defer c.RUnlock()
 	if len(key) == 0 {
 		return ""
 	}
+	c.RLock()
+	defer c.RUnlock()
 
 	var (
 		section, k string
-		sectionKey []string = strings.Split(key, "::")
+		sectionKey []string = strings.Split(strings.ToLower(key), "::")
 	)
 	if len(sectionKey) >= 2 {
 		section = sectionKey[0]

config/json.go

@@ -17,13 +17,10 @@ package config
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"io/ioutil"
 	"os"
-	"path"
 	"strings"
 	"sync"
-	"time"
 )
 
 // JsonConfig is a json config parser and implements Config interface.
@@ -41,13 +38,19 @@ func (js *JsonConfig) Parse(filename string) (ConfigContainer, error) {
 	if err != nil {
 		return nil, err
 	}
+
+	return js.ParseData(content)
+}
+
+// ParseData returns a ConfigContainer with json string
+func (js *JsonConfig) ParseData(data []byte) (ConfigContainer, error) {
 	x := &JsonConfigContainer{
 		data: make(map[string]interface{}),
 	}
-	err = json.Unmarshal(content, &x.data)
+	err := json.Unmarshal(data, &x.data)
 	if err != nil {
 		var wrappingArray []interface{}
-		err2 := json.Unmarshal(content, &wrappingArray)
+		err2 := json.Unmarshal(data, &wrappingArray)
 		if err2 != nil {
 			return nil, err
 		}
@@ -56,16 +59,6 @@ func (js *JsonConfig) Parse(filename string) (ConfigContainer, error) {
 	return x, nil
 }
 
-func (js *JsonConfig) ParseData(data []byte) (ConfigContainer, error) {
-	// Save memory data to temporary file
-	tmpName := path.Join(os.TempDir(), "beego", fmt.Sprintf("%d", time.Now().Nanosecond()))
-	os.MkdirAll(path.Dir(tmpName), os.ModePerm)
-	if err := ioutil.WriteFile(tmpName, data, 0655); err != nil {
-		return nil, err
-	}
-	return js.Parse(tmpName)
-}
-
 // A Config represents the json configuration.
 // Only when get value, support key as section:name type.
 type JsonConfigContainer struct {
@@ -88,11 +81,10 @@ func (c *JsonConfigContainer) Bool(key string) (bool, error) {
 // DefaultBool return the bool value if has no error
 // otherwise return the defaultval
 func (c *JsonConfigContainer) DefaultBool(key string, defaultval bool) bool {
-	if v, err := c.Bool(key); err != nil {
-		return defaultval
-	} else {
+	if v, err := c.Bool(key); err == nil {
 		return v
 	}
+	return defaultval
 }
 
 // Int returns the integer value for a given key.
@@ -110,11 +102,10 @@ func (c *JsonConfigContainer) Int(key string) (int, error) {
 // DefaultInt returns the integer value for a given key.
 // if err != nil return defaltval
 func (c *JsonConfigContainer) DefaultInt(key string, defaultval int) int {
-	if v, err := c.Int(key); err != nil {
-		return defaultval
-	} else {
+	if v, err := c.Int(key); err == nil {
 		return v
 	}
+	return defaultval
 }
 
 // Int64 returns the int64 value for a given key.
@@ -132,11 +123,10 @@ func (c *JsonConfigContainer) Int64(key string) (int64, error) {
 // DefaultInt64 returns the int64 value for a given key.
 // if err != nil return defaltval
 func (c *JsonConfigContainer) DefaultInt64(key string, defaultval int64) int64 {
-	if v, err := c.Int64(key); err != nil {
-		return defaultval
-	} else {
+	if v, err := c.Int64(key); err == nil {
 		return v
 	}
+	return defaultval
 }
 
 // Float returns the float value for a given key.
@@ -154,11 +144,10 @@ func (c *JsonConfigContainer) Float(key string) (float64, error) {
 // DefaultFloat returns the float64 value for a given key.
 // if err != nil return defaltval
 func (c *JsonConfigContainer) DefaultFloat(key string, defaultval float64) float64 {
-	if v, err := c.Float(key); err != nil {
-		return defaultval
-	} else {
+	if v, err := c.Float(key); err == nil {
 		return v
 	}
+	return defaultval
 }
 
 // String returns the string value for a given key.
@@ -175,35 +164,37 @@ func (c *JsonConfigContainer) String(key string) string {
 // DefaultString returns the string value for a given key.
 // if err != nil return defaltval
 func (c *JsonConfigContainer) DefaultString(key string, defaultval string) string {
-	if v := c.String(key); v == "" {
-		return defaultval
-	} else {
+	// TODO FIXME should not use "" to replace non existance
+	if v := c.String(key); v != "" {
 		return v
 	}
+	return defaultval
 }
 
 // Strings returns the []string value for a given key.
 func (c *JsonConfigContainer) Strings(key string) []string {
+	stringVal := c.String(key)
+	if stringVal == "" {
+		return []string{}
+	}
 	return strings.Split(c.String(key), ";")
 }
 
 // DefaultStrings returns the []string value for a given key.
 // if err != nil return defaltval
 func (c *JsonConfigContainer) DefaultStrings(key string, defaultval []string) []string {
-	if v := c.Strings(key); len(v) == 0 {
-		return defaultval
-	} else {
+	if v := c.Strings(key); len(v) > 0 {
 		return v
 	}
+	return defaultval
 }
 
 // GetSection returns map for the given section
 func (c *JsonConfigContainer) GetSection(section string) (map[string]string, error) {
 	if v, ok := c.data[section]; ok {
 		return v.(map[string]string), nil
-	} else {
-		return nil, errors.New("not exist setction")
 	}
+	return nil, errors.New("nonexist section " + section)
 }
 
 // SaveConfigFile save the config into file
@@ -222,7 +213,7 @@ func (c *JsonConfigContainer) SaveConfigFile(filename string) (err error) {
 	return err
 }
 
-// WriteValue writes a new value for key.
+// Set writes a new value for key.
 func (c *JsonConfigContainer) Set(key, val string) error {
 	c.Lock()
 	defer c.Unlock()
@@ -241,18 +232,20 @@ func (c *JsonConfigContainer) DIY(key string) (v interface{}, err error) {
 
 // section.key or key
 func (c *JsonConfigContainer) getData(key string) interface{} {
-	c.RLock()
-	defer c.RUnlock()
 	if len(key) == 0 {
 		return nil
 	}
-	sectionKey := strings.Split(key, "::")
-	if len(sectionKey) >= 2 {
-		curValue, ok := c.data[sectionKey[0]]
+
+	c.RLock()
+	defer c.RUnlock()
+
+	sectionKeys := strings.Split(key, "::")
+	if len(sectionKeys) >= 2 {
+		curValue, ok := c.data[sectionKeys[0]]
 		if !ok {
 			return nil
 		}
-		for _, key := range sectionKey[1:] {
+		for _, key := range sectionKeys[1:] {
 			if v, ok := curValue.(map[string]interface{}); ok {
 				if curValue, ok = v[key]; !ok {
 					return nil

config/json_test.go

@@ -21,6 +21,7 @@ import (
 
 var jsoncontext = `{
 "appname": "beeapi",
+"testnames": "foo;bar",
 "httpport": 8080,
 "mysqlport": 3600,
 "PI": 3.1415976,
@@ -28,8 +29,8 @@ var jsoncontext = `{
 "autorender": false,
 "copyrequestbody": true,
 "database": {
-        "host": "host",                 
-        "port": "port",                 
+        "host": "host",
+        "port": "port",
         "database": "database",
         "username": "username",
         "password": "password",
@@ -122,6 +123,12 @@ func TestJson(t *testing.T) {
 	if jsonconf.String("runmode") != "dev" {
 		t.Fatal("runmode not equal to dev")
 	}
+	if v := jsonconf.Strings("unknown"); len(v) > 0 {
+		t.Fatal("unknown strings, the length should be 0")
+	}
+	if v := jsonconf.Strings("testnames"); len(v) != 2 {
+		t.Fatal("testnames length should be 2")
+	}
 	if v, err := jsonconf.Bool("autorender"); err != nil || v != false {
 		t.Error(v)
 		t.Fatal(err)
@@ -179,4 +186,8 @@ func TestJson(t *testing.T) {
 	if _, err := jsonconf.Bool("unknown"); err == nil {
 		t.Error("unknown keys should return an error when expecting a Bool")
 	}
+
+	if !jsonconf.DefaultBool("unknow", true) {
+		t.Error("unknown keys with default value wrong")
+	}
 }

context/context.go

@@ -31,7 +31,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/astaxie/beego/middleware"
 	"github.com/astaxie/beego/utils"
 )
 
@@ -49,26 +48,13 @@ type Context struct {
 // It sends http response header directly.
 func (ctx *Context) Redirect(status int, localurl string) {
 	ctx.Output.Header("Location", localurl)
-	ctx.Output.SetStatus(status)
+	ctx.ResponseWriter.WriteHeader(status)
 }
 
 // Abort stops this request.
-// if middleware.ErrorMaps exists, panic body.
-// if middleware.HTTPExceptionMaps exists, panic HTTPException struct with status and body string.
+// if beego.ErrorMaps exists, panic body.
 func (ctx *Context) Abort(status int, body string) {
 	ctx.ResponseWriter.WriteHeader(status)
-	// first panic from ErrorMaps, is is user defined error functions.
-	if _, ok := middleware.ErrorMaps[body]; ok {
-		panic(body)
-	}
-	// second panic from HTTPExceptionMaps, it is system defined functions.
-	if e, ok := middleware.HTTPExceptionMaps[status]; ok {
-		if len(body) >= 1 {
-			e.Description = body
-		}
-		panic(e)
-	}
-	// last panic user string
 	panic(body)
 }
 
@@ -154,8 +140,11 @@ func (ctx *Context) CheckXsrfCookie() bool {
 	}
 	if token == "" {
 		ctx.Abort(403, "'_xsrf' argument missing from POST")
-	} else if ctx._xsrf_token != token {
+		return false
+	}
+	if ctx._xsrf_token != token {
 		ctx.Abort(403, "XSRF cookie does not match POST argument")
+		return false
 	}
 	return true
 }

context/input.go

@@ -21,13 +21,22 @@ import (
 	"net/http"
 	"net/url"
 	"reflect"
+	"regexp"
 	"strconv"
 	"strings"
 
 	"github.com/astaxie/beego/session"
 )
 
-// BeegoInput operates the http request header ,data ,cookie and body.
+// Regexes for checking the accept headers
+// TODO make sure these are correct
+var (
+	acceptsHtmlRegex = regexp.MustCompile(`(text/html|application/xhtml\+xml)(?:,|$)`)
+	acceptsXmlRegex  = regexp.MustCompile(`(application/xml|text/xml)(?:,|$)`)
+	acceptsJsonRegex = regexp.MustCompile(`(application/json)(?:,|$)`)
+)
+
+// BeegoInput operates the http request header, data, cookie and body.
 // it also contains router params and current session.
 type BeegoInput struct {
 	CruSession    session.SessionStore
@@ -60,7 +69,7 @@ func (input *BeegoInput) Uri() string {
 
 // Url returns request url path (without query string, fragment).
 func (input *BeegoInput) Url() string {
-	return input.Request.URL.String()
+	return input.Request.URL.Path
 }
 
 // Site returns base site url as scheme://domain type.
@@ -72,11 +81,11 @@ func (input *BeegoInput) Site() string {
 func (input *BeegoInput) Scheme() string {
 	if input.Request.URL.Scheme != "" {
 		return input.Request.URL.Scheme
-	} else if input.Request.TLS == nil {
-		return "http"
-	} else {
-		return "https"
 	}
+	if input.Request.TLS == nil {
+		return "http"
+	}
+	return "https"
 }
 
 // Domain returns host name.
@@ -153,16 +162,31 @@ func (input *BeegoInput) IsSecure() bool {
 	return input.Scheme() == "https"
 }
 
-// IsSecure returns boolean of this request is in webSocket.
+// IsWebsocket returns boolean of this request is in webSocket.
 func (input *BeegoInput) IsWebsocket() bool {
 	return input.Header("Upgrade") == "websocket"
 }
 
-// IsSecure returns boolean of whether file uploads in this request or not..
+// IsUpload returns boolean of whether file uploads in this request or not..
 func (input *BeegoInput) IsUpload() bool {
 	return strings.Contains(input.Header("Content-Type"), "multipart/form-data")
 }
 
+// Checks if request accepts html response
+func (input *BeegoInput) AcceptsHtml() bool {
+	return acceptsHtmlRegex.MatchString(input.Header("Accept"))
+}
+
+// Checks if request accepts xml response
+func (input *BeegoInput) AcceptsXml() bool {
+	return acceptsXmlRegex.MatchString(input.Header("Accept"))
+}
+
+// Checks if request accepts json response
+func (input *BeegoInput) AcceptsJson() bool {
+	return acceptsJsonRegex.MatchString(input.Header("Accept"))
+}
+
 // IP returns request client ip.
 // if in proxy, return first proxy id.
 // if error, return 127.0.0.1.
@@ -189,16 +213,24 @@ func (input *BeegoInput) Proxy() []string {
 	return []string{}
 }
 
+// Referer returns http referer header.
+func (input *BeegoInput) Referer() string {
+	return input.Header("Referer")
+}
+
 // Refer returns http referer header.
 func (input *BeegoInput) Refer() string {
-	return input.Header("Referer")
+	return input.Referer()
 }
 
 // SubDomains returns sub domain string.
 // if aa.bb.domain.com, returns aa.bb .
 func (input *BeegoInput) SubDomains() string {
 	parts := strings.Split(input.Host(), ".")
-	return strings.Join(parts[len(parts)-2:], ".")
+	if len(parts) >= 3 {
+		return strings.Join(parts[:len(parts)-2], ".")
+	}
+	return ""
 }
 
 // Port returns request client port.
@@ -237,6 +269,7 @@ func (input *BeegoInput) Query(key string) string {
 }
 
 // Header returns request header item string by a given string.
+// if non-existed, return empty string.
 func (input *BeegoInput) Header(key string) string {
 	return input.Request.Header.Get(key)
 }
@@ -252,11 +285,12 @@ func (input *BeegoInput) Cookie(key string) string {
 }
 
 // Session returns current session item value by a given key.
+// if non-existed, return empty string.
 func (input *BeegoInput) Session(key interface{}) interface{} {
 	return input.CruSession.Get(key)
 }
 
-// Body returns the raw request body data as bytes.
+// CopyBody returns the raw request body data as bytes.
 func (input *BeegoInput) CopyBody() []byte {
 	requestbody, _ := ioutil.ReadAll(input.Request.Body)
 	input.Request.Body.Close()
@@ -296,7 +330,7 @@ func (input *BeegoInput) ParseFormOrMulitForm(maxMemory int64) error {
 // Bind data from request.Form[key] to dest
 // like /?id=123&isok=true&ft=1.2&ol[0]=1&ol[1]=2&ul[]=str&ul[]=array&user.Name=astaxie
 // var id int  beegoInput.Bind(&id, "id")  id ==123
-// var isok bool  beegoInput.Bind(&isok, "isok")  id ==true
+// var isok bool  beegoInput.Bind(&isok, "isok")  isok ==true
 // var ft float64  beegoInput.Bind(&ft, "ft")  ft ==1.2
 // ol := make([]int, 0, 2)  beegoInput.Bind(&ol, "ol")  ol ==[1 2]
 // ul := make([]string, 0, 2)  beegoInput.Bind(&ul, "ul")  ul ==[str array]

context/input_test.go

@@ -70,3 +70,45 @@ func TestParse(t *testing.T) {
 	}
 	fmt.Println(user)
 }
+
+func TestSubDomain(t *testing.T) {
+	r, _ := http.NewRequest("GET", "http://www.example.com/?id=123&isok=true&ft=1.2&ol[0]=1&ol[1]=2&ul[]=str&ul[]=array&user.Name=astaxie", nil)
+	beegoInput := NewInput(r)
+
+	subdomain := beegoInput.SubDomains()
+	if subdomain != "www" {
+		t.Fatal("Subdomain parse error, got" + subdomain)
+	}
+
+	r, _ = http.NewRequest("GET", "http://localhost/", nil)
+	beegoInput.Request = r
+	if beegoInput.SubDomains() != "" {
+		t.Fatal("Subdomain parse error, should be empty, got " + beegoInput.SubDomains())
+	}
+
+	r, _ = http.NewRequest("GET", "http://aa.bb.example.com/", nil)
+	beegoInput.Request = r
+	if beegoInput.SubDomains() != "aa.bb" {
+		t.Fatal("Subdomain parse error, got " + beegoInput.SubDomains())
+	}
+
+	/* TODO Fix this
+	r, _ = http.NewRequest("GET", "http://127.0.0.1/", nil)
+	beegoInput.Request = r
+	if beegoInput.SubDomains() != "" {
+		t.Fatal("Subdomain parse error, got " + beegoInput.SubDomains())
+	}
+	*/
+
+	r, _ = http.NewRequest("GET", "http://example.com/", nil)
+	beegoInput.Request = r
+	if beegoInput.SubDomains() != "" {
+		t.Fatal("Subdomain parse error, got " + beegoInput.SubDomains())
+	}
+
+	r, _ = http.NewRequest("GET", "http://aa.bb.cc.dd.example.com/", nil)
+	beegoInput.Request = r
+	if beegoInput.SubDomains() != "aa.bb.cc.dd" {
+		t.Fatal("Subdomain parse error, got " + beegoInput.SubDomains())
+	}
+}

context/output.go

@@ -29,6 +29,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"time"
 )
 
 // BeegoOutput does work for sending response header.
@@ -98,28 +99,30 @@ func (output *BeegoOutput) Body(content []byte) {
 func (output *BeegoOutput) Cookie(name string, value string, others ...interface{}) {
 	var b bytes.Buffer
 	fmt.Fprintf(&b, "%s=%s", sanitizeName(name), sanitizeValue(value))
-	if len(others) > 0 {
-		switch v := others[0].(type) {
-		case int:
-			if v > 0 {
-				fmt.Fprintf(&b, "; Max-Age=%d", v)
-			} else if v < 0 {
-				fmt.Fprintf(&b, "; Max-Age=0")
-			}
-		case int64:
-			if v > 0 {
-				fmt.Fprintf(&b, "; Max-Age=%d", v)
-			} else if v < 0 {
-				fmt.Fprintf(&b, "; Max-Age=0")
-			}
-		case int32:
-			if v > 0 {
-				fmt.Fprintf(&b, "; Max-Age=%d", v)
-			} else if v < 0 {
-				fmt.Fprintf(&b, "; Max-Age=0")
-			}
-		}
-	}
+
+    //fix cookie not work in IE
+    if len(others) > 0 {
+        switch v := others[0].(type) {
+            case int:
+            if v > 0 {
+                fmt.Fprintf(&b, "; Expires=%s; Max-Age=%d", time.Now().Add(time.Duration(v) * time.Second).UTC().Format(time.RFC1123), v)
+            } else if v < 0 {
+                fmt.Fprintf(&b, "; Max-Age=0")
+            }
+            case int64:
+            if v > 0 {
+                fmt.Fprintf(&b, "; Expires=%s; Max-Age=%d", time.Now().Add(time.Duration(v) * time.Second).UTC().Format(time.RFC1123), v)
+            } else if v < 0 {
+                fmt.Fprintf(&b, "; Max-Age=0")
+            }
+            case int32:
+            if v > 0 {
+                fmt.Fprintf(&b, "; Expires=%s; Max-Age=%d", time.Now().Add(time.Duration(v) * time.Second).UTC().Format(time.RFC1123), v)
+            } else if v < 0 {
+                fmt.Fprintf(&b, "; Max-Age=0")
+            }
+        }
+    }
 
 	// the settings below
 	// Path, Domain, Secure, HttpOnly
@@ -188,7 +191,7 @@ func sanitizeValue(v string) string {
 // Json writes json to response body.
 // if coding is true, it converts utf-8 to \u0000 type.
 func (output *BeegoOutput) Json(data interface{}, hasIndent bool, coding bool) error {
-	output.Header("Content-Type", "application/json;charset=UTF-8")
+	output.Header("Content-Type", "application/json; charset=utf-8")
 	var content []byte
 	var err error
 	if hasIndent {
@@ -209,7 +212,7 @@ func (output *BeegoOutput) Json(data interface{}, hasIndent bool, coding bool) e
 
 // Jsonp writes jsonp to response body.
 func (output *BeegoOutput) Jsonp(data interface{}, hasIndent bool) error {
-	output.Header("Content-Type", "application/javascript;charset=UTF-8")
+	output.Header("Content-Type", "application/javascript; charset=utf-8")
 	var content []byte
 	var err error
 	if hasIndent {
@@ -235,7 +238,7 @@ func (output *BeegoOutput) Jsonp(data interface{}, hasIndent bool) error {
 
 // Xml writes xml string to response body.
 func (output *BeegoOutput) Xml(data interface{}, hasIndent bool) error {
-	output.Header("Content-Type", "application/xml;charset=UTF-8")
+	output.Header("Content-Type", "application/xml; charset=utf-8")
 	var content []byte
 	var err error
 	if hasIndent {

controller.go

@@ -270,16 +270,22 @@ func (c *Controller) Redirect(url string, code int) {
 // Aborts stops controller handler and show the error data if code is defined in ErrorMap or code string.
 func (c *Controller) Abort(code string) {
 	status, err := strconv.Atoi(code)
-	if err == nil {
-		c.Ctx.Abort(status, code)
-	} else {
-		c.Ctx.Abort(200, code)
+	if err != nil {
+		status = 200
 	}
+	c.CustomAbort(status, code)
 }
 
 // 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.Abort(status, body)
+	c.Ctx.ResponseWriter.WriteHeader(status)
+	// first panic from ErrorMaps, is is user defined error functions.
+	if _, ok := ErrorMaps[body]; ok {
+		panic(body)
+	}
+	// last panic user string
+	c.Ctx.ResponseWriter.Write([]byte(body))
+	panic(USERSTOPRUN)
 }
 
 // StopRun makes panic of USERSTOPRUN error and go to recover function if defined.
@@ -289,7 +295,7 @@ func (c *Controller) StopRun() {
 
 // UrlFor does another controller handler in this request function.
 // it goes to this controller method if endpoint is not clear.
-func (c *Controller) UrlFor(endpoint string, values ...string) string {
+func (c *Controller) UrlFor(endpoint string, values ...interface{}) string {
 	if len(endpoint) <= 0 {
 		return ""
 	}
@@ -363,38 +369,128 @@ func (c *Controller) ParseForm(obj interface{}) error {
 	return ParseForm(c.Input(), obj)
 }
 
-// GetString returns the input value by key string.
-func (c *Controller) GetString(key string) string {
-	return c.Ctx.Input.Query(key)
+// GetString returns the input value by key string or the default value while it's present and input is blank
+func (c *Controller) GetString(key string, def ...string) string {
+	var defv string
+	if len(def) > 0 {
+		defv = def[0]
+	}
+
+	if v := c.Ctx.Input.Query(key); v != "" {
+		return v
+	} else {
+		return defv
+	}
 }
 
-// GetStrings returns the input string slice by key string.
+// GetStrings returns the input string slice by key string or the default value while it's present and input is blank
 // it's designed for multi-value input field such as checkbox(input[type=checkbox]), multi-selection.
-func (c *Controller) GetStrings(key string) []string {
+func (c *Controller) GetStrings(key string, def ...[]string) []string {
+	var defv []string
+	if len(def) > 0 {
+		defv = def[0]
+	}
+
 	f := c.Input()
 	if f == nil {
-		return []string{}
+		return defv
 	}
+
 	vs := f[key]
 	if len(vs) > 0 {
 		return vs
+	} else {
+		return defv
 	}
-	return []string{}
 }
 
-// GetInt returns input value as int64.
-func (c *Controller) GetInt(key string) (int64, error) {
-	return strconv.ParseInt(c.Ctx.Input.Query(key), 10, 64)
+// GetInt returns input as an int or the default value while it's present and input is blank
+func (c *Controller) GetInt(key string, def ...int) (int, error) {
+	if strv := c.Ctx.Input.Query(key); strv != "" {
+		return strconv.Atoi(strv)
+	} else if len(def) > 0 {
+		return def[0], nil
+	} else {
+		return strconv.Atoi(strv)
+	}
 }
 
-// GetBool returns input value as bool.
-func (c *Controller) GetBool(key string) (bool, error) {
-	return strconv.ParseBool(c.Ctx.Input.Query(key))
+// GetInt8 return input as an int8 or the default value while it's present and input is blank
+func (c *Controller) GetInt8(key string, def ...int8) (int8, error) {
+	if strv := c.Ctx.Input.Query(key); strv != "" {
+		i64, err := strconv.ParseInt(strv, 10, 8)
+		i8 := int8(i64)
+		return i8, err
+	} else if len(def) > 0 {
+		return def[0], nil
+	} else {
+		i64, err := strconv.ParseInt(strv, 10, 8)
+		i8 := int8(i64)
+		return i8, err
+	}
 }
 
-// GetFloat returns input value as float64.
-func (c *Controller) GetFloat(key string) (float64, error) {
-	return strconv.ParseFloat(c.Ctx.Input.Query(key), 64)
+// 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) {
+	if strv := c.Ctx.Input.Query(key); strv != "" {
+		i64, err := strconv.ParseInt(strv, 10, 16)
+		i16 := int16(i64)
+		return i16, err
+	} else if len(def) > 0 {
+		return def[0], nil
+	} else {
+		i64, err := strconv.ParseInt(strv, 10, 16)
+		i16 := int16(i64)
+		return i16, 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) {
+	if strv := c.Ctx.Input.Query(key); strv != "" {
+		i64, err := strconv.ParseInt(c.Ctx.Input.Query(key), 10, 32)
+		i32 := int32(i64)
+		return i32, err
+	} else if len(def) > 0 {
+		return def[0], nil
+	} else {
+		i64, err := strconv.ParseInt(c.Ctx.Input.Query(key), 10, 32)
+		i32 := int32(i64)
+		return i32, 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) {
+	if strv := c.Ctx.Input.Query(key); strv != "" {
+		return strconv.ParseInt(strv, 10, 64)
+	} else if len(def) > 0 {
+		return def[0], nil
+	} else {
+		return strconv.ParseInt(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) {
+	if strv := c.Ctx.Input.Query(key); strv != "" {
+		return strconv.ParseBool(strv)
+	} else if len(def) > 0 {
+		return def[0], nil
+	} else {
+		return strconv.ParseBool(strv)
+	}
+}
+
+// GetFloat returns input value as float64 or the default value while it's present and input is blank.
+func (c *Controller) GetFloat(key string, def ...float64) (float64, error) {
+	if strv := c.Ctx.Input.Query(key); strv != "" {
+		return strconv.ParseFloat(strv, 64)
+	} else if len(def) > 0 {
+		return def[0], nil
+	} else {
+		return strconv.ParseFloat(strv, 64)
+	}
 }
 
 // GetFile returns the file data in file upload field named as key.
@@ -403,6 +499,41 @@ func (c *Controller) GetFile(key string) (multipart.File, *multipart.FileHeader,
 	return c.Ctx.Request.FormFile(key)
 }
 
+// GetFiles return multi-upload files
+// files, err:=c.Getfiles("myfiles")
+//	if err != nil {
+//		http.Error(w, err.Error(), http.StatusNoContent)
+//		return
+//	}
+// for i, _ := range files {
+//	//for each fileheader, get a handle to the actual file
+//	file, err := files[i].Open()
+//	defer file.Close()
+//	if err != nil {
+//		http.Error(w, err.Error(), http.StatusInternalServerError)
+//		return
+//	}
+//	//create destination file making sure the path is writeable.
+//	dst, err := os.Create("upload/" + files[i].Filename)
+//	defer dst.Close()
+//	if err != nil {
+//		http.Error(w, err.Error(), http.StatusInternalServerError)
+//		return
+//	}
+//	//copy the uploaded file to the destination file
+//	if _, err := io.Copy(dst, file); err != nil {
+//		http.Error(w, err.Error(), http.StatusInternalServerError)
+//		return
+//	}
+// }
+func (c *Controller) GetFiles(key string) ([]*multipart.FileHeader, error) {
+	files, ok := c.Ctx.Request.MultipartForm.File[key]
+	if ok {
+		return files, nil
+	}
+	return nil, http.ErrMissingFile
+}
+
 // SaveToFile saves uploaded file to new path.
 // it only operates the first one of mutil-upload form file field.
 func (c *Controller) SaveToFile(fromfile, tofile string) error {

controller_test.go

@@ -0,0 +1,75 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package beego
+
+import (
+	"fmt"
+	"github.com/astaxie/beego/context"
+)
+
+func ExampleGetInt() {
+
+	i := &context.BeegoInput{Params: map[string]string{"age": "40"}}
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+
+	val, _ := ctrlr.GetInt("age")
+	fmt.Printf("%T", val)
+	//Output: int
+}
+
+func ExampleGetInt8() {
+
+	i := &context.BeegoInput{Params: map[string]string{"age": "40"}}
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+
+	val, _ := ctrlr.GetInt8("age")
+	fmt.Printf("%T", val)
+	//Output: int8
+}
+
+func ExampleGetInt16() {
+
+	i := &context.BeegoInput{Params: map[string]string{"age": "40"}}
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+
+	val, _ := ctrlr.GetInt16("age")
+	fmt.Printf("%T", val)
+	//Output: int16
+}
+
+func ExampleGetInt32() {
+
+	i := &context.BeegoInput{Params: map[string]string{"age": "40"}}
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+
+	val, _ := ctrlr.GetInt32("age")
+	fmt.Printf("%T", val)
+	//Output: int32
+}
+
+func ExampleGetInt64() {
+
+	i := &context.BeegoInput{Params: map[string]string{"age": "40"}}
+	ctx := &context.Context{Input: i}
+	ctrlr := Controller{Ctx: ctx}
+
+	val, _ := ctrlr.GetInt64("age")
+	fmt.Printf("%T", val)
+	//Output: int64
+}

error.go

@@ -12,20 +12,26 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package middleware
+package beego
 
 import (
 	"fmt"
 	"html/template"
 	"net/http"
+	"reflect"
 	"runtime"
 	"strconv"
+	"strings"
+
+	"github.com/astaxie/beego/context"
+	"github.com/astaxie/beego/utils"
 )
 
-var (
-	AppName string
-	VERSION string
+const (
+	errorTypeHandler = iota
+	errorTypeController
 )
+
 var tpl = `
 <!DOCTYPE html>
 <html>
@@ -76,18 +82,18 @@ var tpl = `
 `
 
 // render default application error page with error and stack string.
-func ShowErr(err interface{}, rw http.ResponseWriter, r *http.Request, Stack string) {
+func showErr(err interface{}, ctx *context.Context, Stack string) {
 	t, _ := template.New("beegoerrortemp").Parse(tpl)
 	data := make(map[string]string)
 	data["AppError"] = AppName + ":" + fmt.Sprint(err)
-	data["RequestMethod"] = r.Method
-	data["RequestURL"] = r.RequestURI
-	data["RemoteAddr"] = r.RemoteAddr
+	data["RequestMethod"] = ctx.Input.Method()
+	data["RequestURL"] = ctx.Input.Uri()
+	data["RemoteAddr"] = ctx.Input.IP()
 	data["Stack"] = Stack
 	data["BeegoVersion"] = VERSION
 	data["GoVersion"] = runtime.Version()
-	rw.WriteHeader(500)
-	t.Execute(rw, data)
+	ctx.ResponseWriter.WriteHeader(500)
+	t.Execute(ctx.ResponseWriter, data)
 }
 
 var errtpl = `
@@ -190,15 +196,68 @@ var errtpl = `
 </html>
 `
 
+type errorInfo struct {
+	controllerType reflect.Type
+	handler        http.HandlerFunc
+	method         string
+	errorType      int
+}
+
 // map of http handlers for each error string.
-var ErrorMaps map[string]http.HandlerFunc
+var ErrorMaps map[string]*errorInfo
 
 func init() {
-	ErrorMaps = make(map[string]http.HandlerFunc)
+	ErrorMaps = make(map[string]*errorInfo)
+}
+
+// show 401 unauthorized error.
+func unauthorized(rw http.ResponseWriter, r *http.Request) {
+	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	data := make(map[string]interface{})
+	data["Title"] = "Unauthorized"
+	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>")
+	data["BeegoVersion"] = VERSION
+	t.Execute(rw, data)
+}
+
+// show 402 Payment Required
+func paymentRequired(rw http.ResponseWriter, r *http.Request) {
+	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	data := make(map[string]interface{})
+	data["Title"] = "Payment Required"
+	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>")
+	data["BeegoVersion"] = VERSION
+	t.Execute(rw, data)
+}
+
+// show 403 forbidden error.
+func forbidden(rw http.ResponseWriter, r *http.Request) {
+	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	data := make(map[string]interface{})
+	data["Title"] = "Forbidden"
+	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>")
+	data["BeegoVersion"] = VERSION
+	t.Execute(rw, data)
 }
 
 // show 404 notfound error.
-func NotFound(rw http.ResponseWriter, r *http.Request) {
+func notFound(rw http.ResponseWriter, r *http.Request) {
 	t, _ := template.New("beegoerrortemp").Parse(errtpl)
 	data := make(map[string]interface{})
 	data["Title"] = "Page Not Found"
@@ -211,45 +270,66 @@ func NotFound(rw http.ResponseWriter, r *http.Request) {
 		"<br>You like 404 pages" +
 		"</ul>")
 	data["BeegoVersion"] = VERSION
-	//rw.WriteHeader(http.StatusNotFound)
 	t.Execute(rw, data)
 }
 
-// show 401 unauthorized error.
-func Unauthorized(rw http.ResponseWriter, r *http.Request) {
+// show 405 Method Not Allowed
+func methodNotAllowed(rw http.ResponseWriter, r *http.Request) {
 	t, _ := template.New("beegoerrortemp").Parse(errtpl)
 	data := make(map[string]interface{})
-	data["Title"] = "Unauthorized"
-	data["Content"] = template.HTML("<br>The page you have requested can't be authorized." +
+	data["Title"] = "Method Not Allowed"
+	data["Content"] = template.HTML("<br>The method you have requested Not Allowed." +
 		"<br>Perhaps you are here because:" +
 		"<br><br><ul>" +
-		"<br>The credentials you supplied are incorrect" +
-		"<br>There are errors in the website address" +
+		"<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>")
 	data["BeegoVersion"] = VERSION
-	//rw.WriteHeader(http.StatusUnauthorized)
 	t.Execute(rw, data)
 }
 
-// show 403 forbidden error.
-func Forbidden(rw http.ResponseWriter, r *http.Request) {
+// show 500 internal server error.
+func internalServerError(rw http.ResponseWriter, r *http.Request) {
 	t, _ := template.New("beegoerrortemp").Parse(errtpl)
 	data := make(map[string]interface{})
-	data["Title"] = "Forbidden"
-	data["Content"] = template.HTML("<br>The page you have requested is forbidden." +
-		"<br>Perhaps you are here because:" +
+	data["Title"] = "Internal Server Error"
+	data["Content"] = template.HTML("<br>The page you have requested is down right now." +
 		"<br><br><ul>" +
-		"<br>Your address may be blocked" +
-		"<br>The site may be disabled" +
-		"<br>You need to log in" +
-		"</ul>")
+		"<br>Please try again later and report the error to the website administrator" +
+		"<br></ul>")
+	data["BeegoVersion"] = VERSION
+	t.Execute(rw, data)
+}
+
+// show 501 Not Implemented.
+func notImplemented(rw http.ResponseWriter, r *http.Request) {
+	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	data := make(map[string]interface{})
+	data["Title"] = "Not Implemented"
+	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>")
+	data["BeegoVersion"] = VERSION
+	t.Execute(rw, data)
+}
+
+// show 502 Bad Gateway.
+func badGateway(rw http.ResponseWriter, r *http.Request) {
+	t, _ := template.New("beegoerrortemp").Parse(errtpl)
+	data := make(map[string]interface{})
+	data["Title"] = "Bad Gateway"
+	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>")
 	data["BeegoVersion"] = VERSION
-	//rw.WriteHeader(http.StatusForbidden)
 	t.Execute(rw, data)
 }
 
 // show 503 service unavailable error.
-func ServiceUnavailable(rw http.ResponseWriter, r *http.Request) {
+func serviceUnavailable(rw http.ResponseWriter, r *http.Request) {
 	t, _ := template.New("beegoerrortemp").Parse(errtpl)
 	data := make(map[string]interface{})
 	data["Title"] = "Service Unavailable"
@@ -260,80 +340,151 @@ func ServiceUnavailable(rw http.ResponseWriter, r *http.Request) {
 		"<br>Please try again later." +
 		"</ul>")
 	data["BeegoVersion"] = VERSION
-	//rw.WriteHeader(http.StatusServiceUnavailable)
 	t.Execute(rw, data)
 }
 
-// show 500 internal server error.
-func InternalServerError(rw http.ResponseWriter, r *http.Request) {
+// show 504 Gateway Timeout.
+func gatewayTimeout(rw http.ResponseWriter, r *http.Request) {
 	t, _ := template.New("beegoerrortemp").Parse(errtpl)
 	data := make(map[string]interface{})
-	data["Title"] = "Internal Server Error"
-	data["Content"] = template.HTML("<br>The page you have requested is down right now." +
+	data["Title"] = "Gateway Timeout"
+	data["Content"] = template.HTML("<br>The page you have requested is unavailable." +
+		"<br>Perhaps you are here because:" +
 		"<br><br><ul>" +
-		"<br>Please try again later and report the error to the website administrator" +
-		"<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>")
 	data["BeegoVersion"] = VERSION
-	//rw.WriteHeader(http.StatusInternalServerError)
 	t.Execute(rw, data)
 }
 
-// show 500 internal error with simple text string.
-func SimpleServerError(rw http.ResponseWriter, r *http.Request) {
-	http.Error(rw, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-}
-
-// add http handler for given error string.
-func Errorhandler(err string, h http.HandlerFunc) {
-	ErrorMaps[err] = h
-}
-
 // register default error http handlers, 404,401,403,500 and 503.
-func RegisterErrorHandler() {
-	if _, ok := ErrorMaps["404"]; !ok {
-		ErrorMaps["404"] = NotFound
+func registerDefaultErrorHandler() {
+	if _, ok := ErrorMaps["401"]; !ok {
+		Errorhandler("401", unauthorized)
 	}
 
-	if _, ok := ErrorMaps["401"]; !ok {
-		ErrorMaps["401"] = Unauthorized
+	if _, ok := ErrorMaps["402"]; !ok {
+		Errorhandler("402", paymentRequired)
 	}
 
 	if _, ok := ErrorMaps["403"]; !ok {
-		ErrorMaps["403"] = Forbidden
+		Errorhandler("403", forbidden)
 	}
 
-	if _, ok := ErrorMaps["503"]; !ok {
-		ErrorMaps["503"] = ServiceUnavailable
+	if _, ok := ErrorMaps["404"]; !ok {
+		Errorhandler("404", notFound)
+	}
+
+	if _, ok := ErrorMaps["405"]; !ok {
+		Errorhandler("405", methodNotAllowed)
 	}
 
 	if _, ok := ErrorMaps["500"]; !ok {
-		ErrorMaps["500"] = InternalServerError
+		Errorhandler("500", internalServerError)
 	}
+	if _, ok := ErrorMaps["501"]; !ok {
+		Errorhandler("501", notImplemented)
+	}
+	if _, ok := ErrorMaps["502"]; !ok {
+		Errorhandler("502", badGateway)
+	}
+
+	if _, ok := ErrorMaps["503"]; !ok {
+		Errorhandler("503", serviceUnavailable)
+	}
+
+	if _, ok := ErrorMaps["504"]; !ok {
+		Errorhandler("504", gatewayTimeout)
+	}
+}
+
+// ErrorHandler registers http.HandlerFunc to each http err code string.
+// usage:
+// 	beego.ErrorHandler("404",NotFound)
+//	beego.ErrorHandler("500",InternalServerError)
+func Errorhandler(code string, h http.HandlerFunc) *App {
+	errinfo := &errorInfo{}
+	errinfo.errorType = errorTypeHandler
+	errinfo.handler = h
+	errinfo.method = code
+	ErrorMaps[code] = errinfo
+	return BeeApp
+}
+
+// ErrorController registers ControllerInterface to each http err code string.
+// usage:
+// 	beego.ErrorHandler(&controllers.ErrorController{})
+func ErrorController(c ControllerInterface) *App {
+	reflectVal := reflect.ValueOf(c)
+	rt := reflectVal.Type()
+	ct := reflect.Indirect(reflectVal).Type()
+	for i := 0; i < rt.NumMethod(); i++ {
+		if !utils.InSlice(rt.Method(i).Name, exceptMethod) && strings.HasPrefix(rt.Method(i).Name, "Error") {
+			errinfo := &errorInfo{}
+			errinfo.errorType = errorTypeController
+			errinfo.controllerType = ct
+			errinfo.method = rt.Method(i).Name
+			errname := strings.TrimPrefix(rt.Method(i).Name, "Error")
+			ErrorMaps[errname] = errinfo
+		}
+	}
+	return BeeApp
 }
 
 // show error string as simple text message.
 // if error string is empty, show 500 error as default.
-func Exception(errcode string, w http.ResponseWriter, r *http.Request, msg string) {
+func exception(errcode string, ctx *context.Context) {
+	code, err := strconv.Atoi(errcode)
+	if err != nil {
+		code = 503
+	}
 	if h, ok := ErrorMaps[errcode]; ok {
-		isint, err := strconv.Atoi(errcode)
-		if err != nil {
-			isint = 500
-		}
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		w.WriteHeader(isint)
-		h(w, r)
+		executeError(h, ctx, code)
+		return
+	} else if h, ok := ErrorMaps["503"]; ok {
+		executeError(h, ctx, code)
 		return
 	} else {
-		isint, err := strconv.Atoi(errcode)
-		if err != nil {
-			isint = 500
-		}
-		if isint == 400 {
-			msg = "404 page not found"
-		}
-		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
-		w.WriteHeader(isint)
-		fmt.Fprintln(w, msg)
-		return
+		ctx.ResponseWriter.WriteHeader(code)
+		ctx.WriteString(errcode)
+	}
+}
+
+func executeError(err *errorInfo, ctx *context.Context, code int) {
+	if err.errorType == errorTypeHandler {
+		ctx.ResponseWriter.WriteHeader(code)
+		err.handler(ctx.ResponseWriter, ctx.Request)
+		return
+	}
+	if err.errorType == errorTypeController {
+		ctx.Output.SetStatus(code)
+		//Invoke the request handler
+		vc := reflect.New(err.controllerType)
+		execController, ok := vc.Interface().(ControllerInterface)
+		if !ok {
+			panic("controller is not ControllerInterface")
+		}
+		//call the controller init function
+		execController.Init(ctx, err.controllerType.Name(), err.method, vc.Interface())
+
+		//call prepare function
+		execController.Prepare()
+
+		execController.URLMapping()
+
+		in := make([]reflect.Value, 0)
+		method := vc.MethodByName(err.method)
+		method.Call(in)
+
+		//render template
+		if AutoRender {
+			if err := execController.Render(); err != nil {
+				panic(err)
+			}
+		}
+
+		// finish all runrouter. release resource
+		execController.Finish()
 	}
 }

example/beeapi/controllers/default.go

@@ -17,47 +17,47 @@ type ObjectController struct {
 	beego.Controller
 }
 
-func (this *ObjectController) Post() {
+func (o *ObjectController) Post() {
 	var ob models.Object
-	json.Unmarshal(this.Ctx.Input.RequestBody, &ob)
+	json.Unmarshal(o.Ctx.Input.RequestBody, &ob)
 	objectid := models.AddOne(ob)
-	this.Data["json"] = map[string]string{"ObjectId": objectid}
-	this.ServeJson()
+	o.Data["json"] = map[string]string{"ObjectId": objectid}
+	o.ServeJson()
 }
 
-func (this *ObjectController) Get() {
-	objectId := this.Ctx.Input.Params[":objectId"]
+func (o *ObjectController) Get() {
+	objectId := o.Ctx.Input.Params[":objectId"]
 	if objectId != "" {
 		ob, err := models.GetOne(objectId)
 		if err != nil {
-			this.Data["json"] = err
+			o.Data["json"] = err
 		} else {
-			this.Data["json"] = ob
+			o.Data["json"] = ob
 		}
 	} else {
 		obs := models.GetAll()
-		this.Data["json"] = obs
+		o.Data["json"] = obs
 	}
-	this.ServeJson()
+	o.ServeJson()
 }
 
-func (this *ObjectController) Put() {
-	objectId := this.Ctx.Input.Params[":objectId"]
+func (o *ObjectController) Put() {
+	objectId := o.Ctx.Input.Params[":objectId"]
 	var ob models.Object
-	json.Unmarshal(this.Ctx.Input.RequestBody, &ob)
+	json.Unmarshal(o.Ctx.Input.RequestBody, &ob)
 
 	err := models.Update(objectId, ob.Score)
 	if err != nil {
-		this.Data["json"] = err
+		o.Data["json"] = err
 	} else {
-		this.Data["json"] = "update success!"
+		o.Data["json"] = "update success!"
 	}
-	this.ServeJson()
+	o.ServeJson()
 }
 
-func (this *ObjectController) Delete() {
-	objectId := this.Ctx.Input.Params[":objectId"]
+func (o *ObjectController) Delete() {
+	objectId := o.Ctx.Input.Params[":objectId"]
 	models.Delete(objectId)
-	this.Data["json"] = "delete success!"
-	this.ServeJson()
+	o.Data["json"] = "delete success!"
+	o.ServeJson()
 }

example/chat/controllers/default.go

@@ -14,7 +14,7 @@ type MainController struct {
 	beego.Controller
 }
 
-func (this *MainController) Get() {
-	this.Data["host"] = this.Ctx.Request.Host
-	this.TplNames = "index.tpl"
+func (m *MainController) Get() {
+	m.Data["host"] = m.Ctx.Request.Host
+	m.TplNames = "index.tpl"
 }

example/chat/controllers/ws.go

@@ -150,14 +150,14 @@ type WSController struct {
 }
 
 var upgrader = websocket.Upgrader{
-    ReadBufferSize:  1024,
-    WriteBufferSize: 1024,
+	ReadBufferSize:  1024,
+	WriteBufferSize: 1024,
 }
 
-func (this *WSController) Get() {
-	ws, err := upgrader.Upgrade(this.Ctx.ResponseWriter, this.Ctx.Request,nil)
+func (w *WSController) Get() {
+	ws, err := upgrader.Upgrade(w.Ctx.ResponseWriter, w.Ctx.Request, nil)
 	if _, ok := err.(websocket.HandshakeError); ok {
-		http.Error(this.Ctx.ResponseWriter, "Not a websocket handshake", 400)
+		http.Error(w.Ctx.ResponseWriter, "Not a websocket handshake", 400)
 		return
 	} else if err != nil {
 		return

example/chat/views/index.tpl

@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <title>Chat Example</title>
-<script src="//ajax.googleapis.com/ajax/libs/jquery/2.0.3/jquery.min.js"></script>
+<script src="//code.jquery.com/jquery-2.1.3.min.js"></script>
 <script type="text/javascript">
     $(function() {
 

filter.go

@@ -14,18 +14,26 @@
 
 package beego
 
-// FilterRouter defines filter operation before controller handler execution.
-// it can match patterned url and do filter function when action arrives.
+import "github.com/astaxie/beego/context"
+
+// FilterFunc defines a filter function which is invoked before the controller handler is executed.
+type FilterFunc func(*context.Context)
+
+// FilterRouter defines a filter operation which is invoked before the controller handler is executed.
+// It can match the URL against a pattern, and execute a filter function
+// when a request with a matching URL arrives.
 type FilterRouter struct {
-	filterFunc FilterFunc
-	tree       *Tree
-	pattern    string
+	filterFunc     FilterFunc
+	tree           *Tree
+	pattern        string
+	returnOnOutput bool
 }
 
-// ValidRouter check current request is valid for this filter.
-// if matched, returns parsed params in this request by defined filter router pattern.
-func (f *FilterRouter) ValidRouter(router string) (bool, map[string]string) {
-	isok, params := f.tree.Match(router)
+// ValidRouter checks if the current request is matched by this filter.
+// If the request is matched, the values of the URL parameters defined
+// by the filter pattern are also returned.
+func (f *FilterRouter) ValidRouter(url string) (bool, map[string]string) {
+	isok, params := f.tree.Match(url)
 	if isok == nil {
 		return false, nil
 	}

flash.go

@@ -32,6 +32,24 @@ func NewFlash() *FlashData {
 	}
 }
 
+// Set message to flash
+func (fd *FlashData) Set(key string, msg string, args ...interface{}) {
+	if len(args) == 0 {
+		fd.Data[key] = msg
+	} else {
+		fd.Data[key] = fmt.Sprintf(msg, args...)
+	}
+}
+
+// Success writes success message to flash.
+func (fd *FlashData) Success(msg string, args ...interface{}) {
+	if len(args) == 0 {
+		fd.Data["success"] = msg
+	} else {
+		fd.Data["success"] = fmt.Sprintf(msg, args...)
+	}
+}
+
 // Notice writes notice message to flash.
 func (fd *FlashData) Notice(msg string, args ...interface{}) {
 	if len(args) == 0 {

flash_test.go

@@ -25,12 +25,12 @@ type TestFlashController struct {
 	Controller
 }
 
-func (this *TestFlashController) TestWriteFlash() {
+func (t *TestFlashController) TestWriteFlash() {
 	flash := NewFlash()
 	flash.Notice("TestFlashString")
-	flash.Store(&this.Controller)
+	flash.Store(&t.Controller)
 	// we choose to serve json because we don't want to load a template html file
-	this.ServeJson(true)
+	t.ServeJson(true)
 }
 
 func TestFlashHeader(t *testing.T) {

grace/conn.go

@@ -0,0 +1,13 @@
+package grace
+
+import "net"
+
+type graceConn struct {
+	net.Conn
+	server *graceServer
+}
+
+func (c graceConn) Close() error {
+	c.server.wg.Done()
+	return c.Conn.Close()
+}

grace/grace.go

@@ -0,0 +1,150 @@
+// 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.
+
+// Description: http://grisha.org/blog/2014/06/03/graceful-restart-in-golang/
+//
+// Usage:
+//
+// import(
+//   "log"
+//	 "net/http"
+//	 "os"
+//
+//   "github.com/astaxie/beego/grace"
+// )
+//
+//  func handler(w http.ResponseWriter, r *http.Request) {
+//	  w.Write([]byte("WORLD!"))
+//  }
+//
+//  func main() {
+//      mux := http.NewServeMux()
+//      mux.HandleFunc("/hello", handler)
+//
+//	    err := grace.ListenAndServe("localhost:8080", mux1)
+//      if err != nil {
+//		   log.Println(err)
+//	    }
+//      log.Println("Server on 8080 stopped")
+//	     os.Exit(0)
+//    }
+package grace
+
+import (
+	"flag"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+const (
+	PRE_SIGNAL = iota
+	POST_SIGNAL
+
+	STATE_INIT
+	STATE_RUNNING
+	STATE_SHUTTING_DOWN
+	STATE_TERMINATE
+)
+
+var (
+	regLock              *sync.Mutex
+	runningServers       map[string]*graceServer
+	runningServersOrder  []string
+	socketPtrOffsetMap   map[string]uint
+	runningServersForked bool
+
+	DefaultReadTimeOut    time.Duration
+	DefaultWriteTimeOut   time.Duration
+	DefaultMaxHeaderBytes int
+	DefaultTimeout        time.Duration
+
+	isChild     bool
+	socketOrder string
+)
+
+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")
+	runningServers = make(map[string]*graceServer)
+	runningServersOrder = []string{}
+	socketPtrOffsetMap = make(map[string]uint)
+
+	DefaultMaxHeaderBytes = 0
+
+	DefaultTimeout = 60 * time.Second
+}
+
+// NewServer returns a new graceServer.
+func NewServer(addr string, handler http.Handler) (srv *graceServer) {
+	regLock.Lock()
+	defer regLock.Unlock()
+	if !flag.Parsed() {
+		flag.Parse()
+	}
+	if len(socketOrder) > 0 {
+		for i, addr := range strings.Split(socketOrder, ",") {
+			socketPtrOffsetMap[addr] = uint(i)
+		}
+	} else {
+		socketPtrOffsetMap[addr] = uint(len(runningServersOrder))
+	}
+
+	srv = &graceServer{
+		wg:      sync.WaitGroup{},
+		sigChan: make(chan os.Signal),
+		isChild: isChild,
+		SignalHooks: map[int]map[os.Signal][]func(){
+			PRE_SIGNAL: map[os.Signal][]func(){
+				syscall.SIGHUP:  []func(){},
+				syscall.SIGINT:  []func(){},
+				syscall.SIGTERM: []func(){},
+			},
+			POST_SIGNAL: map[os.Signal][]func(){
+				syscall.SIGHUP:  []func(){},
+				syscall.SIGINT:  []func(){},
+				syscall.SIGTERM: []func(){},
+			},
+		},
+		state:   STATE_INIT,
+		Network: "tcp",
+	}
+	srv.Server = &http.Server{}
+	srv.Server.Addr = addr
+	srv.Server.ReadTimeout = DefaultReadTimeOut
+	srv.Server.WriteTimeout = DefaultWriteTimeOut
+	srv.Server.MaxHeaderBytes = DefaultMaxHeaderBytes
+	srv.Server.Handler = handler
+
+	runningServersOrder = append(runningServersOrder, addr)
+	runningServers[addr] = srv
+
+	return
+}
+
+// refer http.ListenAndServe
+func ListenAndServe(addr string, handler http.Handler) error {
+	server := NewServer(addr, handler)
+	return server.ListenAndServe()
+}
+
+// refer http.ListenAndServeTLS
+func ListenAndServeTLS(addr string, certFile string, keyFile string, handler http.Handler) error {
+	server := NewServer(addr, handler)
+	return server.ListenAndServeTLS(certFile, keyFile)
+}

grace/listener.go

@@ -0,0 +1,62 @@
+package grace
+
+import (
+	"net"
+	"os"
+	"syscall"
+	"time"
+)
+
+type graceListener struct {
+	net.Listener
+	stop    chan error
+	stopped bool
+	server  *graceServer
+}
+
+func newGraceListener(l net.Listener, srv *graceServer) (el *graceListener) {
+	el = &graceListener{
+		Listener: l,
+		stop:     make(chan error),
+		server:   srv,
+	}
+	go func() {
+		_ = <-el.stop
+		el.stopped = true
+		el.stop <- el.Listener.Close()
+	}()
+	return
+}
+
+func (gl *graceListener) Accept() (c net.Conn, err error) {
+	tc, err := gl.Listener.(*net.TCPListener).AcceptTCP()
+	if err != nil {
+		return
+	}
+
+	tc.SetKeepAlive(true)
+	tc.SetKeepAlivePeriod(3 * time.Minute)
+
+	c = graceConn{
+		Conn:   tc,
+		server: gl.server,
+	}
+
+	gl.server.wg.Add(1)
+	return
+}
+
+func (el *graceListener) Close() error {
+	if el.stopped {
+		return syscall.EINVAL
+	}
+	el.stop <- nil
+	return <-el.stop
+}
+
+func (el *graceListener) File() *os.File {
+	// returns a dup(2) - FD_CLOEXEC flag *not* set
+	tl := el.Listener.(*net.TCPListener)
+	fl, _ := tl.File()
+	return fl
+}

grace/server.go

@@ -0,0 +1,292 @@
+package grace
+
+import (
+	"crypto/tls"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"os/exec"
+	"os/signal"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+type graceServer struct {
+	*http.Server
+	GraceListener    net.Listener
+	SignalHooks      map[int]map[os.Signal][]func()
+	tlsInnerListener *graceListener
+	wg               sync.WaitGroup
+	sigChan          chan os.Signal
+	isChild          bool
+	state            uint8
+	Network          string
+}
+
+// Serve accepts incoming connections on the Listener l,
+// creating a new service goroutine for each.
+// The service goroutines read requests and then call srv.Handler to reply to them.
+func (srv *graceServer) Serve() (err error) {
+	srv.state = STATE_RUNNING
+	err = srv.Server.Serve(srv.GraceListener)
+	log.Println(syscall.Getpid(), "Waiting for connections to finish...")
+	srv.wg.Wait()
+	srv.state = STATE_TERMINATE
+	return
+}
+
+// ListenAndServe listens on the TCP network address srv.Addr and then calls Serve
+// to handle requests on incoming connections. If srv.Addr is blank, ":http" is
+// used.
+func (srv *graceServer) ListenAndServe() (err error) {
+	addr := srv.Addr
+	if addr == "" {
+		addr = ":http"
+	}
+
+	go srv.handleSignals()
+
+	l, err := srv.getListener(addr)
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+
+	srv.GraceListener = newGraceListener(l, srv)
+
+	if srv.isChild {
+		process, err := os.FindProcess(os.Getppid())
+		if err != nil {
+			log.Println(err)
+			return err
+		}
+		err = process.Kill()
+		if err != nil {
+			return err
+		}
+	}
+
+	log.Println(os.Getpid(), srv.Addr)
+	return srv.Serve()
+}
+
+// ListenAndServeTLS listens on the TCP network address srv.Addr and then calls
+// Serve to handle requests on incoming TLS connections.
+//
+// Filenames containing a certificate and matching private key for the server must
+// be provided. If the certificate is signed by a certificate authority, the
+// certFile should be the concatenation of the server's certificate followed by the
+// CA's certificate.
+//
+// If srv.Addr is blank, ":https" is used.
+func (srv *graceServer) ListenAndServeTLS(certFile, keyFile string) (err error) {
+	addr := srv.Addr
+	if addr == "" {
+		addr = ":https"
+	}
+
+	config := &tls.Config{}
+	if srv.TLSConfig != nil {
+		*config = *srv.TLSConfig
+	}
+	if config.NextProtos == nil {
+		config.NextProtos = []string{"http/1.1"}
+	}
+
+	config.Certificates = make([]tls.Certificate, 1)
+	config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
+	if err != nil {
+		return
+	}
+
+	go srv.handleSignals()
+
+	l, err := srv.getListener(addr)
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+
+	srv.tlsInnerListener = newGraceListener(l, srv)
+	srv.GraceListener = tls.NewListener(srv.tlsInnerListener, config)
+
+	if srv.isChild {
+		process, err := os.FindProcess(os.Getppid())
+		if err != nil {
+			log.Println(err)
+			return err
+		}
+		err = process.Kill()
+		if err != nil {
+			return err
+		}
+	}
+	log.Println(os.Getpid(), srv.Addr)
+	return srv.Serve()
+}
+
+// getListener either opens a new socket to listen on, or takes the acceptor socket
+// it got passed when restarted.
+func (srv *graceServer) getListener(laddr string) (l net.Listener, err error) {
+	if srv.isChild {
+		var ptrOffset uint = 0
+		if len(socketPtrOffsetMap) > 0 {
+			ptrOffset = socketPtrOffsetMap[laddr]
+			log.Println("laddr", laddr, "ptr offset", socketPtrOffsetMap[laddr])
+		}
+
+		f := os.NewFile(uintptr(3+ptrOffset), "")
+		l, err = net.FileListener(f)
+		if err != nil {
+			err = fmt.Errorf("net.FileListener error: %v", err)
+			return
+		}
+	} else {
+		l, err = net.Listen(srv.Network, laddr)
+		if err != nil {
+			err = fmt.Errorf("net.Listen error: %v", err)
+			return
+		}
+	}
+	return
+}
+
+// handleSignals listens for os Signals and calls any hooked in function that the
+// user had registered with the signal.
+func (srv *graceServer) handleSignals() {
+	var sig os.Signal
+
+	signal.Notify(
+		srv.sigChan,
+		syscall.SIGHUP,
+		syscall.SIGINT,
+		syscall.SIGTERM,
+	)
+
+	pid := syscall.Getpid()
+	for {
+		sig = <-srv.sigChan
+		srv.signalHooks(PRE_SIGNAL, sig)
+		switch sig {
+		case syscall.SIGHUP:
+			log.Println(pid, "Received SIGHUP. forking.")
+			err := srv.fork()
+			if err != nil {
+				log.Println("Fork err:", err)
+			}
+		case syscall.SIGINT:
+			log.Println(pid, "Received SIGINT.")
+			srv.shutdown()
+		case syscall.SIGTERM:
+			log.Println(pid, "Received SIGTERM.")
+			srv.shutdown()
+		default:
+			log.Printf("Received %v: nothing i care about...\n", sig)
+		}
+		srv.signalHooks(POST_SIGNAL, sig)
+	}
+}
+
+func (srv *graceServer) signalHooks(ppFlag int, sig os.Signal) {
+	if _, notSet := srv.SignalHooks[ppFlag][sig]; !notSet {
+		return
+	}
+	for _, f := range srv.SignalHooks[ppFlag][sig] {
+		f()
+	}
+	return
+}
+
+// shutdown closes the listener so that no new connections are accepted. it also
+// starts a goroutine that will serverTimeout (stop all running requests) the server
+// after DefaultTimeout.
+func (srv *graceServer) shutdown() {
+	if srv.state != STATE_RUNNING {
+		return
+	}
+
+	srv.state = STATE_SHUTTING_DOWN
+	if DefaultTimeout >= 0 {
+		go srv.serverTimeout(DefaultTimeout)
+	}
+	err := srv.GraceListener.Close()
+	if err != nil {
+		log.Println(syscall.Getpid(), "Listener.Close() error:", err)
+	} else {
+		log.Println(syscall.Getpid(), srv.GraceListener.Addr(), "Listener closed.")
+	}
+}
+
+// serverTimeout forces the server to shutdown in a given timeout - whether it
+// finished outstanding requests or not. if Read/WriteTimeout are not set or the
+// max header size is very big a connection could hang
+func (srv *graceServer) serverTimeout(d time.Duration) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("WaitGroup at 0", r)
+		}
+	}()
+	if srv.state != STATE_SHUTTING_DOWN {
+		return
+	}
+	time.Sleep(d)
+	log.Println("[STOP - Hammer Time] Forcefully shutting down parent")
+	for {
+		if srv.state == STATE_TERMINATE {
+			break
+		}
+		srv.wg.Done()
+	}
+}
+
+func (srv *graceServer) fork() (err error) {
+	regLock.Lock()
+	defer regLock.Unlock()
+	if runningServersForked {
+		return
+	}
+	runningServersForked = true
+
+	var files = make([]*os.File, len(runningServers))
+	var orderArgs = make([]string, len(runningServers))
+	for _, srvPtr := range runningServers {
+		switch srvPtr.GraceListener.(type) {
+		case *graceListener:
+			files[socketPtrOffsetMap[srvPtr.Server.Addr]] = srvPtr.GraceListener.(*graceListener).File()
+		default:
+			files[socketPtrOffsetMap[srvPtr.Server.Addr]] = srvPtr.tlsInnerListener.File()
+		}
+		orderArgs[socketPtrOffsetMap[srvPtr.Server.Addr]] = srvPtr.Server.Addr
+	}
+
+	log.Println(files)
+	path := os.Args[0]
+	var args []string
+	if len(os.Args) > 1 {
+		for _, arg := range os.Args[1:] {
+			if arg == "-graceful" {
+				break
+			}
+			args = append(args, arg)
+		}
+	}
+	args = append(args, "-graceful")
+	if len(runningServers) > 1 {
+		args = append(args, fmt.Sprintf(`-socketorder=%s`, strings.Join(orderArgs, ",")))
+		log.Println(args)
+	}
+	cmd := exec.Command(path, args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.ExtraFiles = files
+	err = cmd.Start()
+	if err != nil {
+		log.Fatalf("Restart: Failed to launch, error: %v", err)
+	}
+
+	return
+}

httplib/README.md

@@ -6,53 +6,71 @@ httplib is an libs help you to curl remote url.
 ## GET
 you can use Get to crawl data.
 
-	import "httplib"
+	import "github.com/astaxie/beego/httplib"
 	
 	str, err := httplib.Get("http://beego.me/").String()
 	if err != nil {
-		t.Fatal(err)
+        	// error
 	}
 	fmt.Println(str)
 	
 ## POST
 POST data to remote url
 
-	b:=httplib.Post("http://beego.me/")
-	b.Param("username","astaxie")
-	b.Param("password","123456")
-	str, err := b.String()
+	req := httplib.Post("http://beego.me/")
+	req.Param("username","astaxie")
+	req.Param("password","123456")
+	str, err := req.String()
 	if err != nil {
-		t.Fatal(err)
+        	// error
 	}
 	fmt.Println(str)
 
-## set timeout
-you can set timeout in request.default is 60 seconds.
+## Set timeout
 
-set Get timeout:
+The default timeout is `60` seconds, function prototype:
 
+	SetTimeout(connectTimeout, readWriteTimeout time.Duration)
+
+Exmaple:
+
+	// GET
 	httplib.Get("http://beego.me/").SetTimeout(100 * time.Second, 30 * time.Second)
 	
-set post timeout:	
-	
+	// POST
 	httplib.Post("http://beego.me/").SetTimeout(100 * time.Second, 30 * time.Second)
 
-- first param is connectTimeout.
-- second param is readWriteTimeout
 
-## debug
-if you want to debug the request info, set the debug on
+## Debug
+
+If you want to debug the request info, set the debug on
 
 	httplib.Get("http://beego.me/").Debug(true)
 	
-## support HTTPS client
-if request url is https. You can set the client support TSL:
+## Set HTTP Basic Auth
+
+	str, err := Get("http://beego.me/").SetBasicAuth("user", "passwd").String()
+	if err != nil {
+        	// error
+	}
+	fmt.Println(str)
+	
+## Set HTTPS
+
+If request url is https, You can set the client support TSL:
 
 	httplib.SetTLSClientConfig(&tls.Config{InsecureSkipVerify: true})
 	
-more info about the tls.Config please visit http://golang.org/pkg/crypto/tls/#Config	
-		
-## set cookie
+More info about the `tls.Config` please visit http://golang.org/pkg/crypto/tls/#Config	
+
+## Set HTTP Version
+
+some servers need to specify the protocol version of HTTP
+
+	httplib.Get("http://beego.me/").SetProtocolVersion("HTTP/1.1")
+	
+## Set Cookie
+
 some http request need setcookie. So set it like this:
 
 	cookie := &http.Cookie{}
@@ -60,21 +78,20 @@ some http request need setcookie. So set it like this:
 	cookie.Value  = "astaxie"
 	httplib.Get("http://beego.me/").SetCookie(cookie)
 
-## upload file
-httplib support mutil file upload, use `b.PostFile()`
+## Upload file
 
-	b:=httplib.Post("http://beego.me/")
-	b.Param("username","astaxie")
-	b.Param("password","123456")
-	b.PostFile("uploadfile1", "httplib.pdf")
-	b.PostFile("uploadfile2", "httplib.txt")
-	str, err := b.String()
+httplib support mutil file upload, use `req.PostFile()`
+
+	req := httplib.Post("http://beego.me/")
+	req.Param("username","astaxie")
+	req.PostFile("uploadfile1", "httplib.pdf")
+	str, err := req.String()
 	if err != nil {
-		t.Fatal(err)
+        	// error
 	}
 	fmt.Println(str)
 
-## set HTTP version
-some servers need to specify the protocol version of HTTP
 
-	httplib.Get("http://beego.me/").SetProtocolVersion("HTTP/1.1")
+See godoc for further documentation and examples.
+
+* [godoc.org/github.com/astaxie/beego/httplib](https://godoc.org/github.com/astaxie/beego/httplib)

httplib/httplib.go

@@ -14,9 +14,9 @@
 
 // Usage:
 //
-// import "github.com/astaxie/beego/context"
+// import "github.com/astaxie/beego/httplib"
 //
-//	b:=httplib.Post("http://beego.me/")
+//	b := httplib.Post("http://beego.me/")
 //	b.Param("username","astaxie")
 //	b.Param("password","123456")
 //	b.PostFile("uploadfile1", "httplib.pdf")
@@ -32,11 +32,13 @@ package httplib
 
 import (
 	"bytes"
+	"compress/gzip"
 	"crypto/tls"
 	"encoding/json"
 	"encoding/xml"
 	"io"
 	"io/ioutil"
+	"log"
 	"mime/multipart"
 	"net"
 	"net/http"
@@ -49,11 +51,18 @@ import (
 	"time"
 )
 
-var defaultSetting = BeegoHttpSettings{false, "beegoServer", 60 * time.Second, 60 * time.Second, nil, nil, nil, false}
+var defaultSetting = BeegoHttpSettings{
+	UserAgent:        "beegoServer",
+	ConnectTimeout:   60 * time.Second,
+	ReadWriteTimeout: 60 * time.Second,
+	Gzip:             true,
+	DumpBody:         true,
+}
+
 var defaultCookieJar http.CookieJar
 var settingMutex sync.Mutex
 
-// createDefaultCookieJar creates a global cookiejar to store cookies.
+// createDefaultCookie creates a global cookiejar to store cookies.
 func createDefaultCookie() {
 	settingMutex.Lock()
 	defer settingMutex.Unlock()
@@ -73,44 +82,54 @@ func SetDefaultSetting(setting BeegoHttpSettings) {
 	}
 }
 
+// return *BeegoHttpRequest with specific method
+func NewBeegoRequest(rawurl, method string) *BeegoHttpRequest {
+	var resp http.Response
+	u, err := url.Parse(rawurl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	req := http.Request{
+		URL:        u,
+		Method:     method,
+		Header:     make(http.Header),
+		Proto:      "HTTP/1.1",
+		ProtoMajor: 1,
+		ProtoMinor: 1,
+	}
+	return &BeegoHttpRequest{
+		url:     rawurl,
+		req:     &req,
+		params:  map[string]string{},
+		files:   map[string]string{},
+		setting: defaultSetting,
+		resp:    &resp,
+	}
+}
+
 // Get returns *BeegoHttpRequest with GET method.
 func Get(url string) *BeegoHttpRequest {
-	var req http.Request
-	req.Method = "GET"
-	req.Header = http.Header{}
-	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting}
+	return NewBeegoRequest(url, "GET")
 }
 
 // Post returns *BeegoHttpRequest with POST method.
 func Post(url string) *BeegoHttpRequest {
-	var req http.Request
-	req.Method = "POST"
-	req.Header = http.Header{}
-	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting}
+	return NewBeegoRequest(url, "POST")
 }
 
 // Put returns *BeegoHttpRequest with PUT method.
 func Put(url string) *BeegoHttpRequest {
-	var req http.Request
-	req.Method = "PUT"
-	req.Header = http.Header{}
-	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting}
+	return NewBeegoRequest(url, "PUT")
 }
 
-// Delete returns *BeegoHttpRequest DELETE GET method.
+// Delete returns *BeegoHttpRequest DELETE method.
 func Delete(url string) *BeegoHttpRequest {
-	var req http.Request
-	req.Method = "DELETE"
-	req.Header = http.Header{}
-	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting}
+	return NewBeegoRequest(url, "DELETE")
 }
 
 // Head returns *BeegoHttpRequest with HEAD method.
 func Head(url string) *BeegoHttpRequest {
-	var req http.Request
-	req.Method = "HEAD"
-	req.Header = http.Header{}
-	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting}
+	return NewBeegoRequest(url, "HEAD")
 }
 
 // BeegoHttpSettings
@@ -123,6 +142,8 @@ type BeegoHttpSettings struct {
 	Proxy            func(*http.Request) (*url.URL, error)
 	Transport        http.RoundTripper
 	EnableCookie     bool
+	Gzip             bool
+	DumpBody         bool
 }
 
 // BeegoHttpRequest provides more useful methods for requesting one url than http.Request.
@@ -132,6 +153,14 @@ type BeegoHttpRequest struct {
 	params  map[string]string
 	files   map[string]string
 	setting BeegoHttpSettings
+	resp    *http.Response
+	body    []byte
+	dump    []byte
+}
+
+// get request
+func (b *BeegoHttpRequest) GetRequest() *http.Request {
+	return b.req
 }
 
 // Change request settings
@@ -140,6 +169,12 @@ func (b *BeegoHttpRequest) Setting(setting BeegoHttpSettings) *BeegoHttpRequest
 	return b
 }
 
+// SetBasicAuth sets the request's Authorization header to use HTTP Basic Authentication with the provided username and password.
+func (b *BeegoHttpRequest) SetBasicAuth(username, password string) *BeegoHttpRequest {
+	b.req.SetBasicAuth(username, password)
+	return b
+}
+
 // SetEnableCookie sets enable/disable cookiejar
 func (b *BeegoHttpRequest) SetEnableCookie(enable bool) *BeegoHttpRequest {
 	b.setting.EnableCookie = enable
@@ -158,6 +193,17 @@ func (b *BeegoHttpRequest) Debug(isdebug bool) *BeegoHttpRequest {
 	return b
 }
 
+// Dump Body.
+func (b *BeegoHttpRequest) DumpBody(isdump bool) *BeegoHttpRequest {
+	b.setting.DumpBody = isdump
+	return b
+}
+
+// return the DumpRequest
+func (b *BeegoHttpRequest) DumpRequest() []byte {
+	return b.dump
+}
+
 // SetTimeout sets connect time out and read-write time out for BeegoRequest.
 func (b *BeegoHttpRequest) SetTimeout(connectTimeout, readWriteTimeout time.Duration) *BeegoHttpRequest {
 	b.setting.ConnectTimeout = connectTimeout
@@ -177,6 +223,12 @@ func (b *BeegoHttpRequest) Header(key, value string) *BeegoHttpRequest {
 	return b
 }
 
+// Set HOST
+func (b *BeegoHttpRequest) SetHost(host string) *BeegoHttpRequest {
+	b.req.Host = host
+	return b
+}
+
 // Set the protocol version for incoming requests.
 // Client requests always use HTTP/1.1.
 func (b *BeegoHttpRequest) SetProtocolVersion(vers string) *BeegoHttpRequest {
@@ -246,7 +298,87 @@ func (b *BeegoHttpRequest) Body(data interface{}) *BeegoHttpRequest {
 	return b
 }
 
+// JsonBody adds request raw body encoding by JSON.
+func (b *BeegoHttpRequest) JsonBody(obj interface{}) (*BeegoHttpRequest, error) {
+	if b.req.Body == nil && obj != nil {
+		buf := bytes.NewBuffer(nil)
+		enc := json.NewEncoder(buf)
+		if err := enc.Encode(obj); err != nil {
+			return b, err
+		}
+		b.req.Body = ioutil.NopCloser(buf)
+		b.req.ContentLength = int64(buf.Len())
+		b.req.Header.Set("Content-Type", "application/json")
+	}
+	return b, nil
+}
+
+func (b *BeegoHttpRequest) buildUrl(paramBody string) {
+	// build GET url with query string
+	if b.req.Method == "GET" && len(paramBody) > 0 {
+		if strings.Index(b.url, "?") != -1 {
+			b.url += "&" + paramBody
+		} else {
+			b.url = b.url + "?" + paramBody
+		}
+		return
+	}
+
+	// build POST/PUT/PATCH url and body
+	if (b.req.Method == "POST" || b.req.Method == "PUT" || b.req.Method == "PATCH") && b.req.Body == nil {
+		// with files
+		if len(b.files) > 0 {
+			pr, pw := io.Pipe()
+			bodyWriter := multipart.NewWriter(pw)
+			go func() {
+				for formname, filename := range b.files {
+					fileWriter, err := bodyWriter.CreateFormFile(formname, filename)
+					if err != nil {
+						log.Fatal(err)
+					}
+					fh, err := os.Open(filename)
+					if err != nil {
+						log.Fatal(err)
+					}
+					//iocopy
+					_, err = io.Copy(fileWriter, fh)
+					fh.Close()
+					if err != nil {
+						log.Fatal(err)
+					}
+				}
+				for k, v := range b.params {
+					bodyWriter.WriteField(k, v)
+				}
+				bodyWriter.Close()
+				pw.Close()
+			}()
+			b.Header("Content-Type", bodyWriter.FormDataContentType())
+			b.req.Body = ioutil.NopCloser(pr)
+			return
+		}
+
+		// with params
+		if len(paramBody) > 0 {
+			b.Header("Content-Type", "application/x-www-form-urlencoded")
+			b.Body(paramBody)
+		}
+	}
+}
+
 func (b *BeegoHttpRequest) getResponse() (*http.Response, error) {
+	if b.resp.StatusCode != 0 {
+		return b.resp, nil
+	}
+	resp, err := b.SendOut()
+	if err != nil {
+		return nil, err
+	}
+	b.resp = resp
+	return resp, nil
+}
+
+func (b *BeegoHttpRequest) SendOut() (*http.Response, error) {
 	var paramBody string
 	if len(b.params) > 0 {
 		var buf bytes.Buffer
@@ -260,63 +392,13 @@ func (b *BeegoHttpRequest) getResponse() (*http.Response, error) {
 		paramBody = paramBody[0 : len(paramBody)-1]
 	}
 
-	if b.req.Method == "GET" && len(paramBody) > 0 {
-		if strings.Index(b.url, "?") != -1 {
-			b.url += "&" + paramBody
-		} else {
-			b.url = b.url + "?" + paramBody
-		}
-	} else if b.req.Method == "POST" && b.req.Body == nil && len(paramBody) > 0 {
-		if len(b.files) > 0 {
-			bodyBuf := &bytes.Buffer{}
-			bodyWriter := multipart.NewWriter(bodyBuf)
-			for formname, filename := range b.files {
-				fileWriter, err := bodyWriter.CreateFormFile(formname, filename)
-				if err != nil {
-					return nil, err
-				}
-				fh, err := os.Open(filename)
-				if err != nil {
-					return nil, err
-				}
-				//iocopy
-				_, err = io.Copy(fileWriter, fh)
-				fh.Close()
-				if err != nil {
-					return nil, err
-				}
-			}
-			for k, v := range b.params {
-				bodyWriter.WriteField(k, v)
-			}
-			contentType := bodyWriter.FormDataContentType()
-			bodyWriter.Close()
-			b.Header("Content-Type", contentType)
-			b.req.Body = ioutil.NopCloser(bodyBuf)
-			b.req.ContentLength = int64(bodyBuf.Len())
-		} else {
-			b.Header("Content-Type", "application/x-www-form-urlencoded")
-			b.Body(paramBody)
-		}
-	}
-
+	b.buildUrl(paramBody)
 	url, err := url.Parse(b.url)
-	if url.Scheme == "" {
-		b.url = "http://" + b.url
-		url, err = url.Parse(b.url)
-	}
 	if err != nil {
 		return nil, err
 	}
 
 	b.req.URL = url
-	if b.setting.ShowDebug {
-		dump, err := httputil.DumpRequest(b.req, true)
-		if err != nil {
-			println(err.Error())
-		}
-		println(string(dump))
-	}
 
 	trans := b.setting.Transport
 
@@ -342,14 +424,12 @@ func (b *BeegoHttpRequest) getResponse() (*http.Response, error) {
 		}
 	}
 
-	var jar http.CookieJar
+	var jar http.CookieJar = nil
 	if b.setting.EnableCookie {
 		if defaultCookieJar == nil {
 			createDefaultCookie()
 		}
 		jar = defaultCookieJar
-	} else {
-		jar = nil
 	}
 
 	client := &http.Client{
@@ -357,15 +437,18 @@ func (b *BeegoHttpRequest) getResponse() (*http.Response, error) {
 		Jar:       jar,
 	}
 
-	if b.setting.UserAgent != "" {
+	if b.setting.UserAgent != "" && b.req.Header.Get("User-Agent") == "" {
 		b.req.Header.Set("User-Agent", b.setting.UserAgent)
 	}
 
-	resp, err := client.Do(b.req)
-	if err != nil {
-		return nil, err
+	if b.setting.ShowDebug {
+		dump, err := httputil.DumpRequest(b.req, b.setting.DumpBody)
+		if err != nil {
+			log.Println(err.Error())
+		}
+		b.dump = dump
 	}
-	return resp, nil
+	return client.Do(b.req)
 }
 
 // String returns the body string in response.
@@ -382,6 +465,9 @@ func (b *BeegoHttpRequest) String() (string, error) {
 // Bytes returns the body []byte in response.
 // it calls Response inner.
 func (b *BeegoHttpRequest) Bytes() ([]byte, error) {
+	if b.body != nil {
+		return b.body, nil
+	}
 	resp, err := b.getResponse()
 	if err != nil {
 		return nil, err
@@ -390,11 +476,16 @@ func (b *BeegoHttpRequest) Bytes() ([]byte, error) {
 		return nil, nil
 	}
 	defer resp.Body.Close()
-	data, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
+	if b.setting.Gzip && resp.Header.Get("Content-Encoding") == "gzip" {
+		reader, err := gzip.NewReader(resp.Body)
+		if err != nil {
+			return nil, err
+		}
+		b.body, err = ioutil.ReadAll(reader)
+	} else {
+		b.body, err = ioutil.ReadAll(resp.Body)
 	}
-	return data, nil
+	return b.body, err
 }
 
 // ToFile saves the body data in response to one file.
@@ -425,8 +516,7 @@ func (b *BeegoHttpRequest) ToJson(v interface{}) error {
 	if err != nil {
 		return err
 	}
-	err = json.Unmarshal(data, v)
-	return err
+	return json.Unmarshal(data, v)
 }
 
 // ToXml returns the map that marshals from the body bytes as xml in response .
@@ -436,8 +526,7 @@ func (b *BeegoHttpRequest) ToXml(v interface{}) error {
 	if err != nil {
 		return err
 	}
-	err = xml.Unmarshal(data, v)
-	return err
+	return xml.Unmarshal(data, v)
 }
 
 // Response executes request client gets response mannually.
@@ -452,7 +541,7 @@ func TimeoutDialer(cTimeout time.Duration, rwTimeout time.Duration) func(net, ad
 		if err != nil {
 			return nil, err
 		}
-		conn.SetDeadline(time.Now().Add(rwTimeout))
-		return conn, nil
+		err = conn.SetDeadline(time.Now().Add(rwTimeout))
+		return conn, err
 	}
 }

httplib/httplib_test.go

@@ -15,47 +15,90 @@
 package httplib
 
 import (
+	"io/ioutil"
+	"os"
 	"strings"
 	"testing"
 )
 
-func TestSimpleGet(t *testing.T) {
-	str, err := Get("http://httpbin.org/get").String()
+func TestResponse(t *testing.T) {
+	req := Get("http://httpbin.org/get")
+	resp, err := req.Response()
 	if err != nil {
 		t.Fatal(err)
 	}
-	t.Log(str)
+	t.Log(resp)
+}
+
+func TestGet(t *testing.T) {
+	req := Get("http://httpbin.org/get")
+	b, err := req.Bytes()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(b)
+
+	s, err := req.String()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(s)
+
+	if string(b) != s {
+		t.Fatal("request data not match")
+	}
 }
 
 func TestSimplePost(t *testing.T) {
 	v := "smallfish"
 	req := Post("http://httpbin.org/post")
 	req.Param("username", v)
+
 	str, err := req.String()
 	if err != nil {
 		t.Fatal(err)
 	}
 	t.Log(str)
+
 	n := strings.Index(str, v)
 	if n == -1 {
 		t.Fatal(v + " not found in post")
 	}
 }
 
-func TestPostFile(t *testing.T) {
-	v := "smallfish"
-	req := Post("http://httpbin.org/post")
-	req.Param("username", v)
-	req.PostFile("uploadfile", "httplib_test.go")
-	str, err := req.String()
+//func TestPostFile(t *testing.T) {
+//	v := "smallfish"
+//	req := Post("http://httpbin.org/post")
+//	req.Debug(true)
+//	req.Param("username", v)
+//	req.PostFile("uploadfile", "httplib_test.go")
+
+//	str, err := req.String()
+//	if err != nil {
+//		t.Fatal(err)
+//	}
+//	t.Log(str)
+
+//	n := strings.Index(str, v)
+//	if n == -1 {
+//		t.Fatal(v + " not found in post")
+//	}
+//}
+
+func TestSimplePut(t *testing.T) {
+	str, err := Put("http://httpbin.org/put").String()
 	if err != nil {
 		t.Fatal(err)
 	}
 	t.Log(str)
-	n := strings.Index(str, v)
-	if n == -1 {
-		t.Fatal(v + " not found in post")
+}
+
+func TestSimpleDelete(t *testing.T) {
+	str, err := Delete("http://httpbin.org/delete").String()
+	if err != nil {
+		t.Fatal(err)
 	}
+	t.Log(str)
 }
 
 func TestWithCookie(t *testing.T) {
@@ -65,17 +108,31 @@ func TestWithCookie(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Log(str)
+
 	str, err = Get("http://httpbin.org/cookies").SetEnableCookie(true).String()
 	if err != nil {
 		t.Fatal(err)
 	}
 	t.Log(str)
+
 	n := strings.Index(str, v)
 	if n == -1 {
 		t.Fatal(v + " not found in cookie")
 	}
 }
 
+func TestWithBasicAuth(t *testing.T) {
+	str, err := Get("http://httpbin.org/basic-auth/user/passwd").SetBasicAuth("user", "passwd").String()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(str)
+	n := strings.Index(str, "authenticated")
+	if n == -1 {
+		t.Fatal("authenticated not found in response")
+	}
+}
+
 func TestWithUserAgent(t *testing.T) {
 	v := "beego"
 	str, err := Get("http://httpbin.org/headers").SetUserAgent(v).String()
@@ -83,6 +140,7 @@ func TestWithUserAgent(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Log(str)
+
 	n := strings.Index(str, v)
 	if n == -1 {
 		t.Fatal(v + " not found in user-agent")
@@ -102,8 +160,57 @@ func TestWithSetting(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Log(str)
+
 	n := strings.Index(str, v)
 	if n == -1 {
 		t.Fatal(v + " not found in user-agent")
 	}
 }
+
+func TestToJson(t *testing.T) {
+	req := Get("http://httpbin.org/ip")
+	resp, err := req.Response()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(resp)
+
+	// httpbin will return http remote addr
+	type Ip struct {
+		Origin string `json:"origin"`
+	}
+	var ip Ip
+	err = req.ToJson(&ip)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(ip.Origin)
+
+	if n := strings.Count(ip.Origin, "."); n != 3 {
+		t.Fatal("response is not valid ip")
+	}
+}
+
+func TestToFile(t *testing.T) {
+	f := "beego_testfile"
+	req := Get("http://httpbin.org/ip")
+	err := req.ToFile(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(f)
+	b, err := ioutil.ReadFile(f)
+	if n := strings.Index(string(b), "origin"); n == -1 {
+		t.Fatal(err)
+	}
+}
+
+func TestHeader(t *testing.T) {
+	req := Get("http://httpbin.org/headers")
+	req.Header("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.57 Safari/537.36")
+	str, err := req.String()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(str)
+}

log.go

@@ -78,9 +78,9 @@ func Warning(v ...interface{}) {
 	BeeLogger.Warning(generateFmtStr(len(v)), v...)
 }
 
-// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0.
+// compatibility alias for Warning()
 func Warn(v ...interface{}) {
-	Warning(v...)
+	BeeLogger.Warn(generateFmtStr(len(v)), v...)
 }
 
 func Notice(v ...interface{}) {
@@ -92,9 +92,9 @@ func Informational(v ...interface{}) {
 	BeeLogger.Informational(generateFmtStr(len(v)), v...)
 }
 
-// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0.
+// compatibility alias for Warning()
 func Info(v ...interface{}) {
-	Informational(v...)
+	BeeLogger.Info(generateFmtStr(len(v)), v...)
 }
 
 // Debug logs a message at debug level.
@@ -103,7 +103,7 @@ func Debug(v ...interface{}) {
 }
 
 // Trace logs a message at trace level.
-// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0.
+// compatibility alias for Warning()
 func Trace(v ...interface{}) {
 	BeeLogger.Trace(generateFmtStr(len(v)), v...)
 }

logs/conn.go

@@ -43,11 +43,7 @@ func NewConn() LoggerInterface {
 // init connection writer with json config.
 // json config only need key "level".
 func (c *ConnWriter) Init(jsonconfig string) error {
-	err := json.Unmarshal([]byte(jsonconfig), c)
-	if err != nil {
-		return err
-	}
-	return nil
+	return json.Unmarshal([]byte(jsonconfig), c)
 }
 
 // write message in connection.
@@ -77,10 +73,9 @@ func (c *ConnWriter) Flush() {
 
 // destroy connection writer and close tcp listener.
 func (c *ConnWriter) Destroy() {
-	if c.innerWriter == nil {
-		return
+	if c.innerWriter != nil {
+		c.innerWriter.Close()
 	}
-	c.innerWriter.Close()
 }
 
 func (c *ConnWriter) connect() error {

logs/console.go

@@ -38,8 +38,8 @@ var colors = []Brush{
 	NewBrush("1;31"), // Error      red
 	NewBrush("1;33"), // Warning    yellow
 	NewBrush("1;32"), // Notice			green
-	NewBrush("1;34"), // Informational	green
-	NewBrush("1;30"), // Debug      black
+	NewBrush("1;34"), // Informational	blue
+	NewBrush("1;34"), // Debug      blue
 }
 
 // ConsoleWriter implements LoggerInterface and writes messages to terminal.
@@ -50,9 +50,10 @@ type ConsoleWriter struct {
 
 // create ConsoleWriter returning as LoggerInterface.
 func NewConsole() LoggerInterface {
-	cw := new(ConsoleWriter)
-	cw.lg = log.New(os.Stdout, "", log.Ldate|log.Ltime)
-	cw.Level = LevelDebug
+	cw := &ConsoleWriter{
+		lg:    log.New(os.Stdout, "", log.Ldate|log.Ltime),
+		Level: LevelDebug,
+	}
 	return cw
 }
 
@@ -62,11 +63,7 @@ func (c *ConsoleWriter) Init(jsonconfig string) error {
 	if len(jsonconfig) == 0 {
 		return nil
 	}
-	err := json.Unmarshal([]byte(jsonconfig), c)
-	if err != nil {
-		return err
-	}
-	return nil
+	return json.Unmarshal([]byte(jsonconfig), c)
 }
 
 // write message in console.
@@ -76,9 +73,10 @@ func (c *ConsoleWriter) WriteMsg(msg string, level int) error {
 	}
 	if goos := runtime.GOOS; goos == "windows" {
 		c.lg.Println(msg)
-	} else {
-		c.lg.Println(colors[level](msg))
+		return nil
 	}
+	c.lg.Println(colors[level](msg))
+
 	return nil
 }
 

logs/es/es.go

@@ -0,0 +1,76 @@
+package es
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net"
+	"net/url"
+	"time"
+
+	"github.com/astaxie/beego/logs"
+	"github.com/belogik/goes"
+)
+
+func NewES() logs.LoggerInterface {
+	cw := &esLogger{
+		Level: logs.LevelDebug,
+	}
+	return cw
+}
+
+type esLogger struct {
+	*goes.Connection
+	DSN   string `json:"dsn"`
+	Level int    `json:"level"`
+}
+
+// {"dsn":"http://localhost:9200/","level":1}
+func (el *esLogger) Init(jsonconfig string) error {
+	err := json.Unmarshal([]byte(jsonconfig), el)
+	if err != nil {
+		return err
+	}
+	if el.DSN == "" {
+		return errors.New("empty dsn")
+	} else if u, err := url.Parse(el.DSN); err != nil {
+		return err
+	} else if u.Path == "" {
+		return errors.New("missing prefix")
+	} else if host, port, err := net.SplitHostPort(u.Host); err != nil {
+		return err
+	} else {
+		conn := goes.NewConnection(host, port)
+		el.Connection = conn
+	}
+	return nil
+}
+
+func (el *esLogger) WriteMsg(msg string, level int) error {
+	if level > el.Level {
+		return nil
+	}
+	t := time.Now()
+	vals := make(map[string]interface{})
+	vals["@timestamp"] = t.Format(time.RFC3339)
+	vals["@msg"] = msg
+	d := goes.Document{
+		Index:  fmt.Sprintf("%04d.%02d.%02d", t.Year(), t.Month(), t.Day()),
+		Type:   "logs",
+		Fields: vals,
+	}
+	_, err := el.Index(d, nil)
+	return err
+}
+
+func (el *esLogger) Destroy() {
+
+}
+
+func (el *esLogger) Flush() {
+
+}
+
+func init() {
+	logs.Register("es", NewES)
+}

logs/file.go

@@ -15,10 +15,11 @@
 package logs
 
 import (
+	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"os"
 	"path/filepath"
@@ -122,11 +123,7 @@ func (w *FileLogWriter) startLogger() error {
 		return err
 	}
 	w.mw.SetFd(fd)
-	err = w.initFd()
-	if err != nil {
-		return err
-	}
-	return nil
+	return w.initFd()
 }
 
 func (w *FileLogWriter) docheck(size int) {
@@ -169,18 +166,44 @@ func (w *FileLogWriter) initFd() error {
 	}
 	w.maxsize_cursize = int(finfo.Size())
 	w.daily_opendate = time.Now().Day()
+	w.maxlines_curlines = 0
 	if finfo.Size() > 0 {
-		content, err := ioutil.ReadFile(w.Filename)
+		count, err := w.lines()
 		if err != nil {
 			return err
 		}
-		w.maxlines_curlines = len(strings.Split(string(content), "\n"))
-	} else {
-		w.maxlines_curlines = 0
+		w.maxlines_curlines = count
 	}
 	return nil
 }
 
+func (w *FileLogWriter) lines() (int, error) {
+	fd, err := os.Open(w.Filename)
+	if err != nil {
+		return 0, err
+	}
+	defer fd.Close()
+
+	buf := make([]byte, 32768) // 32k
+	count := 0
+	lineSep := []byte{'\n'}
+
+	for {
+		c, err := fd.Read(buf)
+		if err != nil && err != io.EOF {
+			return count, err
+		}
+
+		count += bytes.Count(buf[:c], lineSep)
+
+		if err == io.EOF {
+			break
+		}
+	}
+
+	return count, nil
+}
+
 // DoRotate means it need to write file in new file.
 // new file name like xx.log.2013-01-01.2
 func (w *FileLogWriter) DoRotate() error {
@@ -226,13 +249,20 @@ func (w *FileLogWriter) DoRotate() error {
 
 func (w *FileLogWriter) deleteOldLog() {
 	dir := filepath.Dir(w.Filename)
-	filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+	filepath.Walk(dir, func(path string, info os.FileInfo, err error) (returnErr error) {
+		defer func() {
+			if r := recover(); r != nil {
+				returnErr = fmt.Errorf("Unable to delete old log '%s', error: %+v", path, r)
+				fmt.Println(returnErr)
+			}
+		}()
+
 		if !info.IsDir() && info.ModTime().Unix() < (time.Now().Unix()-60*60*24*w.Maxdays) {
 			if strings.HasPrefix(filepath.Base(path), filepath.Base(w.Filename)) {
 				os.Remove(path)
 			}
 		}
-		return nil
+		return
 	})
 }
 

logs/log.go

@@ -92,6 +92,7 @@ type BeeLogger struct {
 	level               int
 	enableFuncCallDepth bool
 	loggerFuncCallDepth int
+	asynchronous        bool
 	msg                 chan *logMsg
 	outputs             map[string]LoggerInterface
 }
@@ -110,7 +111,11 @@ func NewLogger(channellen int64) *BeeLogger {
 	bl.loggerFuncCallDepth = 2
 	bl.msg = make(chan *logMsg, channellen)
 	bl.outputs = make(map[string]LoggerInterface)
-	//bl.SetLogger("console", "") // default output to console
+	return bl
+}
+
+func (bl *BeeLogger) Async() *BeeLogger {
+	bl.asynchronous = true
 	go bl.startLogger()
 	return bl
 }
@@ -148,23 +153,30 @@ func (bl *BeeLogger) DelLogger(adaptername string) error {
 }
 
 func (bl *BeeLogger) writerMsg(loglevel int, msg string) error {
-	if loglevel > bl.level {
-		return nil
-	}
 	lm := new(logMsg)
 	lm.level = loglevel
 	if bl.enableFuncCallDepth {
 		_, file, line, ok := runtime.Caller(bl.loggerFuncCallDepth)
-		if ok {
-			_, filename := path.Split(file)
-			lm.msg = fmt.Sprintf("[%s:%d] %s", filename, line, msg)
-		} else {
-			lm.msg = msg
+		if !ok {
+			file = "???"
+			line = 0
 		}
+		_, filename := path.Split(file)
+		lm.msg = fmt.Sprintf("[%s:%d] %s", filename, line, msg)
 	} else {
 		lm.msg = msg
 	}
-	bl.msg <- lm
+	if bl.asynchronous {
+		bl.msg <- lm
+	} else {
+		for name, l := range bl.outputs {
+			err := l.WriteMsg(lm.msg, lm.level)
+			if err != nil {
+				fmt.Println("unable to WriteMsg to adapter:", name, err)
+				return err
+			}
+		}
+	}
 	return nil
 }
 
@@ -181,6 +193,11 @@ func (bl *BeeLogger) SetLogFuncCallDepth(d int) {
 	bl.loggerFuncCallDepth = d
 }
 
+// get log funcCallDepth for wrapper
+func (bl *BeeLogger) GetLogFuncCallDepth() int {
+	return bl.loggerFuncCallDepth
+}
+
 // enable log funcCallDepth
 func (bl *BeeLogger) EnableFuncCallDepth(b bool) {
 	bl.enableFuncCallDepth = b
@@ -193,7 +210,10 @@ func (bl *BeeLogger) startLogger() {
 		select {
 		case bm := <-bl.msg:
 			for _, l := range bl.outputs {
-				l.WriteMsg(bm.msg, bm.level)
+				err := l.WriteMsg(bm.msg, bm.level)
+				if err != nil {
+					fmt.Println("ERROR, unable to WriteMsg:", err)
+				}
 			}
 		}
 	}
@@ -201,71 +221,104 @@ func (bl *BeeLogger) startLogger() {
 
 // Log EMERGENCY level message.
 func (bl *BeeLogger) Emergency(format string, v ...interface{}) {
-	msg := fmt.Sprintf("[D] "+format, v...)
+	if LevelEmergency > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[M] "+format, v...)
 	bl.writerMsg(LevelEmergency, msg)
 }
 
 // Log ALERT level message.
 func (bl *BeeLogger) Alert(format string, v ...interface{}) {
-	msg := fmt.Sprintf("[D] "+format, v...)
+	if LevelAlert > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[A] "+format, v...)
 	bl.writerMsg(LevelAlert, msg)
 }
 
 // Log CRITICAL level message.
 func (bl *BeeLogger) Critical(format string, v ...interface{}) {
+	if LevelCritical > bl.level {
+		return
+	}
 	msg := fmt.Sprintf("[C] "+format, v...)
 	bl.writerMsg(LevelCritical, msg)
 }
 
 // Log ERROR level message.
 func (bl *BeeLogger) Error(format string, v ...interface{}) {
+	if LevelError > bl.level {
+		return
+	}
 	msg := fmt.Sprintf("[E] "+format, v...)
 	bl.writerMsg(LevelError, msg)
 }
 
 // Log WARNING level message.
 func (bl *BeeLogger) Warning(format string, v ...interface{}) {
+	if LevelWarning > bl.level {
+		return
+	}
 	msg := fmt.Sprintf("[W] "+format, v...)
 	bl.writerMsg(LevelWarning, msg)
 }
 
 // Log NOTICE level message.
 func (bl *BeeLogger) Notice(format string, v ...interface{}) {
-	msg := fmt.Sprintf("[W] "+format, v...)
+	if LevelNotice > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[N] "+format, v...)
 	bl.writerMsg(LevelNotice, msg)
 }
 
 // Log INFORMATIONAL level message.
 func (bl *BeeLogger) Informational(format string, v ...interface{}) {
+	if LevelInformational > bl.level {
+		return
+	}
 	msg := fmt.Sprintf("[I] "+format, v...)
 	bl.writerMsg(LevelInformational, msg)
 }
 
 // Log DEBUG level message.
 func (bl *BeeLogger) Debug(format string, v ...interface{}) {
+	if LevelDebug > bl.level {
+		return
+	}
 	msg := fmt.Sprintf("[D] "+format, v...)
 	bl.writerMsg(LevelDebug, msg)
 }
 
 // Log WARN level message.
-//
-// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0.
+// compatibility alias for Warning()
 func (bl *BeeLogger) Warn(format string, v ...interface{}) {
-	bl.Warning(format, v...)
+	if LevelWarning > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[W] "+format, v...)
+	bl.writerMsg(LevelWarning, msg)
 }
 
 // Log INFO level message.
-//
-// Deprecated: compatibility alias for Informational(), Will be removed in 1.5.0.
+// compatibility alias for Informational()
 func (bl *BeeLogger) Info(format string, v ...interface{}) {
-	bl.Informational(format, v...)
+	if LevelInformational > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[I] "+format, v...)
+	bl.writerMsg(LevelInformational, msg)
 }
 
 // Log TRACE level message.
-//
-// Deprecated: compatibility alias for Debug(), Will be removed in 1.5.0.
+// compatibility alias for Debug()
 func (bl *BeeLogger) Trace(format string, v ...interface{}) {
-	bl.Debug(format, v...)
+	if LevelDebug > bl.level {
+		return
+	}
+	msg := fmt.Sprintf("[D] "+format, v...)
+	bl.writerMsg(LevelDebug, msg)
 }
 
 // flush all chan data.
@@ -281,11 +334,14 @@ func (bl *BeeLogger) Close() {
 		if len(bl.msg) > 0 {
 			bm := <-bl.msg
 			for _, l := range bl.outputs {
-				l.WriteMsg(bm.msg, bm.level)
+				err := l.WriteMsg(bm.msg, bm.level)
+				if err != nil {
+					fmt.Println("ERROR, unable to WriteMsg (while closing logger):", err)
+				}
 			}
-		} else {
-			break
+			continue
 		}
+		break
 	}
 	for _, l := range bl.outputs {
 		l.Flush()

logs/smtp.go

@@ -15,15 +15,18 @@
 package logs
 
 import (
+	"crypto/tls"
 	"encoding/json"
 	"fmt"
+	"net"
 	"net/smtp"
 	"strings"
 	"time"
 )
 
 const (
-	subjectPhrase = "Diagnostic message from server"
+// no usage
+// subjectPhrase = "Diagnostic message from server"
 )
 
 // smtpWriter implements LoggerInterface and is used to send emails via given SMTP-server.
@@ -32,6 +35,7 @@ type SmtpWriter struct {
 	Password           string   `json:"password"`
 	Host               string   `json:"Host"`
 	Subject            string   `json:"subject"`
+	FromAddress        string   `json:"fromAddress"`
 	RecipientAddresses []string `json:"sendTos"`
 	Level              int      `json:"level"`
 }
@@ -48,6 +52,7 @@ func NewSmtpWriter() LoggerInterface {
 //		"password:"password",
 //		"host":"smtp.gmail.com:465",
 //		"subject":"email title",
+//		"fromAddress":"from@example.com",
 //		"sendTos":["email1","email2"],
 //		"level":LevelError
 //	}
@@ -71,6 +76,59 @@ func (s *SmtpWriter) GetSmtpAuth(host string) smtp.Auth {
 	)
 }
 
+func (s *SmtpWriter) sendMail(hostAddressWithPort string, auth smtp.Auth, fromAddress string, recipients []string, msgContent []byte) error {
+	client, err := smtp.Dial(hostAddressWithPort)
+	if err != nil {
+		return err
+	}
+
+	host, _, _ := net.SplitHostPort(hostAddressWithPort)
+	tlsConn := &tls.Config{
+		InsecureSkipVerify: true,
+		ServerName:         host,
+	}
+	if err = client.StartTLS(tlsConn); err != nil {
+		return err
+	}
+
+	if auth != nil {
+		if err = client.Auth(auth); err != nil {
+			return err
+		}
+	}
+
+	if err = client.Mail(fromAddress); err != nil {
+		return err
+	}
+
+	for _, rec := range recipients {
+		if err = client.Rcpt(rec); err != nil {
+			return err
+		}
+	}
+
+	w, err := client.Data()
+	if err != nil {
+		return err
+	}
+	_, err = w.Write([]byte(msgContent))
+	if err != nil {
+		return err
+	}
+
+	err = w.Close()
+	if err != nil {
+		return err
+	}
+
+	err = client.Quit()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // write message in smtp writer.
 // it will send an email with subject and only this message.
 func (s *SmtpWriter) WriteMsg(msg string, level int) error {
@@ -86,18 +144,10 @@ func (s *SmtpWriter) WriteMsg(msg string, level int) error {
 	// Connect to the server, authenticate, set the sender and recipient,
 	// and send the email all in one step.
 	content_type := "Content-Type: text/plain" + "; charset=UTF-8"
-	mailmsg := []byte("To: " + strings.Join(s.RecipientAddresses, ";") + "\r\nFrom: " + s.Username + "<" + s.Username +
+	mailmsg := []byte("To: " + strings.Join(s.RecipientAddresses, ";") + "\r\nFrom: " + s.FromAddress + "<" + s.FromAddress +
 		">\r\nSubject: " + s.Subject + "\r\n" + content_type + "\r\n\r\n" + fmt.Sprintf(".%s", time.Now().Format("2006-01-02 15:04:05")) + msg)
 
-	err := smtp.SendMail(
-		s.Host,
-		auth,
-		s.Username,
-		s.RecipientAddresses,
-		mailmsg,
-	)
-
-	return err
+	return s.sendMail(s.Host, auth, s.FromAddress, s.RecipientAddresses, mailmsg)
 }
 
 // implementing method. empty.

middleware/exceptions.go

@@ -1,49 +0,0 @@
-// Copyright 2014 beego Author. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package middleware
-
-import "fmt"
-
-// http exceptions
-type HTTPException struct {
-	StatusCode  int // http status code 4xx, 5xx
-	Description string
-}
-
-// return http exception error string, e.g. "400 Bad Request".
-func (e *HTTPException) Error() string {
-	return fmt.Sprintf("%d %s", e.StatusCode, e.Description)
-}
-
-// map of http exceptions for each http status code int.
-// defined 400,401,403,404,405,500,502,503 and 504 default.
-var HTTPExceptionMaps map[int]HTTPException
-
-func init() {
-	HTTPExceptionMaps = make(map[int]HTTPException)
-
-	// Normal 4XX HTTP Status
-	HTTPExceptionMaps[400] = HTTPException{400, "Bad Request"}
-	HTTPExceptionMaps[401] = HTTPException{401, "Unauthorized"}
-	HTTPExceptionMaps[403] = HTTPException{403, "Forbidden"}
-	HTTPExceptionMaps[404] = HTTPException{404, "Not Found"}
-	HTTPExceptionMaps[405] = HTTPException{405, "Method Not Allowed"}
-
-	// Normal 5XX HTTP Status
-	HTTPExceptionMaps[500] = HTTPException{500, "Internal Server Error"}
-	HTTPExceptionMaps[502] = HTTPException{502, "Bad Gateway"}
-	HTTPExceptionMaps[503] = HTTPException{503, "Service Unavailable"}
-	HTTPExceptionMaps[504] = HTTPException{504, "Gateway Timeout"}
-}

middleware/i18n.go

@@ -34,7 +34,6 @@ type Translation struct {
 }
 
 func NewLocale(filepath string, defaultlocal string) *Translation {
-	i18n := make(map[string]map[string]string)
 	file, err := os.Open(filepath)
 	if err != nil {
 		panic("open " + filepath + " err :" + err.Error())
@@ -43,8 +42,9 @@ func NewLocale(filepath string, defaultlocal string) *Translation {
 	if err != nil {
 		panic("read " + filepath + " err :" + err.Error())
 	}
-	err = json.Unmarshal(data, &i18n)
-	if err != nil {
+
+	i18n := make(map[string]map[string]string)
+	if err = json.Unmarshal(data, &i18n); err != nil {
 		panic("json.Unmarshal " + filepath + " err :" + err.Error())
 	}
 	return &Translation{

migration/ddl.go

@@ -0,0 +1,46 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package migration
+
+type Table struct {
+	TableName string
+	Columns   []*Column
+}
+
+func (t *Table) Create() string {
+	return ""
+}
+
+func (t *Table) Drop() string {
+	return ""
+}
+
+type Column struct {
+	Name    string
+	Type    string
+	Default interface{}
+}
+
+func Create(tbname string, columns ...Column) string {
+	return ""
+}
+
+func Drop(tbname string, columns ...Column) string {
+	return ""
+}
+
+func TableDDL(tbname string, columns ...Column) string {
+	return ""
+}

mime.go

@@ -40,6 +40,7 @@ var mimemaps map[string]string = map[string]string{
 	".ani":         "application/x-navi-animation",
 	".aos":         "application/x-nokia-9000-communicator-add-on-software",
 	".aps":         "application/mime",
+	".apk":         "application/vnd.android.package-archive",
 	".arc":         "application/x-arc-compressed",
 	".arj":         "application/arj",
 	".art":         "image/x-jg",

namespace.go

@@ -19,7 +19,6 @@ import (
 	"strings"
 
 	beecontext "github.com/astaxie/beego/context"
-	"github.com/astaxie/beego/middleware"
 )
 
 type namespaceCond func(*beecontext.Context) bool
@@ -57,7 +56,7 @@ func NewNamespace(prefix string, params ...innnerNamespace) *Namespace {
 func (n *Namespace) Cond(cond namespaceCond) *Namespace {
 	fn := func(ctx *beecontext.Context) {
 		if !cond(ctx) {
-			middleware.Exception("405", ctx.ResponseWriter, ctx.Request, "Method not allowed")
+			exception("405", ctx)
 		}
 	}
 	if v, ok := n.handlers.filters[BeforeRouter]; ok {
@@ -217,7 +216,7 @@ func (n *Namespace) Namespace(ns ...*Namespace) *Namespace {
 				n.handlers.routers[k] = t
 			}
 		}
-		if n.handlers.enableFilter {
+		if ni.handlers.enableFilter {
 			for pos, filterList := range ni.handlers.filters {
 				for _, mr := range filterList {
 					t := NewTree()

orm/README.md

@@ -6,8 +6,6 @@ A powerful orm framework for go.
 
 It is heavily influenced by Django ORM, SQLAlchemy.
 
-now, beta, unstable, may be changing some api make your app build failed.
-
 **Support Database:**
 
 * MySQL: [github.com/go-sql-driver/mysql](https://github.com/go-sql-driver/mysql)
@@ -119,7 +117,7 @@ o.Begin()
 ...
 user := User{Name: "slene"}
 id, err := o.Insert(&user)
-if err != nil {
+if err == nil {
 	o.Commit()
 } else {
 	o.Rollback()

orm/cmd_utils.go

@@ -104,7 +104,11 @@ func getColumnAddQuery(al *alias, fi *fieldInfo) string {
 		typ += " " + "NOT NULL"
 	}
 
-	return fmt.Sprintf("ALTER TABLE %s%s%s ADD COLUMN %s%s%s %s", Q, fi.mi.table, Q, Q, fi.column, Q, typ)
+	return fmt.Sprintf("ALTER TABLE %s%s%s ADD COLUMN %s%s%s %s %s", 
+		Q, fi.mi.table, Q, 
+		Q, fi.column, Q, 
+		typ, getColumnDefault(fi),
+	)
 }
 
 // create database creation string.
@@ -155,6 +159,9 @@ func getDbCreateSql(al *alias) (sqls []string, tableIndexes map[string][]dbIndex
 				//if fi.initial.String() != "" {
 				//	column += " DEFAULT " + fi.initial.String()
 				//}
+				
+				// Append attribute DEFAULT
+				column += getColumnDefault(fi)
 
 				if fi.unique {
 					column += " " + "UNIQUE"
@@ -239,3 +246,44 @@ func getDbCreateSql(al *alias) (sqls []string, tableIndexes map[string][]dbIndex
 
 	return
 }
+
+
+// Get string value for the attribute "DEFAULT" for the CREATE, ALTER commands
+func getColumnDefault(fi *fieldInfo) string {
+	var (
+		v, t, d string
+	)
+
+	// Skip default attribute if field is in relations
+	if fi.rel || fi.reverse {
+		return v
+	}
+
+	t = " DEFAULT '%s' "
+
+	// These defaults will be useful if there no config value orm:"default" and NOT NULL is on
+	switch fi.fieldType {
+		case TypeDateField, TypeDateTimeField:
+			return v;
+	
+		case TypeBooleanField, TypeBitField, TypeSmallIntegerField, TypeIntegerField,
+		TypeBigIntegerField, TypePositiveBitField, TypePositiveSmallIntegerField, 
+		TypePositiveIntegerField, TypePositiveBigIntegerField, TypeFloatField,
+		TypeDecimalField:
+			d = "0"
+	}
+	
+	if fi.colDefault {
+		if !fi.initial.Exist() {
+			v = fmt.Sprintf(t, "")
+		} else {
+			v = fmt.Sprintf(t, fi.initial.String())
+		}
+	} else {
+		if !fi.null {
+			v = fmt.Sprintf(t, d)
+		}
+	}
+
+	return v
+}

orm/db.go

@@ -44,6 +44,8 @@ var (
 		"gte":         true,
 		"lt":          true,
 		"lte":         true,
+		"eq":          true,
+		"nq":          true,
 		"startswith":  true,
 		"endswith":    true,
 		"istartswith": true,
@@ -122,6 +124,12 @@ func (d *dbBase) collectFieldValue(mi *modelInfo, fi *fieldInfo, ind reflect.Val
 					if nb.Valid {
 						value = nb.Bool
 					}
+				} else if field.Kind() == reflect.Ptr {
+					if field.IsNil() {
+						value = nil
+					} else {
+						value = field.Elem().Bool()
+					}
 				} else {
 					value = field.Bool()
 				}
@@ -131,6 +139,12 @@ func (d *dbBase) collectFieldValue(mi *modelInfo, fi *fieldInfo, ind reflect.Val
 					if ns.Valid {
 						value = ns.String
 					}
+				} else if field.Kind() == reflect.Ptr {
+					if field.IsNil() {
+						value = nil
+					} else {
+						value = field.Elem().String()
+					}
 				} else {
 					value = field.String()
 				}
@@ -140,6 +154,12 @@ func (d *dbBase) collectFieldValue(mi *modelInfo, fi *fieldInfo, ind reflect.Val
 					if nf.Valid {
 						value = nf.Float64
 					}
+				} else if field.Kind() == reflect.Ptr {
+					if field.IsNil() {
+						value = nil
+					} else {
+						value = field.Elem().Float()
+					}
 				} else {
 					vu := field.Interface()
 					if _, ok := vu.(float32); ok {
@@ -161,13 +181,27 @@ func (d *dbBase) collectFieldValue(mi *modelInfo, fi *fieldInfo, ind reflect.Val
 			default:
 				switch {
 				case fi.fieldType&IsPostiveIntegerField > 0:
-					value = field.Uint()
+					if field.Kind() == reflect.Ptr {
+						if field.IsNil() {
+							value = nil
+						} else {
+							value = field.Elem().Uint()
+						}
+					} else {
+						value = field.Uint()
+					}
 				case fi.fieldType&IsIntegerField > 0:
 					if ni, ok := field.Interface().(sql.NullInt64); ok {
 						value = nil
 						if ni.Valid {
 							value = ni.Int64
 						}
+					} else if field.Kind() == reflect.Ptr {
+						if field.IsNil() {
+							value = nil
+						} else {
+							value = field.Elem().Int()
+						}
 					} else {
 						value = field.Int()
 					}
@@ -292,7 +326,7 @@ func (d *dbBase) Read(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Lo
 	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)
 
 	refs := make([]interface{}, colsNum)
-	for i, _ := range refs {
+	for i := range refs {
 		var ref interface{}
 		refs[i] = &ref
 	}
@@ -391,7 +425,7 @@ func (d *dbBase) InsertValue(q dbQuerier, mi *modelInfo, isMulti bool, names []s
 	Q := d.ins.TableQuote()
 
 	marks := make([]string, len(names))
-	for i, _ := range marks {
+	for i := range marks {
 		marks[i] = "?"
 	}
 
@@ -661,7 +695,7 @@ func (d *dbBase) DeleteBatch(q dbQuerier, qs *querySet, mi *modelInfo, cond *Con
 	}
 
 	marks := make([]string, len(args))
-	for i, _ := range marks {
+	for i := range marks {
 		marks[i] = "?"
 	}
 	sql := fmt.Sprintf("IN (%s)", strings.Join(marks, ", "))
@@ -792,7 +826,7 @@ func (d *dbBase) ReadBatch(q dbQuerier, qs *querySet, mi *modelInfo, cond *Condi
 	}
 
 	refs := make([]interface{}, colsNum)
-	for i, _ := range refs {
+	for i := range refs {
 		var ref interface{}
 		refs[i] = &ref
 	}
@@ -932,7 +966,7 @@ func (d *dbBase) GenerateOperatorSql(mi *modelInfo, fi *fieldInfo, operator stri
 	switch operator {
 	case "in":
 		marks := make([]string, len(params))
-		for i, _ := range marks {
+		for i := range marks {
 			marks[i] = "?"
 		}
 		sql = fmt.Sprintf("IN (%s)", strings.Join(marks, ", "))
@@ -1177,6 +1211,11 @@ setValue:
 					nb.Valid = true
 				}
 				field.Set(reflect.ValueOf(nb))
+			} else if field.Kind() == reflect.Ptr {
+				if value != nil {
+					v := value.(bool)
+					field.Set(reflect.ValueOf(&v))
+				}
 			} else {
 				if value == nil {
 					value = false
@@ -1194,6 +1233,11 @@ setValue:
 					ns.Valid = true
 				}
 				field.Set(reflect.ValueOf(ns))
+			} else if field.Kind() == reflect.Ptr {
+				if value != nil {
+					v := value.(string)
+					field.Set(reflect.ValueOf(&v))
+				}
 			} else {
 				if value == nil {
 					value = ""
@@ -1208,6 +1252,56 @@ setValue:
 			}
 			field.Set(reflect.ValueOf(value))
 		}
+	case fieldType == TypePositiveBitField && field.Kind() == reflect.Ptr:
+		if value != nil {
+			v := uint8(value.(uint64))
+			field.Set(reflect.ValueOf(&v))
+		}
+	case fieldType == TypePositiveSmallIntegerField && field.Kind() == reflect.Ptr:
+		if value != nil {
+			v := uint16(value.(uint64))
+			field.Set(reflect.ValueOf(&v))
+		}
+	case fieldType == TypePositiveIntegerField && field.Kind() == reflect.Ptr:
+		if value != nil {
+			if field.Type() == reflect.TypeOf(new(uint)) {
+				v := uint(value.(uint64))
+				field.Set(reflect.ValueOf(&v))
+			} else {
+				v := uint32(value.(uint64))
+				field.Set(reflect.ValueOf(&v))
+			}
+		}
+	case fieldType == TypePositiveBigIntegerField && field.Kind() == reflect.Ptr:
+		if value != nil {
+			v := value.(uint64)
+			field.Set(reflect.ValueOf(&v))
+		}
+	case fieldType == TypeBitField && field.Kind() == reflect.Ptr:
+		if value != nil {
+			v := int8(value.(int64))
+			field.Set(reflect.ValueOf(&v))
+		}
+	case fieldType == TypeSmallIntegerField && field.Kind() == reflect.Ptr:
+		if value != nil {
+			v := int16(value.(int64))
+			field.Set(reflect.ValueOf(&v))
+		}
+	case fieldType == TypeIntegerField && field.Kind() == reflect.Ptr:
+		if value != nil {
+			if field.Type() == reflect.TypeOf(new(int)) {
+				v := int(value.(int64))
+				field.Set(reflect.ValueOf(&v))
+			} else {
+				v := int32(value.(int64))
+				field.Set(reflect.ValueOf(&v))
+			}
+		}
+	case fieldType == TypeBigIntegerField && field.Kind() == reflect.Ptr:
+		if value != nil {
+			v := value.(int64)
+			field.Set(reflect.ValueOf(&v))
+		}
 	case fieldType&IsIntegerField > 0:
 		if fieldType&IsPostiveIntegerField > 0 {
 			if isNative {
@@ -1244,6 +1338,16 @@ setValue:
 					nf.Valid = true
 				}
 				field.Set(reflect.ValueOf(nf))
+			} else if field.Kind() == reflect.Ptr {
+				if value != nil {
+					if field.Type() == reflect.TypeOf(new(float32)) {
+						v := float32(value.(float64))
+						field.Set(reflect.ValueOf(&v))
+					} else {
+						v := value.(float64)
+						field.Set(reflect.ValueOf(&v))
+					}
+				}
 			} else {
 
 				if value == nil {
@@ -1358,7 +1462,7 @@ func (d *dbBase) ReadValues(q dbQuerier, qs *querySet, mi *modelInfo, cond *Cond
 	}
 
 	refs := make([]interface{}, len(cols))
-	for i, _ := range refs {
+	for i := range refs {
 		var ref interface{}
 		refs[i] = &ref
 	}

orm/db_mysql.go

@@ -30,6 +30,8 @@ var mysqlOperators = map[string]string{
 	"gte":         ">= ?",
 	"lt":          "< ?",
 	"lte":         "<= ?",
+	"eq":          "= ?",
+	"ne":          "!= ?",
 	"startswith":  "LIKE BINARY ?",
 	"endswith":    "LIKE BINARY ?",
 	"istartswith": "LIKE ?",

orm/db_postgres.go

@@ -29,6 +29,8 @@ var postgresOperators = map[string]string{
 	"gte":         ">= ?",
 	"lt":          "< ?",
 	"lte":         "<= ?",
+	"eq":          "= ?",
+	"ne":          "!= ?",
 	"startswith":  "LIKE ?",
 	"endswith":    "LIKE ?",
 	"istartswith": "LIKE UPPER(?)",

orm/db_sqlite.go

@@ -29,6 +29,8 @@ var sqliteOperators = map[string]string{
 	"gte":         ">= ?",
 	"lt":          "< ?",
 	"lte":         "<= ?",
+	"eq":          "= ?",
+	"ne":          "!= ?",
 	"startswith":  "LIKE ? ESCAPE '\\'",
 	"endswith":    "LIKE ? ESCAPE '\\'",
 	"istartswith": "LIKE ? ESCAPE '\\'",

orm/models_info_f.go

@@ -116,6 +116,7 @@ type fieldInfo struct {
 	null                bool
 	index               bool
 	unique              bool
+	colDefault          bool
 	initial             StrTo
 	size                int
 	auto_now            bool
@@ -280,6 +281,11 @@ checkType:
 	fi.pk = attrs["pk"]
 	fi.unique = attrs["unique"]
 
+	// Mark object property if there is attribute "default" in the orm configuration
+	if _, ok := tags["default"]; ok {
+		fi.colDefault = true
+	}
+
 	switch fieldType {
 	case RelManyToMany, RelReverseMany, RelReverseOne:
 		fi.null = false

orm/models_test.go

@@ -155,6 +155,24 @@ type DataNull struct {
 	NullBool    sql.NullBool    `orm:"null"`
 	NullFloat64 sql.NullFloat64 `orm:"null"`
 	NullInt64   sql.NullInt64   `orm:"null"`
+	BooleanPtr  *bool           `orm:"null"`
+	CharPtr     *string         `orm:"null;size(50)"`
+	TextPtr     *string         `orm:"null;type(text)"`
+	BytePtr     *byte           `orm:"null"`
+	RunePtr     *rune           `orm:"null"`
+	IntPtr      *int            `orm:"null"`
+	Int8Ptr     *int8           `orm:"null"`
+	Int16Ptr    *int16          `orm:"null"`
+	Int32Ptr    *int32          `orm:"null"`
+	Int64Ptr    *int64          `orm:"null"`
+	UintPtr     *uint           `orm:"null"`
+	Uint8Ptr    *uint8          `orm:"null"`
+	Uint16Ptr   *uint16         `orm:"null"`
+	Uint32Ptr   *uint32         `orm:"null"`
+	Uint64Ptr   *uint64         `orm:"null"`
+	Float32Ptr  *float32        `orm:"null"`
+	Float64Ptr  *float64        `orm:"null"`
+	DecimalPtr  *float64        `orm:"digits(8);decimals(4);null"`
 }
 
 type String string
@@ -224,14 +242,14 @@ type User struct {
 
 func (u *User) TableIndex() [][]string {
 	return [][]string{
-		[]string{"Id", "UserName"},
-		[]string{"Id", "Created"},
+		{"Id", "UserName"},
+		{"Id", "Created"},
 	}
 }
 
 func (u *User) TableUnique() [][]string {
 	return [][]string{
-		[]string{"UserName", "Email"},
+		{"UserName", "Email"},
 	}
 }
 
@@ -269,7 +287,7 @@ type Post struct {
 
 func (u *Post) TableIndex() [][]string {
 	return [][]string{
-		[]string{"Id", "Created"},
+		{"Id", "Created"},
 	}
 }
 

orm/models_utils.go

@@ -111,45 +111,73 @@ func getColumnName(ft int, addrField reflect.Value, sf reflect.StructField, col
 
 // return field type as type constant from reflect.Value
 func getFieldType(val reflect.Value) (ft int, err error) {
-	elm := reflect.Indirect(val)
-	switch elm.Kind() {
-	case reflect.Int8:
+	switch val.Type() {
+	case reflect.TypeOf(new(int8)):
 		ft = TypeBitField
-	case reflect.Int16:
+	case reflect.TypeOf(new(int16)):
 		ft = TypeSmallIntegerField
-	case reflect.Int32, reflect.Int:
+	case reflect.TypeOf(new(int32)),
+		reflect.TypeOf(new(int)):
 		ft = TypeIntegerField
-	case reflect.Int64:
+	case reflect.TypeOf(new(int64)):
 		ft = TypeBigIntegerField
-	case reflect.Uint8:
+	case reflect.TypeOf(new(uint8)):
 		ft = TypePositiveBitField
-	case reflect.Uint16:
+	case reflect.TypeOf(new(uint16)):
 		ft = TypePositiveSmallIntegerField
-	case reflect.Uint32, reflect.Uint:
+	case reflect.TypeOf(new(uint32)),
+		reflect.TypeOf(new(uint)):
 		ft = TypePositiveIntegerField
-	case reflect.Uint64:
+	case reflect.TypeOf(new(uint64)):
 		ft = TypePositiveBigIntegerField
-	case reflect.Float32, reflect.Float64:
+	case reflect.TypeOf(new(float32)),
+		reflect.TypeOf(new(float64)):
 		ft = TypeFloatField
-	case reflect.Bool:
+	case reflect.TypeOf(new(bool)):
 		ft = TypeBooleanField
-	case reflect.String:
+	case reflect.TypeOf(new(string)):
 		ft = TypeCharField
 	default:
-		if elm.Interface() == nil {
-			panic(fmt.Errorf("%s is nil pointer, may be miss setting tag", val))
-		}
-		switch elm.Interface().(type) {
-		case sql.NullInt64:
+		elm := reflect.Indirect(val)
+		switch elm.Kind() {
+		case reflect.Int8:
+			ft = TypeBitField
+		case reflect.Int16:
+			ft = TypeSmallIntegerField
+		case reflect.Int32, reflect.Int:
+			ft = TypeIntegerField
+		case reflect.Int64:
 			ft = TypeBigIntegerField
-		case sql.NullFloat64:
+		case reflect.Uint8:
+			ft = TypePositiveBitField
+		case reflect.Uint16:
+			ft = TypePositiveSmallIntegerField
+		case reflect.Uint32, reflect.Uint:
+			ft = TypePositiveIntegerField
+		case reflect.Uint64:
+			ft = TypePositiveBigIntegerField
+		case reflect.Float32, reflect.Float64:
 			ft = TypeFloatField
-		case sql.NullBool:
+		case reflect.Bool:
 			ft = TypeBooleanField
-		case sql.NullString:
+		case reflect.String:
 			ft = TypeCharField
-		case time.Time:
-			ft = TypeDateTimeField
+		default:
+			if elm.Interface() == nil {
+				panic(fmt.Errorf("%s is nil pointer, may be miss setting tag", val))
+			}
+			switch elm.Interface().(type) {
+			case sql.NullInt64:
+				ft = TypeBigIntegerField
+			case sql.NullFloat64:
+				ft = TypeFloatField
+			case sql.NullBool:
+				ft = TypeBooleanField
+			case sql.NullString:
+				ft = TypeCharField
+			case time.Time:
+				ft = TypeDateTimeField
+			}
 		}
 	}
 	if ft&IsFieldType == 0 {

orm/orm.go

@@ -489,10 +489,6 @@ func (o *orm) Driver() Driver {
 	return driver(o.alias.Name)
 }
 
-func (o *orm) GetDB() dbQuerier {
-	panic(ErrNotImplement)
-}
-
 // create new orm
 func NewOrm() Ormer {
 	BootStrap() // execute only once

orm/orm_queryset.go

@@ -115,23 +115,21 @@ func (o querySet) OrderBy(exprs ...string) QuerySeter {
 // set relation model to query together.
 // it will query relation models and assign to parent model.
 func (o querySet) RelatedSel(params ...interface{}) QuerySeter {
-	var related []string
-	if len(params) == 0 {
-		o.relDepth = DefaultRelsDepth
-	} else {
-		for _, p := range params {
-			switch val := p.(type) {
-			case string:
-				related = append(o.related, val)
-			case int:
-				o.relDepth = val
-			default:
-				panic(fmt.Errorf("<QuerySeter.RelatedSel> wrong param kind: %v", val))
-			}
-		}
-	}
-	o.related = related
-	return &o
+    if len(params) == 0 {
+        o.relDepth = DefaultRelsDepth
+    } else {
+        for _, p := range params {
+            switch val := p.(type) {
+            case string:
+                o.related = append(o.related, val)
+            case int:
+                o.relDepth = val
+            default:
+                panic(fmt.Errorf("<QuerySeter.RelatedSel> wrong param kind: %v", val))
+            }
+        }
+    }
+    return &o
 }
 
 // set condition to QuerySeter.

orm/orm_raw.go

@@ -585,7 +585,7 @@ func (o *rawSet) readValues(container interface{}, needCols []string) (int64, er
 
 				cols = columns
 				refs = make([]interface{}, len(cols))
-				for i, _ := range refs {
+				for i := range refs {
 					var ref sql.NullString
 					refs[i] = &ref
 
@@ -711,7 +711,7 @@ func (o *rawSet) queryRowsTo(container interface{}, keyCol, valueCol string) (in
 			} else {
 				cols = columns
 				refs = make([]interface{}, len(cols))
-				for i, _ := range refs {
+				for i := range refs {
 					if keyCol == cols[i] {
 						keyIndex = i
 					}

orm/orm_test.go

@@ -287,6 +287,25 @@ func TestNullDataTypes(t *testing.T) {
 	throwFail(t, AssertIs(d.NullInt64.Valid, false))
 	throwFail(t, AssertIs(d.NullFloat64.Valid, false))
 
+	throwFail(t, AssertIs(d.BooleanPtr, nil))
+	throwFail(t, AssertIs(d.CharPtr, nil))
+	throwFail(t, AssertIs(d.TextPtr, nil))
+	throwFail(t, AssertIs(d.BytePtr, nil))
+	throwFail(t, AssertIs(d.RunePtr, nil))
+	throwFail(t, AssertIs(d.IntPtr, nil))
+	throwFail(t, AssertIs(d.Int8Ptr, nil))
+	throwFail(t, AssertIs(d.Int16Ptr, nil))
+	throwFail(t, AssertIs(d.Int32Ptr, nil))
+	throwFail(t, AssertIs(d.Int64Ptr, nil))
+	throwFail(t, AssertIs(d.UintPtr, nil))
+	throwFail(t, AssertIs(d.Uint8Ptr, nil))
+	throwFail(t, AssertIs(d.Uint16Ptr, nil))
+	throwFail(t, AssertIs(d.Uint32Ptr, nil))
+	throwFail(t, AssertIs(d.Uint64Ptr, nil))
+	throwFail(t, AssertIs(d.Float32Ptr, nil))
+	throwFail(t, AssertIs(d.Float64Ptr, nil))
+	throwFail(t, AssertIs(d.DecimalPtr, nil))
+
 	_, err = dORM.Raw(`INSERT INTO data_null (boolean) VALUES (?)`, nil).Exec()
 	throwFail(t, err)
 
@@ -294,12 +313,49 @@ func TestNullDataTypes(t *testing.T) {
 	err = dORM.Read(&d)
 	throwFail(t, err)
 
+	booleanPtr := true
+	charPtr := string("test")
+	textPtr := string("test")
+	bytePtr := byte('t')
+	runePtr := rune('t')
+	intPtr := int(42)
+	int8Ptr := int8(42)
+	int16Ptr := int16(42)
+	int32Ptr := int32(42)
+	int64Ptr := int64(42)
+	uintPtr := uint(42)
+	uint8Ptr := uint8(42)
+	uint16Ptr := uint16(42)
+	uint32Ptr := uint32(42)
+	uint64Ptr := uint64(42)
+	float32Ptr := float32(42.0)
+	float64Ptr := float64(42.0)
+	decimalPtr := float64(42.0)
+
 	d = DataNull{
 		DateTime:    time.Now(),
 		NullString:  sql.NullString{String: "test", Valid: true},
 		NullBool:    sql.NullBool{Bool: true, Valid: true},
 		NullInt64:   sql.NullInt64{Int64: 42, Valid: true},
 		NullFloat64: sql.NullFloat64{Float64: 42.42, Valid: true},
+		BooleanPtr:  &booleanPtr,
+		CharPtr:     &charPtr,
+		TextPtr:     &textPtr,
+		BytePtr:     &bytePtr,
+		RunePtr:     &runePtr,
+		IntPtr:      &intPtr,
+		Int8Ptr:     &int8Ptr,
+		Int16Ptr:    &int16Ptr,
+		Int32Ptr:    &int32Ptr,
+		Int64Ptr:    &int64Ptr,
+		UintPtr:     &uintPtr,
+		Uint8Ptr:    &uint8Ptr,
+		Uint16Ptr:   &uint16Ptr,
+		Uint32Ptr:   &uint32Ptr,
+		Uint64Ptr:   &uint64Ptr,
+		Float32Ptr:  &float32Ptr,
+		Float64Ptr:  &float64Ptr,
+		DecimalPtr:  &decimalPtr,
 	}
 
 	id, err = dORM.Insert(&d)
@@ -321,6 +377,25 @@ func TestNullDataTypes(t *testing.T) {
 
 	throwFail(t, AssertIs(d.NullFloat64.Valid, true))
 	throwFail(t, AssertIs(d.NullFloat64.Float64, 42.42))
+
+	throwFail(t, AssertIs(*d.BooleanPtr, booleanPtr))
+	throwFail(t, AssertIs(*d.CharPtr, charPtr))
+	throwFail(t, AssertIs(*d.TextPtr, textPtr))
+	throwFail(t, AssertIs(*d.BytePtr, bytePtr))
+	throwFail(t, AssertIs(*d.RunePtr, runePtr))
+	throwFail(t, AssertIs(*d.IntPtr, intPtr))
+	throwFail(t, AssertIs(*d.Int8Ptr, int8Ptr))
+	throwFail(t, AssertIs(*d.Int16Ptr, int16Ptr))
+	throwFail(t, AssertIs(*d.Int32Ptr, int32Ptr))
+	throwFail(t, AssertIs(*d.Int64Ptr, int64Ptr))
+	throwFail(t, AssertIs(*d.UintPtr, uintPtr))
+	throwFail(t, AssertIs(*d.Uint8Ptr, uint8Ptr))
+	throwFail(t, AssertIs(*d.Uint16Ptr, uint16Ptr))
+	throwFail(t, AssertIs(*d.Uint32Ptr, uint32Ptr))
+	throwFail(t, AssertIs(*d.Uint64Ptr, uint64Ptr))
+	throwFail(t, AssertIs(*d.Float32Ptr, float32Ptr))
+	throwFail(t, AssertIs(*d.Float64Ptr, float64Ptr))
+	throwFail(t, AssertIs(*d.DecimalPtr, decimalPtr))
 }
 
 func TestDataCustomTypes(t *testing.T) {
@@ -511,29 +586,29 @@ func TestInsertTestData(t *testing.T) {
 	throwFail(t, AssertIs(id, 4))
 
 	tags := []*Tag{
-		&Tag{Name: "golang", BestPost: &Post{Id: 2}},
-		&Tag{Name: "example"},
-		&Tag{Name: "format"},
-		&Tag{Name: "c++"},
+		{Name: "golang", BestPost: &Post{Id: 2}},
+		{Name: "example"},
+		{Name: "format"},
+		{Name: "c++"},
 	}
 
 	posts := []*Post{
-		&Post{User: users[0], Tags: []*Tag{tags[0]}, Title: "Introduction", Content: `Go is a new language. Although it borrows ideas from existing languages, it has unusual properties that make effective Go programs different in character from programs written in its relatives. A straightforward translation of a C++ or Java program into Go is unlikely to produce a satisfactory result—Java programs are written in Java, not Go. On the other hand, thinking about the problem from a Go perspective could produce a successful but quite different program. In other words, to write Go well, it's important to understand its properties and idioms. It's also important to know the established conventions for programming in Go, such as naming, formatting, program construction, and so on, so that programs you write will be easy for other Go programmers to understand.
+		{User: users[0], Tags: []*Tag{tags[0]}, Title: "Introduction", Content: `Go is a new language. Although it borrows ideas from existing languages, it has unusual properties that make effective Go programs different in character from programs written in its relatives. A straightforward translation of a C++ or Java program into Go is unlikely to produce a satisfactory result—Java programs are written in Java, not Go. On the other hand, thinking about the problem from a Go perspective could produce a successful but quite different program. In other words, to write Go well, it's important to understand its properties and idioms. It's also important to know the established conventions for programming in Go, such as naming, formatting, program construction, and so on, so that programs you write will be easy for other Go programmers to understand.
 This document gives tips for writing clear, idiomatic Go code. It augments the language specification, the Tour of Go, and How to Write Go Code, all of which you should read first.`},
-		&Post{User: users[1], Tags: []*Tag{tags[0], tags[1]}, Title: "Examples", Content: `The Go package sources are intended to serve not only as the core library but also as examples of how to use the language. Moreover, many of the packages contain working, self-contained executable examples you can run directly from the golang.org web site, such as this one (click on the word "Example" to open it up). If you have a question about how to approach a problem or how something might be implemented, the documentation, code and examples in the library can provide answers, ideas and background.`},
-		&Post{User: users[1], Tags: []*Tag{tags[0], tags[2]}, Title: "Formatting", Content: `Formatting issues are the most contentious but the least consequential. People can adapt to different formatting styles but it's better if they don't have to, and less time is devoted to the topic if everyone adheres to the same style. The problem is how to approach this Utopia without a long prescriptive style guide.
+		{User: users[1], Tags: []*Tag{tags[0], tags[1]}, Title: "Examples", Content: `The Go package sources are intended to serve not only as the core library but also as examples of how to use the language. Moreover, many of the packages contain working, self-contained executable examples you can run directly from the golang.org web site, such as this one (click on the word "Example" to open it up). If you have a question about how to approach a problem or how something might be implemented, the documentation, code and examples in the library can provide answers, ideas and background.`},
+		{User: users[1], Tags: []*Tag{tags[0], tags[2]}, Title: "Formatting", Content: `Formatting issues are the most contentious but the least consequential. People can adapt to different formatting styles but it's better if they don't have to, and less time is devoted to the topic if everyone adheres to the same style. The problem is how to approach this Utopia without a long prescriptive style guide.
 With Go we take an unusual approach and let the machine take care of most formatting issues. The gofmt program (also available as go fmt, which operates at the package level rather than source file level) reads a Go program and emits the source in a standard style of indentation and vertical alignment, retaining and if necessary reformatting comments. If you want to know how to handle some new layout situation, run gofmt; if the answer doesn't seem right, rearrange your program (or file a bug about gofmt), don't work around it.`},
-		&Post{User: users[2], Tags: []*Tag{tags[3]}, Title: "Commentary", Content: `Go provides C-style /* */ block comments and C++-style // line comments. Line comments are the norm; block comments appear mostly as package comments, but are useful within an expression or to disable large swaths of code.
+		{User: users[2], Tags: []*Tag{tags[3]}, Title: "Commentary", Content: `Go provides C-style /* */ block comments and C++-style // line comments. Line comments are the norm; block comments appear mostly as package comments, but are useful within an expression or to disable large swaths of code.
 The program—and web server—godoc processes Go source files to extract documentation about the contents of the package. Comments that appear before top-level declarations, with no intervening newlines, are extracted along with the declaration to serve as explanatory text for the item. The nature and style of these comments determines the quality of the documentation godoc produces.`},
 	}
 
 	comments := []*Comment{
-		&Comment{Post: posts[0], Content: "a comment"},
-		&Comment{Post: posts[1], Content: "yes"},
-		&Comment{Post: posts[1]},
-		&Comment{Post: posts[1]},
-		&Comment{Post: posts[2]},
-		&Comment{Post: posts[2]},
+		{Post: posts[0], Content: "a comment"},
+		{Post: posts[1], Content: "yes"},
+		{Post: posts[1]},
+		{Post: posts[1]},
+		{Post: posts[2]},
+		{Post: posts[2]},
 	}
 
 	for _, tag := range tags {
@@ -1173,7 +1248,7 @@ func TestQueryM2M(t *testing.T) {
 	post := Post{Id: 4}
 	m2m := dORM.QueryM2M(&post, "Tags")
 
-	tag1 := []*Tag{&Tag{Name: "TestTag1"}, &Tag{Name: "TestTag2"}}
+	tag1 := []*Tag{{Name: "TestTag1"}, {Name: "TestTag2"}}
 	tag2 := &Tag{Name: "TestTag3"}
 	tag3 := []interface{}{&Tag{Name: "TestTag4"}}
 
@@ -1236,7 +1311,7 @@ func TestQueryM2M(t *testing.T) {
 
 	m2m = dORM.QueryM2M(&tag, "Posts")
 
-	post1 := []*Post{&Post{Title: "TestPost1"}, &Post{Title: "TestPost2"}}
+	post1 := []*Post{{Title: "TestPost1"}, {Title: "TestPost2"}}
 	post2 := &Post{Title: "TestPost3"}
 	post3 := []interface{}{&Post{Title: "TestPost4"}}
 

orm/qb.go

@@ -0,0 +1,57 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package orm
+
+import "errors"
+
+type QueryBuilder interface {
+	Select(fields ...string) QueryBuilder
+	From(tables ...string) QueryBuilder
+	InnerJoin(table string) QueryBuilder
+	LeftJoin(table string) QueryBuilder
+	RightJoin(table string) QueryBuilder
+	On(cond string) QueryBuilder
+	Where(cond string) QueryBuilder
+	And(cond string) QueryBuilder
+	Or(cond string) QueryBuilder
+	In(vals ...string) QueryBuilder
+	OrderBy(fields ...string) QueryBuilder
+	Asc() QueryBuilder
+	Desc() QueryBuilder
+	Limit(limit int) QueryBuilder
+	Offset(offset int) QueryBuilder
+	GroupBy(fields ...string) QueryBuilder
+	Having(cond string) QueryBuilder
+	Update(tables ...string) QueryBuilder
+	Set(kv ...string) QueryBuilder
+	Delete(tables ...string) QueryBuilder
+	InsertInto(table string, fields ...string) QueryBuilder
+	Values(vals ...string) QueryBuilder
+	Subquery(sub string, alias string) string
+	String() string
+}
+
+func NewQueryBuilder(driver string) (qb QueryBuilder, err error) {
+	if driver == "mysql" {
+		qb = new(MySQLQueryBuilder)
+	} else if driver == "postgres" {
+		err = errors.New("postgres query builder is not supported yet!")
+	} else if driver == "sqlite" {
+		err = errors.New("sqlite query builder is not supported yet!")
+	} else {
+		err = errors.New("unknown driver for query builder!")
+	}
+	return
+}

orm/qb_mysql.go

@@ -0,0 +1,153 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package orm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const COMMA_SPACE = ", "
+
+type MySQLQueryBuilder struct {
+	Tokens []string
+}
+
+func (qb *MySQLQueryBuilder) Select(fields ...string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "SELECT", strings.Join(fields, COMMA_SPACE))
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) From(tables ...string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "FROM", strings.Join(tables, COMMA_SPACE))
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) InnerJoin(table string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "INNER JOIN", table)
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) LeftJoin(table string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "LEFT JOIN", table)
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) RightJoin(table string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "RIGHT JOIN", table)
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) On(cond string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "ON", cond)
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Where(cond string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "WHERE", cond)
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) And(cond string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "AND", cond)
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Or(cond string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "OR", cond)
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) In(vals ...string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "IN", "(", strings.Join(vals, COMMA_SPACE), ")")
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) OrderBy(fields ...string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "ORDER BY", strings.Join(fields, COMMA_SPACE))
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Asc() QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "ASC")
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Desc() QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "DESC")
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Limit(limit int) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "LIMIT", strconv.Itoa(limit))
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Offset(offset int) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "OFFSET", strconv.Itoa(offset))
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) GroupBy(fields ...string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "GROUP BY", strings.Join(fields, COMMA_SPACE))
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Having(cond string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "HAVING", cond)
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Update(tables ...string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "UPDATE", strings.Join(tables, COMMA_SPACE))
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Set(kv ...string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "SET", strings.Join(kv, COMMA_SPACE))
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Delete(tables ...string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "DELETE")
+	if len(tables) != 0 {
+		qb.Tokens = append(qb.Tokens, strings.Join(tables, COMMA_SPACE))
+	}
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) InsertInto(table string, fields ...string) QueryBuilder {
+	qb.Tokens = append(qb.Tokens, "INSERT INTO", table)
+	if len(fields) != 0 {
+		fieldsStr := strings.Join(fields, COMMA_SPACE)
+		qb.Tokens = append(qb.Tokens, "(", fieldsStr, ")")
+	}
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Values(vals ...string) QueryBuilder {
+	valsStr := strings.Join(vals, COMMA_SPACE)
+	qb.Tokens = append(qb.Tokens, "VALUES", "(", valsStr, ")")
+	return qb
+}
+
+func (qb *MySQLQueryBuilder) Subquery(sub string, alias string) string {
+	return fmt.Sprintf("(%s) AS %s", sub, alias)
+}
+
+func (qb *MySQLQueryBuilder) String() string {
+	return strings.Join(qb.Tokens, " ")
+}

orm/types.go

@@ -51,7 +51,6 @@ type Ormer interface {
 	Rollback() error
 	Raw(string, ...interface{}) RawSeter
 	Driver() Driver
-	GetDB() dbQuerier
 }
 
 // insert prepared statement

orm/utils.go

@@ -195,7 +195,7 @@ func snakeString(s string) string {
 		}
 		data = append(data, d)
 	}
-	return strings.ToLower(string(data[:len(data)]))
+	return strings.ToLower(string(data[:]))
 }
 
 // camel string, xx_yy to XxYy
@@ -220,7 +220,7 @@ func camelString(s string) string {
 		}
 		data = append(data, d)
 	}
-	return string(data[:len(data)])
+	return string(data[:])
 }
 
 type argString []string

parser.go

@@ -24,6 +24,7 @@ import (
 	"io/ioutil"
 	"os"
 	"path"
+	"sort"
 	"strings"
 
 	"github.com/astaxie/beego/utils"
@@ -36,26 +37,31 @@ import (
 )
 
 func init() {
-	{{.globalinfo}}
+{{.globalinfo}}
 }
 `
 
 var (
 	lastupdateFilename string = "lastupdate.tmp"
+	commentFilename    string
 	pkgLastupdate      map[string]int64
 	genInfoList        map[string][]ControllerComments
 )
 
+const COMMENTFL = "commentsRouter_"
+
 func init() {
 	pkgLastupdate = make(map[string]int64)
-	genInfoList = make(map[string][]ControllerComments)
 }
 
 func parserPkg(pkgRealpath, pkgpath string) error {
+	rep := strings.NewReplacer("/", "_", ".", "_")
+	commentFilename = COMMENTFL + rep.Replace(pkgpath) + ".go"
 	if !compareFile(pkgRealpath) {
-		Info(pkgRealpath + " don't has updated")
+		Info(pkgRealpath + " has not changed, not reloading")
 		return nil
 	}
+	genInfoList = make(map[string][]ControllerComments)
 	fileSet := token.NewFileSet()
 	astPkgs, err := parser.ParseDir(fileSet, pkgRealpath, func(info os.FileInfo) bool {
 		name := info.Name()
@@ -124,7 +130,13 @@ func genRouterCode() {
 	os.Mkdir(path.Join(workPath, "routers"), 0755)
 	Info("generate router from comments")
 	var globalinfo string
-	for k, cList := range genInfoList {
+	sortKey := make([]string, 0)
+	for k, _ := range genInfoList {
+		sortKey = append(sortKey, k)
+	}
+	sort.Strings(sortKey)
+	for _, k := range sortKey {
+		cList := genInfoList[k]
 		for _, c := range cList {
 			allmethod := "nil"
 			if len(c.AllowHTTPMethods) > 0 {
@@ -148,14 +160,14 @@ func genRouterCode() {
 	beego.GlobalControllerRouter["` + k + `"] = append(beego.GlobalControllerRouter["` + k + `"],
 		beego.ControllerComments{
 			"` + strings.TrimSpace(c.Method) + `",
-			"` + c.Router + `",
+			` + "`" + c.Router + "`" + `,
 			` + allmethod + `,
 			` + params + `})
 `
 		}
 	}
 	if globalinfo != "" {
-		f, err := os.Create(path.Join(workPath, "routers", "commentsRouter.go"))
+		f, err := os.Create(path.Join(workPath, "routers", commentFilename))
 		if err != nil {
 			panic(err)
 		}
@@ -165,7 +177,7 @@ func genRouterCode() {
 }
 
 func compareFile(pkgRealpath string) bool {
-	if !utils.FileExists(path.Join(workPath, "routers", "commentsRouter.go")) {
+	if !utils.FileExists(path.Join(workPath, "routers", commentFilename)) {
 		return true
 	}
 	if utils.FileExists(path.Join(workPath, lastupdateFilename)) {

plugins/apiauth/apiauth.go

@@ -0,0 +1,176 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package apiauth provides handlers to enable apiauth support.
+//
+// Simple Usage:
+//	import(
+//		"github.com/astaxie/beego"
+//		"github.com/astaxie/beego/plugins/apiauth"
+//	)
+//
+//	func main(){
+//		// apiauth every request
+//		beego.InsertFilter("*", beego.BeforeRouter,apiauth.APIBaiscAuth("appid","appkey"))
+//		beego.Run()
+//	}
+//
+// Advanced Usage:
+//
+//	func getAppSecret(appid string) string {
+//		// get appsecret by appid
+//		// maybe store in configure, maybe in database
+//	}
+//
+//	beego.InsertFilter("*", beego.BeforeRouter,apiauth.APIAuthWithFunc(getAppSecret, 360))
+//
+// Infomation:
+//
+// In the request user should include these params in the query
+//
+// 1. appid
+//
+//		 appid is asigned to the application
+//
+// 2. signature
+//
+//	get the signature use apiauth.Signature()
+//
+//	when you send to server remember use url.QueryEscape()
+//
+// 3. timestamp:
+//
+//       send the request time, the format is yyyy-mm-dd HH:ii:ss
+//
+package apiauth
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"fmt"
+	"net/url"
+	"sort"
+	"time"
+
+	"github.com/astaxie/beego"
+	"github.com/astaxie/beego/context"
+)
+
+type AppIdToAppSecret func(string) string
+
+func APIBaiscAuth(appid, appkey string) beego.FilterFunc {
+	ft := func(aid string) string {
+		if aid == appid {
+			return appkey
+		}
+		return ""
+	}
+	return APIAuthWithFunc(ft, 300)
+}
+
+func APIAuthWithFunc(f AppIdToAppSecret, timeout int) beego.FilterFunc {
+	return func(ctx *context.Context) {
+		if ctx.Input.Query("appid") == "" {
+			ctx.Output.SetStatus(403)
+			ctx.WriteString("miss query param: appid")
+			return
+		}
+		appsecret := f(ctx.Input.Query("appid"))
+		if appsecret == "" {
+			ctx.Output.SetStatus(403)
+			ctx.WriteString("not exist this appid")
+			return
+		}
+		if ctx.Input.Query("signature") == "" {
+			ctx.Output.SetStatus(403)
+			ctx.WriteString("miss query param: signature")
+			return
+		}
+		if ctx.Input.Query("timestamp") == "" {
+			ctx.Output.SetStatus(403)
+			ctx.WriteString("miss query param: timestamp")
+			return
+		}
+		u, err := time.Parse("2006-01-02 15:04:05", ctx.Input.Query("timestamp"))
+		if err != nil {
+			ctx.Output.SetStatus(403)
+			ctx.WriteString("timestamp format is error, should 2006-01-02 15:04:05")
+			return
+		}
+		t := time.Now()
+		if t.Sub(u).Seconds() > float64(timeout) {
+			ctx.Output.SetStatus(403)
+			ctx.WriteString("timeout! the request time is long ago, please try again")
+			return
+		}
+		if ctx.Input.Query("signature") !=
+			Signature(appsecret, ctx.Input.Method(), ctx.Request.Form, ctx.Input.Uri()) {
+			ctx.Output.SetStatus(403)
+			ctx.WriteString("auth failed")
+		}
+	}
+}
+
+func Signature(appsecret, method string, params url.Values, RequestURI string) (result string) {
+	var query string
+	pa := make(map[string]string)
+	for k, v := range params {
+		pa[k] = v[0]
+	}
+	vs := mapSorter(pa)
+	vs.Sort()
+	for i := 0; i < vs.Len(); i++ {
+		if vs.Keys[i] == "signature" {
+			continue
+		}
+		if vs.Keys[i] != "" && vs.Vals[i] != "" {
+			query = fmt.Sprintf("%v%v%v", query, vs.Keys[i], vs.Vals[i])
+		}
+	}
+	string_to_sign := fmt.Sprintf("%v\n%v\n%v\n", method, query, RequestURI)
+
+	sha256 := sha256.New
+	hash := hmac.New(sha256, []byte(appsecret))
+	hash.Write([]byte(string_to_sign))
+	return base64.StdEncoding.EncodeToString(hash.Sum(nil))
+}
+
+type valSorter struct {
+	Keys []string
+	Vals []string
+}
+
+func mapSorter(m map[string]string) *valSorter {
+	vs := &valSorter{
+		Keys: make([]string, 0, len(m)),
+		Vals: make([]string, 0, len(m)),
+	}
+	for k, v := range m {
+		vs.Keys = append(vs.Keys, k)
+		vs.Vals = append(vs.Vals, v)
+	}
+	return vs
+}
+
+func (vs *valSorter) Sort() {
+	sort.Sort(vs)
+}
+
+func (vs *valSorter) Len() int           { return len(vs.Keys) }
+func (vs *valSorter) Less(i, j int) bool { return vs.Keys[i] < vs.Keys[j] }
+func (vs *valSorter) Swap(i, j int) {
+	vs.Vals[i], vs.Vals[j] = vs.Vals[j], vs.Vals[i]
+	vs.Keys[i], vs.Keys[j] = vs.Keys[j], vs.Keys[i]
+}

plugins/auth/basic.go

@@ -27,6 +27,7 @@
 //
 //
 // Advanced Usage:
+//
 //	func SecretAuth(username, password string) bool {
 //		return username == "astaxie" && password == "helloBeego"
 //	}

plugins/cors/cors.go

@@ -217,6 +217,7 @@ func Allow(opts *Options) beego.FilterFunc {
 				ctx.Output.Header(key, value)
 			}
 			ctx.Output.SetStatus(http.StatusOK)
+			ctx.WriteString("")
 			return
 		}
 		headers = opts.Header(origin)

router.go

@@ -30,7 +30,6 @@ import (
 	"time"
 
 	beecontext "github.com/astaxie/beego/context"
-	"github.com/astaxie/beego/middleware"
 	"github.com/astaxie/beego/toolbox"
 	"github.com/astaxie/beego/utils"
 )
@@ -72,9 +71,31 @@ var (
 		"SetSecureCookie", "XsrfToken", "CheckXsrfCookie", "XsrfFormHtml",
 		"GetControllerAndAction"}
 
-	url_placeholder = "{{placeholder}}"
+	url_placeholder                = "{{placeholder}}"
+	DefaultLogFilter FilterHandler = &logFilter{}
 )
 
+type FilterHandler interface {
+	Filter(*beecontext.Context) bool
+}
+
+// default log filter static file will not show
+type logFilter struct {
+}
+
+func (l *logFilter) Filter(ctx *beecontext.Context) bool {
+	requestPath := path.Clean(ctx.Input.Request.URL.Path)
+	if requestPath == "/favicon.ico" || requestPath == "/robots.txt" {
+		return true
+	}
+	for prefix := range StaticDir {
+		if strings.HasPrefix(requestPath, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
 // To append a slice's value into "exceptMethod", for controller's methods shouldn't reflect to AutoRouter
 func ExceptMethodAppend(action string) {
 	exceptMethod = append(exceptMethod, action)
@@ -131,7 +152,7 @@ func (p *ControllerRegistor) Add(pattern string, c ControllerInterface, mappingM
 					if val := reflectVal.MethodByName(colon[1]); val.IsValid() {
 						methods[strings.ToUpper(m)] = colon[1]
 					} else {
-						panic(colon[1] + " method doesn't exist in the controller " + t.Name())
+						panic("'" + colon[1] + "' method doesn't exist in the controller " + t.Name())
 					}
 				} else {
 					panic(v + " is an invalid method mapping. Method doesn't exist " + m)
@@ -150,7 +171,7 @@ func (p *ControllerRegistor) Add(pattern string, c ControllerInterface, mappingM
 			p.addToRouter(m, pattern, route)
 		}
 	} else {
-		for k, _ := range methods {
+		for k := range methods {
 			if k == "*" {
 				for _, m := range HTTPMETHOD {
 					p.addToRouter(m, pattern, route)
@@ -163,6 +184,9 @@ func (p *ControllerRegistor) Add(pattern string, c ControllerInterface, mappingM
 }
 
 func (p *ControllerRegistor) addToRouter(method, pattern string, r *controllerInfo) {
+	if !RouterCaseSensitive {
+		pattern = strings.ToLower(pattern)
+	}
 	if t, ok := p.routers[method]; ok {
 		t.AddRouter(pattern, r)
 	} else {
@@ -308,7 +332,7 @@ func (p *ControllerRegistor) AddMethod(method, pattern string, f FilterFunc) {
 		methods[strings.ToUpper(method)] = strings.ToUpper(method)
 	}
 	route.methods = methods
-	for k, _ := range methods {
+	for k := range methods {
 		if k == "*" {
 			for _, m := range HTTPMETHOD {
 				p.addToRouter(m, pattern, route)
@@ -376,11 +400,21 @@ func (p *ControllerRegistor) AddAutoPrefix(prefix string, c ControllerInterface)
 }
 
 // Add a FilterFunc with pattern rule and action constant.
-func (p *ControllerRegistor) InsertFilter(pattern string, pos int, filter FilterFunc) error {
+// The bool params is for setting the returnOnOutput value (false allows multiple filters to execute)
+func (p *ControllerRegistor) InsertFilter(pattern string, pos int, filter FilterFunc, params ...bool) error {
+
 	mr := new(FilterRouter)
 	mr.tree = NewTree()
 	mr.pattern = pattern
 	mr.filterFunc = filter
+	if !RouterCaseSensitive {
+		pattern = strings.ToLower(pattern)
+	}
+	if len(params) == 0 {
+		mr.returnOnOutput = true
+	} else {
+		mr.returnOnOutput = params[0]
+	}
 	mr.tree.AddRouter(pattern, true)
 	return p.insertFilterRouter(pos, mr)
 }
@@ -394,7 +428,7 @@ func (p *ControllerRegistor) insertFilterRouter(pos int, mr *FilterRouter) error
 
 // UrlFor does another controller handler in this request function.
 // it can access any controller method.
-func (p *ControllerRegistor) UrlFor(endpoint string, values ...string) string {
+func (p *ControllerRegistor) UrlFor(endpoint string, values ...interface{}) string {
 	paths := strings.Split(endpoint, ".")
 	if len(paths) <= 1 {
 		Warn("urlfor endpoint must like path.controller.method")
@@ -409,16 +443,16 @@ func (p *ControllerRegistor) UrlFor(endpoint string, values ...string) string {
 		key := ""
 		for k, v := range values {
 			if k%2 == 0 {
-				key = v
+				key = fmt.Sprint(v)
 			} else {
-				params[key] = v
+				params[key] = fmt.Sprint(v)
 			}
 		}
 	}
-	controllName := strings.Join(paths[:len(paths)-1], ".")
+	controllName := strings.Join(paths[:len(paths)-1], "/")
 	methodName := paths[len(paths)-1]
-	for _, t := range p.routers {
-		ok, url := p.geturl(t, "/", controllName, methodName, params)
+	for m, t := range p.routers {
+		ok, url := p.geturl(t, "/", controllName, methodName, params, m)
 		if ok {
 			return url
 		}
@@ -426,24 +460,25 @@ func (p *ControllerRegistor) UrlFor(endpoint string, values ...string) string {
 	return ""
 }
 
-func (p *ControllerRegistor) geturl(t *Tree, url, controllName, methodName string, params map[string]string) (bool, string) {
+func (p *ControllerRegistor) geturl(t *Tree, url, controllName, methodName string, params map[string]string, httpMethod string) (bool, string) {
 	for k, subtree := range t.fixrouters {
 		u := path.Join(url, k)
-		ok, u := p.geturl(subtree, u, controllName, methodName, params)
+		ok, u := p.geturl(subtree, u, controllName, methodName, params, httpMethod)
 		if ok {
 			return ok, u
 		}
 	}
 	if t.wildcard != nil {
-		url = path.Join(url, url_placeholder)
-		ok, u := p.geturl(t.wildcard, url, controllName, methodName, params)
+		u := path.Join(url, url_placeholder)
+		ok, u := p.geturl(t.wildcard, u, controllName, methodName, params, httpMethod)
 		if ok {
 			return ok, u
 		}
 	}
 	for _, l := range t.leaves {
 		if c, ok := l.runObject.(*controllerInfo); ok {
-			if c.routerType == routerTypeBeego && c.controllerType.Name() == controllName {
+			if c.routerType == routerTypeBeego &&
+				strings.HasSuffix(path.Join(c.controllerType.PkgPath(), c.controllerType.Name()), controllName) {
 				find := false
 				if _, ok := HTTPMETHOD[strings.ToUpper(methodName)]; ok {
 					if len(c.methods) == 0 {
@@ -455,8 +490,8 @@ func (p *ControllerRegistor) geturl(t *Tree, url, controllName, methodName strin
 					}
 				}
 				if !find {
-					for _, md := range c.methods {
-						if md == methodName {
+					for m, md := range c.methods {
+						if (m == "*" || m == httpMethod) && md == methodName {
 							find = true
 						}
 					}
@@ -541,7 +576,6 @@ func (p *ControllerRegistor) geturl(t *Tree, url, controllName, methodName strin
 
 // Implement http.Handler interface.
 func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	defer p.recoverPanic(rw, r)
 	starttime := time.Now()
 	var runrouter reflect.Type
 	var findrouter bool
@@ -564,22 +598,34 @@ func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 	context.Output.Context = context
 	context.Output.EnableGzip = EnableGzip
 
+	defer p.recoverPanic(context)
+
+	var urlPath string
+	if !RouterCaseSensitive {
+		urlPath = strings.ToLower(r.URL.Path)
+	} else {
+		urlPath = r.URL.Path
+	}
 	// defined filter function
 	do_filter := func(pos int) (started bool) {
 		if p.enableFilter {
 			if l, ok := p.filters[pos]; ok {
 				for _, filterR := range l {
-					if ok, p := filterR.ValidRouter(r.URL.Path); ok {
-						context.Input.Params = p
-						filterR.filterFunc(context)
-						if w.started {
-							return true
+					if filterR.returnOnOutput && w.started {
+						return true
+					}
+					if ok, params := filterR.ValidRouter(urlPath); ok {
+						for k, v := range params {
+							context.Input.Params[k] = v
 						}
+						filterR.filterFunc(context)
+					}
+					if filterR.returnOnOutput && w.started {
+						return true
 					}
 				}
 			}
 		}
-
 		return false
 	}
 
@@ -602,7 +648,13 @@ func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 
 	// session init
 	if SessionOn {
-		context.Input.CruSession = GlobalSessions.SessionStart(w, r)
+		var err error
+		context.Input.CruSession, err = GlobalSessions.SessionStart(w, r)
+		if err != nil {
+			Error(err)
+			exception("503", context)
+			return
+		}
 		defer func() {
 			context.Input.CruSession.SessionRelease(w)
 		}()
@@ -626,8 +678,18 @@ func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 	}
 
 	if !findrouter {
-		if t, ok := p.routers[r.Method]; ok {
-			runObject, p := t.Match(r.URL.Path)
+		http_method := r.Method
+
+		if http_method == "POST" && context.Input.Query("_method") == "PUT" {
+			http_method = "PUT"
+		}
+
+		if http_method == "POST" && context.Input.Query("_method") == "DELETE" {
+			http_method = "DELETE"
+		}
+
+		if t, ok := p.routers[http_method]; ok {
+			runObject, p := t.Match(urlPath)
 			if r, ok := runObject.(*controllerInfo); ok {
 				routerInfo = r
 				findrouter = true
@@ -645,7 +707,7 @@ func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 
 	//if no matches to url, throw a not found exception
 	if !findrouter {
-		middleware.Exception("404", rw, r, "")
+		exception("404", context)
 		goto Admin
 	}
 
@@ -661,7 +723,7 @@ func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 					isRunable = true
 					routerInfo.runfunction(context)
 				} else {
-					middleware.Exception("405", rw, r, "Method Not Allowed")
+					exception("405", context)
 					goto Admin
 				}
 			} else if routerInfo.routerType == routerTypeHandler {
@@ -705,7 +767,7 @@ func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request)
 			if EnableXSRF {
 				execController.XsrfToken()
 				if r.Method == "POST" || r.Method == "DELETE" || r.Method == "PUT" ||
-					(r.Method == "POST" && (r.Form.Get("_method") == "delete" || r.Form.Get("_method") == "put")) {
+					(r.Method == "POST" && (context.Input.Query("_method") == "DELETE" || context.Input.Query("_method") == "PUT")) {
 					execController.CheckXsrfCookie()
 				}
 			}
@@ -772,7 +834,7 @@ Admin:
 		}
 	}
 
-	if RunMode == "dev" {
+	if RunMode == "dev" || AccessLogs {
 		var devinfo string
 		if findrouter {
 			if routerInfo != nil {
@@ -783,7 +845,9 @@ Admin:
 		} else {
 			devinfo = fmt.Sprintf("| % -10s | % -40s | % -16s | % -10s |", r.Method, r.URL.Path, timeend.String(), "notmatch")
 		}
-		Debug(devinfo)
+		if DefaultLogFilter == nil || !DefaultLogFilter.Filter(context) {
+			Debug(devinfo)
+		}
 	}
 
 	// Call WriteHeader if status code has been set changed
@@ -792,82 +856,38 @@ Admin:
 	}
 }
 
-func (p *ControllerRegistor) recoverPanic(rw http.ResponseWriter, r *http.Request) {
+func (p *ControllerRegistor) recoverPanic(context *beecontext.Context) {
 	if err := recover(); err != nil {
 		if err == USERSTOPRUN {
 			return
 		}
-		if _, ok := err.(middleware.HTTPException); ok {
-			// catch intented errors, only for HTTP 4XX and 5XX
+		if !RecoverPanic {
+			panic(err)
 		} else {
-			if RunMode == "dev" {
-				if !RecoverPanic {
-					panic(err)
-				} else {
-					if ErrorsShow {
-						if handler, ok := middleware.ErrorMaps[fmt.Sprint(err)]; ok {
-							handler(rw, r)
-							return
-						}
-					}
-					var stack string
-					Critical("the request url is ", r.URL.Path)
-					Critical("Handler crashed with error", err)
-					for i := 1; ; i++ {
-						_, file, line, ok := runtime.Caller(i)
-						if !ok {
-							break
-						}
-						Critical(file, line)
-						stack = stack + fmt.Sprintln(file, line)
-					}
-					middleware.ShowErr(err, rw, r, stack)
-				}
-			} else {
-				if !RecoverPanic {
-					panic(err)
-				} else {
-					// in production model show all infomation
-					if ErrorsShow {
-						handler := p.getErrorHandler(fmt.Sprint(err))
-						handler(rw, r)
-						return
-					} else {
-						Critical("the request url is ", r.URL.Path)
-						Critical("Handler crashed with error", err)
-						for i := 1; ; i++ {
-							_, file, line, ok := runtime.Caller(i)
-							if !ok {
-								break
-							}
-							Critical(file, line)
-						}
-					}
+			if ErrorsShow {
+				if _, ok := ErrorMaps[fmt.Sprint(err)]; ok {
+					exception(fmt.Sprint(err), context)
+					return
 				}
 			}
-
+			var stack string
+			Critical("the request url is ", context.Input.Url())
+			Critical("Handler crashed with error", err)
+			for i := 1; ; i++ {
+				_, file, line, ok := runtime.Caller(i)
+				if !ok {
+					break
+				}
+				Critical(fmt.Sprintf("%s:%d", file, line))
+				stack = stack + fmt.Sprintln(fmt.Sprintf("%s:%d", file, line))
+			}
+			if RunMode == "dev" {
+				showErr(err, context, stack)
+			}
 		}
 	}
 }
 
-// there always should be error handler that sets error code accordingly for all unhandled errors.
-// in order to have custom UI for error page it's necessary to override "500" error.
-func (p *ControllerRegistor) getErrorHandler(errorCode string) func(rw http.ResponseWriter, r *http.Request) {
-	handler := middleware.SimpleServerError
-	ok := true
-	if errorCode != "" {
-		handler, ok = middleware.ErrorMaps[errorCode]
-		if !ok {
-			handler, ok = middleware.ErrorMaps["500"]
-		}
-		if !ok || handler == nil {
-			handler = middleware.SimpleServerError
-		}
-	}
-
-	return handler
-}
-
 //responseWriter is a wrapper for the http.ResponseWriter
 //started set to true if response was written to then don't execute other handler
 type responseWriter struct {

router_test.go

@@ -17,6 +17,7 @@ package beego
 import (
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 
 	"github.com/astaxie/beego/context"
@@ -26,33 +27,33 @@ type TestController struct {
 	Controller
 }
 
-func (this *TestController) Get() {
-	this.Data["Username"] = "astaxie"
-	this.Ctx.Output.Body([]byte("ok"))
+func (tc *TestController) Get() {
+	tc.Data["Username"] = "astaxie"
+	tc.Ctx.Output.Body([]byte("ok"))
 }
 
-func (this *TestController) Post() {
-	this.Ctx.Output.Body([]byte(this.Ctx.Input.Query(":name")))
+func (tc *TestController) Post() {
+	tc.Ctx.Output.Body([]byte(tc.Ctx.Input.Query(":name")))
 }
 
-func (this *TestController) Param() {
-	this.Ctx.Output.Body([]byte(this.Ctx.Input.Query(":name")))
+func (tc *TestController) Param() {
+	tc.Ctx.Output.Body([]byte(tc.Ctx.Input.Query(":name")))
 }
 
-func (this *TestController) List() {
-	this.Ctx.Output.Body([]byte("i am list"))
+func (tc *TestController) List() {
+	tc.Ctx.Output.Body([]byte("i am list"))
 }
 
-func (this *TestController) Params() {
-	this.Ctx.Output.Body([]byte(this.Ctx.Input.Params["0"] + this.Ctx.Input.Params["1"] + this.Ctx.Input.Params["2"]))
+func (tc *TestController) Params() {
+	tc.Ctx.Output.Body([]byte(tc.Ctx.Input.Params["0"] + tc.Ctx.Input.Params["1"] + tc.Ctx.Input.Params["2"]))
 }
 
-func (this *TestController) Myext() {
-	this.Ctx.Output.Body([]byte(this.Ctx.Input.Param(":ext")))
+func (tc *TestController) Myext() {
+	tc.Ctx.Output.Body([]byte(tc.Ctx.Input.Param(":ext")))
 }
 
-func (this *TestController) GetUrl() {
-	this.Ctx.Output.Body([]byte(this.UrlFor(".Myext")))
+func (tc *TestController) GetUrl() {
+	tc.Ctx.Output.Body([]byte(tc.UrlFor(".Myext")))
 }
 
 func (t *TestController) GetParams() {
@@ -385,3 +386,196 @@ func testRequest(method, path string) (*httptest.ResponseRecorder, *http.Request
 
 	return recorder, request
 }
+
+// Execution point: BeforeRouter
+// expectation: only BeforeRouter function is executed, notmatch output as router doesn't handle
+func TestFilterBeforeRouter(t *testing.T) {
+	testName := "TestFilterBeforeRouter"
+	url := "/beforeRouter"
+
+	mux := NewControllerRegister()
+	mux.InsertFilter(url, BeforeRouter, beegoBeforeRouter1)
+
+	mux.Get(url, beegoFilterFunc)
+
+	rw, r := testRequest("GET", url)
+	mux.ServeHTTP(rw, r)
+
+	if strings.Contains(rw.Body.String(), "BeforeRouter1") == false {
+		t.Errorf(testName + " BeforeRouter did not run")
+	}
+	if strings.Contains(rw.Body.String(), "hello") == true {
+		t.Errorf(testName + " BeforeRouter did not return properly")
+	}
+}
+
+// Execution point: BeforeExec
+// expectation: only BeforeExec function is executed, match as router determines route only
+func TestFilterBeforeExec(t *testing.T) {
+	testName := "TestFilterBeforeExec"
+	url := "/beforeExec"
+
+	mux := NewControllerRegister()
+	mux.InsertFilter(url, BeforeRouter, beegoFilterNoOutput)
+	mux.InsertFilter(url, BeforeExec, beegoBeforeExec1)
+
+	mux.Get(url, beegoFilterFunc)
+
+	rw, r := testRequest("GET", url)
+	mux.ServeHTTP(rw, r)
+
+	if strings.Contains(rw.Body.String(), "BeforeExec1") == false {
+		t.Errorf(testName + " BeforeExec did not run")
+	}
+	if strings.Contains(rw.Body.String(), "hello") == true {
+		t.Errorf(testName + " BeforeExec did not return properly")
+	}
+	if strings.Contains(rw.Body.String(), "BeforeRouter") == true {
+		t.Errorf(testName + " BeforeRouter ran in error")
+	}
+}
+
+// Execution point: AfterExec
+// expectation: only AfterExec function is executed, match as router handles
+func TestFilterAfterExec(t *testing.T) {
+	testName := "TestFilterAfterExec"
+	url := "/afterExec"
+
+	mux := NewControllerRegister()
+	mux.InsertFilter(url, BeforeRouter, beegoFilterNoOutput)
+	mux.InsertFilter(url, BeforeExec, beegoFilterNoOutput)
+	mux.InsertFilter(url, AfterExec, beegoAfterExec1, false)
+
+	mux.Get(url, beegoFilterFunc)
+
+	rw, r := testRequest("GET", url)
+	mux.ServeHTTP(rw, r)
+
+	if strings.Contains(rw.Body.String(), "AfterExec1") == false {
+		t.Errorf(testName + " AfterExec did not run")
+	}
+	if strings.Contains(rw.Body.String(), "hello") == false {
+		t.Errorf(testName + " handler did not run properly")
+	}
+	if strings.Contains(rw.Body.String(), "BeforeRouter") == true {
+		t.Errorf(testName + " BeforeRouter ran in error")
+	}
+	if strings.Contains(rw.Body.String(), "BeforeExec") == true {
+		t.Errorf(testName + " BeforeExec ran in error")
+	}
+}
+
+// Execution point: FinishRouter
+// expectation: only FinishRouter function is executed, match as router handles
+func TestFilterFinishRouter(t *testing.T) {
+	testName := "TestFilterFinishRouter"
+	url := "/finishRouter"
+
+	mux := NewControllerRegister()
+	mux.InsertFilter(url, BeforeRouter, beegoFilterNoOutput)
+	mux.InsertFilter(url, BeforeExec, beegoFilterNoOutput)
+	mux.InsertFilter(url, AfterExec, beegoFilterNoOutput)
+	mux.InsertFilter(url, FinishRouter, beegoFinishRouter1)
+
+	mux.Get(url, beegoFilterFunc)
+
+	rw, r := testRequest("GET", url)
+	mux.ServeHTTP(rw, r)
+
+	if strings.Contains(rw.Body.String(), "FinishRouter1") == true {
+		t.Errorf(testName + " FinishRouter did not run")
+	}
+	if strings.Contains(rw.Body.String(), "hello") == false {
+		t.Errorf(testName + " handler did not run properly")
+	}
+	if strings.Contains(rw.Body.String(), "AfterExec1") == true {
+		t.Errorf(testName + " AfterExec ran in error")
+	}
+	if strings.Contains(rw.Body.String(), "BeforeRouter") == true {
+		t.Errorf(testName + " BeforeRouter ran in error")
+	}
+	if strings.Contains(rw.Body.String(), "BeforeExec") == true {
+		t.Errorf(testName + " BeforeExec ran in error")
+	}
+}
+
+// Execution point: FinishRouter
+// expectation: only first FinishRouter function is executed, match as router handles
+func TestFilterFinishRouterMultiFirstOnly(t *testing.T) {
+	testName := "TestFilterFinishRouterMultiFirstOnly"
+	url := "/finishRouterMultiFirstOnly"
+
+	mux := NewControllerRegister()
+	mux.InsertFilter(url, FinishRouter, beegoFinishRouter1, false)
+	mux.InsertFilter(url, FinishRouter, beegoFinishRouter2)
+
+	mux.Get(url, beegoFilterFunc)
+
+	rw, r := testRequest("GET", url)
+	mux.ServeHTTP(rw, r)
+
+	if strings.Contains(rw.Body.String(), "FinishRouter1") == false {
+		t.Errorf(testName + " FinishRouter1 did not run")
+	}
+	if strings.Contains(rw.Body.String(), "hello") == false {
+		t.Errorf(testName + " handler did not run properly")
+	}
+	// not expected in body
+	if strings.Contains(rw.Body.String(), "FinishRouter2") == true {
+		t.Errorf(testName + " FinishRouter2 did run")
+	}
+}
+
+// Execution point: FinishRouter
+// expectation: both FinishRouter functions execute, match as router handles
+func TestFilterFinishRouterMulti(t *testing.T) {
+	testName := "TestFilterFinishRouterMulti"
+	url := "/finishRouterMulti"
+
+	mux := NewControllerRegister()
+	mux.InsertFilter(url, FinishRouter, beegoFinishRouter1, false)
+	mux.InsertFilter(url, FinishRouter, beegoFinishRouter2, false)
+
+	mux.Get(url, beegoFilterFunc)
+
+	rw, r := testRequest("GET", url)
+	mux.ServeHTTP(rw, r)
+
+	if strings.Contains(rw.Body.String(), "FinishRouter1") == false {
+		t.Errorf(testName + " FinishRouter1 did not run")
+	}
+	if strings.Contains(rw.Body.String(), "hello") == false {
+		t.Errorf(testName + " handler did not run properly")
+	}
+	if strings.Contains(rw.Body.String(), "FinishRouter2") == false {
+		t.Errorf(testName + " FinishRouter2 did not run properly")
+	}
+}
+
+func beegoFilterNoOutput(ctx *context.Context) {
+	return
+}
+func beegoBeforeRouter1(ctx *context.Context) {
+	ctx.WriteString("|BeforeRouter1")
+}
+func beegoBeforeRouter2(ctx *context.Context) {
+	ctx.WriteString("|BeforeRouter2")
+}
+func beegoBeforeExec1(ctx *context.Context) {
+	ctx.WriteString("|BeforeExec1")
+}
+func beegoBeforeExec2(ctx *context.Context) {
+	ctx.WriteString("|BeforeExec2")
+}
+func beegoAfterExec1(ctx *context.Context) {
+	ctx.WriteString("|AfterExec1")
+}
+func beegoAfterExec2(ctx *context.Context) {
+	ctx.WriteString("|AfterExec2")
+}
+func beegoFinishRouter1(ctx *context.Context) {
+	ctx.WriteString("|FinishRouter1")
+}
+func beegoFinishRouter2(ctx *context.Context) {
+	ctx.WriteString("|FinishRouter2")
+}

session/ledis/ledis_session.go

@@ -0,0 +1,180 @@
+package session
+
+import (
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/astaxie/beego/session"
+	"github.com/siddontang/ledisdb/config"
+	"github.com/siddontang/ledisdb/ledis"
+)
+
+var ledispder = &LedisProvider{}
+var c *ledis.DB
+
+// ledis session store
+type LedisSessionStore struct {
+	sid         string
+	lock        sync.RWMutex
+	values      map[interface{}]interface{}
+	maxlifetime int64
+}
+
+// set value in ledis session
+func (ls *LedisSessionStore) Set(key, value interface{}) error {
+	ls.lock.Lock()
+	defer ls.lock.Unlock()
+	ls.values[key] = value
+	return nil
+}
+
+// get value in ledis session
+func (ls *LedisSessionStore) Get(key interface{}) interface{} {
+	ls.lock.RLock()
+	defer ls.lock.RUnlock()
+	if v, ok := ls.values[key]; ok {
+		return v
+	} else {
+		return nil
+	}
+}
+
+// delete value in ledis session
+func (ls *LedisSessionStore) Delete(key interface{}) error {
+	ls.lock.Lock()
+	defer ls.lock.Unlock()
+	delete(ls.values, key)
+	return nil
+}
+
+// clear all values in ledis session
+func (ls *LedisSessionStore) Flush() error {
+	ls.lock.Lock()
+	defer ls.lock.Unlock()
+	ls.values = make(map[interface{}]interface{})
+	return nil
+}
+
+// get ledis session id
+func (ls *LedisSessionStore) SessionID() string {
+	return ls.sid
+}
+
+// save session values to ledis
+func (ls *LedisSessionStore) SessionRelease(w http.ResponseWriter) {
+	b, err := session.EncodeGob(ls.values)
+	if err != nil {
+		return
+	}
+	c.Set([]byte(ls.sid), b)
+	c.Expire([]byte(ls.sid), ls.maxlifetime)
+}
+
+// ledis session provider
+type LedisProvider struct {
+	maxlifetime int64
+	savePath    string
+	db          int
+}
+
+// init ledis session
+// savepath like ledis server saveDataPath,pool size
+// e.g. 127.0.0.1:6379,100,astaxie
+func (lp *LedisProvider) SessionInit(maxlifetime int64, savePath string) error {
+	var err error
+	lp.maxlifetime = maxlifetime
+	configs := strings.Split(savePath, ",")
+	if len(configs) == 1 {
+		lp.savePath = configs[0]
+	} else if len(configs) == 2 {
+		lp.savePath = configs[0]
+		lp.db, err = strconv.Atoi(configs[1])
+		if err != nil {
+			return err
+		}
+	}
+	cfg := new(config.Config)
+	cfg.DataDir = lp.savePath
+	nowLedis, err := ledis.Open(cfg)
+	c, err = nowLedis.Select(lp.db)
+	if err != nil {
+		println(err)
+		return nil
+	}
+	return nil
+}
+
+// read ledis session by sid
+func (lp *LedisProvider) SessionRead(sid string) (session.SessionStore, error) {
+	kvs, err := c.Get([]byte(sid))
+	var kv map[interface{}]interface{}
+	if len(kvs) == 0 {
+		kv = make(map[interface{}]interface{})
+	} else {
+		kv, err = session.DecodeGob(kvs)
+		if err != nil {
+			return nil, err
+		}
+	}
+	ls := &LedisSessionStore{sid: sid, values: kv, maxlifetime: lp.maxlifetime}
+	return ls, nil
+}
+
+// check ledis session exist by sid
+func (lp *LedisProvider) SessionExist(sid string) bool {
+	count, _ := c.Exists([]byte(sid))
+	if count == 0 {
+		return false
+	} else {
+		return true
+	}
+}
+
+// generate new sid for ledis session
+func (lp *LedisProvider) SessionRegenerate(oldsid, sid string) (session.SessionStore, error) {
+	count, _ := c.Exists([]byte(sid))
+	if count == 0 {
+		// oldsid doesn't exists, set the new sid directly
+		// ignore error here, since if it return error
+		// the existed value will be 0
+		c.Set([]byte(sid), []byte(""))
+		c.Expire([]byte(sid), lp.maxlifetime)
+	} else {
+		data, _ := c.Get([]byte(oldsid))
+		c.Set([]byte(sid), data)
+		c.Expire([]byte(sid), lp.maxlifetime)
+	}
+	kvs, err := c.Get([]byte(sid))
+	var kv map[interface{}]interface{}
+	if len(kvs) == 0 {
+		kv = make(map[interface{}]interface{})
+	} else {
+		kv, err = session.DecodeGob([]byte(kvs))
+		if err != nil {
+			return nil, err
+		}
+	}
+	ls := &LedisSessionStore{sid: sid, values: kv, maxlifetime: lp.maxlifetime}
+	return ls, nil
+}
+
+// delete ledis session by id
+func (lp *LedisProvider) SessionDestroy(sid string) error {
+	c.Del([]byte(sid))
+	return nil
+}
+
+// Impelment method, no used.
+func (lp *LedisProvider) SessionGC() {
+	return
+}
+
+// @todo
+func (lp *LedisProvider) SessionAll() int {
+	return 0
+}
+func init() {
+	session.Register("ledis", ledispder)
+}

session/memcache/sess_memcache.go

@@ -129,8 +129,9 @@ func (rp *MemProvider) SessionRead(sid string) (session.SessionStore, error) {
 		}
 	}
 	item, err := client.Get(sid)
-	if err != nil {
-		return nil, err
+	if err != nil && err == memcache.ErrCacheMiss {
+		rs := &MemcacheSessionStore{sid: sid, values: make(map[interface{}]interface{}), maxlifetime: rp.maxlifetime}
+		return rs, nil
 	}
 	var kv map[interface{}]interface{}
 	if len(item.Value) == 0 {
@@ -141,7 +142,6 @@ func (rp *MemProvider) SessionRead(sid string) (session.SessionStore, error) {
 			return nil, err
 		}
 	}
-
 	rs := &MemcacheSessionStore{sid: sid, values: kv, maxlifetime: rp.maxlifetime}
 	return rs, nil
 }
@@ -179,7 +179,6 @@ func (rp *MemProvider) SessionRegenerate(oldsid, sid string) (session.SessionSto
 	} else {
 		client.Delete(oldsid)
 		item.Key = sid
-		item.Value = item.Value
 		item.Expiration = int32(rp.maxlifetime)
 		client.Set(item)
 		contain = item.Value

session/mysql/sess_mysql.go

@@ -21,7 +21,7 @@
 // mysql session support need create table as sql:
 //	CREATE TABLE `session` (
 //	`session_key` char(64) NOT NULL,
-//	session_data` blob,
+//	`session_data` blob,
 //	`session_expiry` int(11) unsigned NOT NULL,
 //	PRIMARY KEY (`session_key`)
 //	) ENGINE=MyISAM DEFAULT CHARSET=utf8;

session/redis/sess_redis.go

@@ -109,7 +109,7 @@ func (rs *RedisSessionStore) SessionRelease(w http.ResponseWriter) {
 		return
 	}
 
-	c.Do("SET", rs.sid, string(b), "EX", rs.maxlifetime)
+	c.Do("SETEX", rs.sid, rs.maxlifetime, string(b))
 }
 
 // redis session provider
@@ -118,12 +118,13 @@ type RedisProvider struct {
 	savePath    string
 	poolsize    int
 	password    string
+	dbNum       int
 	poollist    *redis.Pool
 }
 
 // init redis session
-// savepath like redis server addr,pool size,password
-// e.g. 127.0.0.1:6379,100,astaxie
+// savepath like redis server addr,pool size,password,dbnum
+// e.g. 127.0.0.1:6379,100,astaxie,0
 func (rp *RedisProvider) SessionInit(maxlifetime int64, savePath string) error {
 	rp.maxlifetime = maxlifetime
 	configs := strings.Split(savePath, ",")
@@ -143,6 +144,16 @@ func (rp *RedisProvider) SessionInit(maxlifetime int64, savePath string) error {
 	if len(configs) > 2 {
 		rp.password = configs[2]
 	}
+	if len(configs) > 3 {
+		dbnum, err := strconv.Atoi(configs[3])
+		if err != nil || dbnum < 0 {
+			rp.dbNum = 0
+		} else {
+			rp.dbNum = dbnum
+		}
+	} else {
+		rp.dbNum = 0
+	}
 	rp.poollist = redis.NewPool(func() (redis.Conn, error) {
 		c, err := redis.Dial("tcp", rp.savePath)
 		if err != nil {
@@ -154,6 +165,11 @@ func (rp *RedisProvider) SessionInit(maxlifetime int64, savePath string) error {
 				return nil, err
 			}
 		}
+		_, err = c.Do("SELECT", rp.dbNum)
+		if err != nil {
+			c.Close()
+			return nil, err
+		}
 		return c, err
 	}, rp.poolsize)
 

session/sess_cookie_test.go

@@ -29,7 +29,10 @@ func TestCookie(t *testing.T) {
 	}
 	r, _ := http.NewRequest("GET", "/", nil)
 	w := httptest.NewRecorder()
-	sess := globalSessions.SessionStart(w, r)
+	sess, err := globalSessions.SessionStart(w, r)
+	if err != nil {
+		t.Fatal("set error,", err)
+	}
 	err = sess.Set("username", "astaxie")
 	if err != nil {
 		t.Fatal("set error,", err)

session/sess_mem.go

@@ -1,199 +1,199 @@
-// Copyright 2014 beego Author. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package session
-
-import (
-	"container/list"
-	"net/http"
-	"sync"
-	"time"
-)
-
-var mempder = &MemProvider{list: list.New(), sessions: make(map[string]*list.Element)}
-
-// memory session store.
-// it saved sessions in a map in memory.
-type MemSessionStore struct {
-	sid          string                      //session id
-	timeAccessed time.Time                   //last access time
-	value        map[interface{}]interface{} //session store
-	lock         sync.RWMutex
-}
-
-// set value to memory session
-func (st *MemSessionStore) Set(key, value interface{}) error {
-	st.lock.Lock()
-	defer st.lock.Unlock()
-	st.value[key] = value
-	return nil
-}
-
-// get value from memory session by key
-func (st *MemSessionStore) Get(key interface{}) interface{} {
-	st.lock.RLock()
-	defer st.lock.RUnlock()
-	if v, ok := st.value[key]; ok {
-		return v
-	} else {
-		return nil
-	}
-}
-
-// delete in memory session by key
-func (st *MemSessionStore) Delete(key interface{}) error {
-	st.lock.Lock()
-	defer st.lock.Unlock()
-	delete(st.value, key)
-	return nil
-}
-
-// clear all values in memory session
-func (st *MemSessionStore) Flush() error {
-	st.lock.Lock()
-	defer st.lock.Unlock()
-	st.value = make(map[interface{}]interface{})
-	return nil
-}
-
-// get this id of memory session store
-func (st *MemSessionStore) SessionID() string {
-	return st.sid
-}
-
-// Implement method, no used.
-func (st *MemSessionStore) SessionRelease(w http.ResponseWriter) {
-}
-
-type MemProvider struct {
-	lock        sync.RWMutex             // locker
-	sessions    map[string]*list.Element // map in memory
-	list        *list.List               // for gc
-	maxlifetime int64
-	savePath    string
-}
-
-// init memory session
-func (pder *MemProvider) SessionInit(maxlifetime int64, savePath string) error {
-	pder.maxlifetime = maxlifetime
-	pder.savePath = savePath
-	return nil
-}
-
-// get memory session store by sid
-func (pder *MemProvider) SessionRead(sid string) (SessionStore, error) {
-	pder.lock.RLock()
-	if element, ok := pder.sessions[sid]; ok {
-		go pder.SessionUpdate(sid)
-		pder.lock.RUnlock()
-		return element.Value.(*MemSessionStore), nil
-	} else {
-		pder.lock.RUnlock()
-		pder.lock.Lock()
-		newsess := &MemSessionStore{sid: sid, timeAccessed: time.Now(), value: make(map[interface{}]interface{})}
-		element := pder.list.PushBack(newsess)
-		pder.sessions[sid] = element
-		pder.lock.Unlock()
-		return newsess, nil
-	}
-}
-
-// check session store exist in memory session by sid
-func (pder *MemProvider) SessionExist(sid string) bool {
-	pder.lock.RLock()
-	defer pder.lock.RUnlock()
-	if _, ok := pder.sessions[sid]; ok {
-		return true
-	} else {
-		return false
-	}
-}
-
-// generate new sid for session store in memory session
-func (pder *MemProvider) SessionRegenerate(oldsid, sid string) (SessionStore, error) {
-	pder.lock.RLock()
-	if element, ok := pder.sessions[oldsid]; ok {
-		go pder.SessionUpdate(oldsid)
-		pder.lock.RUnlock()
-		pder.lock.Lock()
-		element.Value.(*MemSessionStore).sid = sid
-		pder.sessions[sid] = element
-		delete(pder.sessions, oldsid)
-		pder.lock.Unlock()
-		return element.Value.(*MemSessionStore), nil
-	} else {
-		pder.lock.RUnlock()
-		pder.lock.Lock()
-		newsess := &MemSessionStore{sid: sid, timeAccessed: time.Now(), value: make(map[interface{}]interface{})}
-		element := pder.list.PushBack(newsess)
-		pder.sessions[sid] = element
-		pder.lock.Unlock()
-		return newsess, nil
-	}
-}
-
-// delete session store in memory session by id
-func (pder *MemProvider) SessionDestroy(sid string) error {
-	pder.lock.Lock()
-	defer pder.lock.Unlock()
-	if element, ok := pder.sessions[sid]; ok {
-		delete(pder.sessions, sid)
-		pder.list.Remove(element)
-		return nil
-	}
-	return nil
-}
-
-// clean expired session stores in memory session
-func (pder *MemProvider) SessionGC() {
-	pder.lock.RLock()
-	for {
-		element := pder.list.Back()
-		if element == nil {
-			break
-		}
-		if (element.Value.(*MemSessionStore).timeAccessed.Unix() + pder.maxlifetime) < time.Now().Unix() {
-			pder.lock.RUnlock()
-			pder.lock.Lock()
-			pder.list.Remove(element)
-			delete(pder.sessions, element.Value.(*MemSessionStore).sid)
-			pder.lock.Unlock()
-			pder.lock.RLock()
-		} else {
-			break
-		}
-	}
-	pder.lock.RUnlock()
-}
-
-// get count number of memory session
-func (pder *MemProvider) SessionAll() int {
-	return pder.list.Len()
-}
-
-// expand time of session store by id in memory session
-func (pder *MemProvider) SessionUpdate(sid string) error {
-	pder.lock.Lock()
-	defer pder.lock.Unlock()
-	if element, ok := pder.sessions[sid]; ok {
-		element.Value.(*MemSessionStore).timeAccessed = time.Now()
-		pder.list.MoveToFront(element)
-		return nil
-	}
-	return nil
-}
-
-func init() {
-	Register("memory", mempder)
-}
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package session
+
+import (
+	"container/list"
+	"net/http"
+	"sync"
+	"time"
+)
+
+var mempder = &MemProvider{list: list.New(), sessions: make(map[string]*list.Element)}
+
+// memory session store.
+// it saved sessions in a map in memory.
+type MemSessionStore struct {
+	sid          string                      //session id
+	timeAccessed time.Time                   //last access time
+	value        map[interface{}]interface{} //session store
+	lock         sync.RWMutex
+}
+
+// set value to memory session
+func (st *MemSessionStore) Set(key, value interface{}) error {
+	st.lock.Lock()
+	defer st.lock.Unlock()
+	st.value[key] = value
+	return nil
+}
+
+// get value from memory session by key
+func (st *MemSessionStore) Get(key interface{}) interface{} {
+	st.lock.RLock()
+	defer st.lock.RUnlock()
+	if v, ok := st.value[key]; ok {
+		return v
+	} else {
+		return nil
+	}
+}
+
+// delete in memory session by key
+func (st *MemSessionStore) Delete(key interface{}) error {
+	st.lock.Lock()
+	defer st.lock.Unlock()
+	delete(st.value, key)
+	return nil
+}
+
+// clear all values in memory session
+func (st *MemSessionStore) Flush() error {
+	st.lock.Lock()
+	defer st.lock.Unlock()
+	st.value = make(map[interface{}]interface{})
+	return nil
+}
+
+// get this id of memory session store
+func (st *MemSessionStore) SessionID() string {
+	return st.sid
+}
+
+// Implement method, no used.
+func (st *MemSessionStore) SessionRelease(w http.ResponseWriter) {
+}
+
+type MemProvider struct {
+	lock        sync.RWMutex             // locker
+	sessions    map[string]*list.Element // map in memory
+	list        *list.List               // for gc
+	maxlifetime int64
+	savePath    string
+}
+
+// init memory session
+func (pder *MemProvider) SessionInit(maxlifetime int64, savePath string) error {
+	pder.maxlifetime = maxlifetime
+	pder.savePath = savePath
+	return nil
+}
+
+// get memory session store by sid
+func (pder *MemProvider) SessionRead(sid string) (SessionStore, error) {
+	pder.lock.RLock()
+	if element, ok := pder.sessions[sid]; ok {
+		go pder.SessionUpdate(sid)
+		pder.lock.RUnlock()
+		return element.Value.(*MemSessionStore), nil
+	} else {
+		pder.lock.RUnlock()
+		pder.lock.Lock()
+		newsess := &MemSessionStore{sid: sid, timeAccessed: time.Now(), value: make(map[interface{}]interface{})}
+		element := pder.list.PushBack(newsess)
+		pder.sessions[sid] = element
+		pder.lock.Unlock()
+		return newsess, nil
+	}
+}
+
+// check session store exist in memory session by sid
+func (pder *MemProvider) SessionExist(sid string) bool {
+	pder.lock.RLock()
+	defer pder.lock.RUnlock()
+	if _, ok := pder.sessions[sid]; ok {
+		return true
+	} else {
+		return false
+	}
+}
+
+// generate new sid for session store in memory session
+func (pder *MemProvider) SessionRegenerate(oldsid, sid string) (SessionStore, error) {
+	pder.lock.RLock()
+	if element, ok := pder.sessions[oldsid]; ok {
+		go pder.SessionUpdate(oldsid)
+		pder.lock.RUnlock()
+		pder.lock.Lock()
+		element.Value.(*MemSessionStore).sid = sid
+		pder.sessions[sid] = element
+		delete(pder.sessions, oldsid)
+		pder.lock.Unlock()
+		return element.Value.(*MemSessionStore), nil
+	} else {
+		pder.lock.RUnlock()
+		pder.lock.Lock()
+		newsess := &MemSessionStore{sid: sid, timeAccessed: time.Now(), value: make(map[interface{}]interface{})}
+		element := pder.list.PushBack(newsess)
+		pder.sessions[sid] = element
+		pder.lock.Unlock()
+		return newsess, nil
+	}
+}
+
+// delete session store in memory session by id
+func (pder *MemProvider) SessionDestroy(sid string) error {
+	pder.lock.Lock()
+	defer pder.lock.Unlock()
+	if element, ok := pder.sessions[sid]; ok {
+		delete(pder.sessions, sid)
+		pder.list.Remove(element)
+		return nil
+	}
+	return nil
+}
+
+// clean expired session stores in memory session
+func (pder *MemProvider) SessionGC() {
+	pder.lock.RLock()
+	for {
+		element := pder.list.Back()
+		if element == nil {
+			break
+		}
+		if (element.Value.(*MemSessionStore).timeAccessed.Unix() + pder.maxlifetime) < time.Now().Unix() {
+			pder.lock.RUnlock()
+			pder.lock.Lock()
+			pder.list.Remove(element)
+			delete(pder.sessions, element.Value.(*MemSessionStore).sid)
+			pder.lock.Unlock()
+			pder.lock.RLock()
+		} else {
+			break
+		}
+	}
+	pder.lock.RUnlock()
+}
+
+// get count number of memory session
+func (pder *MemProvider) SessionAll() int {
+	return pder.list.Len()
+}
+
+// expand time of session store by id in memory session
+func (pder *MemProvider) SessionUpdate(sid string) error {
+	pder.lock.Lock()
+	defer pder.lock.Unlock()
+	if element, ok := pder.sessions[sid]; ok {
+		element.Value.(*MemSessionStore).timeAccessed = time.Now()
+		pder.list.MoveToFront(element)
+		return nil
+	}
+	return nil
+}
+
+func init() {
+	Register("memory", mempder)
+}

session/sess_mem_test.go

@@ -26,9 +26,12 @@ func TestMem(t *testing.T) {
 	go globalSessions.GC()
 	r, _ := http.NewRequest("GET", "/", nil)
 	w := httptest.NewRecorder()
-	sess := globalSessions.SessionStart(w, r)
+	sess, err := globalSessions.SessionStart(w, r)
+	if err != nil {
+		t.Fatal("set error,", err)
+	}
 	defer sess.SessionRelease(w)
-	err := sess.Set("username", "astaxie")
+	err = sess.Set("username", "astaxie")
 	if err != nil {
 		t.Fatal("set error,", err)
 	}

session/session.go

@@ -28,19 +28,13 @@
 package session
 
 import (
-	"crypto/hmac"
-	"crypto/md5"
 	"crypto/rand"
-	"crypto/sha1"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
-	"io"
 	"net/http"
 	"net/url"
 	"time"
-
-	"github.com/astaxie/beego/utils"
 )
 
 // SessionStore contains all data for one session process with specific id.
@@ -81,16 +75,15 @@ func Register(name string, provide Provider) {
 }
 
 type managerConfig struct {
-	CookieName        string `json:"cookieName"`
-	EnableSetCookie   bool   `json:"enableSetCookie,omitempty"`
-	Gclifetime        int64  `json:"gclifetime"`
-	Maxlifetime       int64  `json:"maxLifetime"`
-	Secure            bool   `json:"secure"`
-	SessionIDHashFunc string `json:"sessionIDHashFunc"`
-	SessionIDHashKey  string `json:"sessionIDHashKey"`
-	CookieLifeTime    int    `json:"cookieLifeTime"`
-	ProviderConfig    string `json:"providerConfig"`
-	Domain            string `json:"domain"`
+	CookieName      string `json:"cookieName"`
+	EnableSetCookie bool   `json:"enableSetCookie,omitempty"`
+	Gclifetime      int64  `json:"gclifetime"`
+	Maxlifetime     int64  `json:"maxLifetime"`
+	Secure          bool   `json:"secure"`
+	CookieLifeTime  int    `json:"cookieLifeTime"`
+	ProviderConfig  string `json:"providerConfig"`
+	Domain          string `json:"domain"`
+	SessionIdLength int64  `json:"sessionIdLength"`
 }
 
 // Manager contains Provider and its configuration.
@@ -129,11 +122,9 @@ func NewManager(provideName, config string) (*Manager, error) {
 	if err != nil {
 		return nil, err
 	}
-	if cf.SessionIDHashFunc == "" {
-		cf.SessionIDHashFunc = "sha1"
-	}
-	if cf.SessionIDHashKey == "" {
-		cf.SessionIDHashKey = string(generateRandomKey(16))
+
+	if cf.SessionIdLength == 0 {
+		cf.SessionIdLength = 16
 	}
 
 	return &Manager{
@@ -144,39 +135,54 @@ func NewManager(provideName, config string) (*Manager, error) {
 
 // Start session. generate or read the session id from http request.
 // if session id exists, return SessionStore with this id.
-func (manager *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (session SessionStore) {
-	cookie, err := r.Cookie(manager.config.CookieName)
-	if err != nil || cookie.Value == "" {
-		sid := manager.sessionId(r)
-		session, _ = manager.provider.SessionRead(sid)
-		cookie = &http.Cookie{Name: manager.config.CookieName,
+func (manager *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (session SessionStore, err error) {
+	cookie, errs := r.Cookie(manager.config.CookieName)
+	if errs != nil || cookie.Value == "" {
+		sid, errs := manager.sessionId(r)
+		if errs != nil {
+			return nil, errs
+		}
+		session, err = manager.provider.SessionRead(sid)
+		cookie = &http.Cookie{
+			Name:     manager.config.CookieName,
 			Value:    url.QueryEscape(sid),
 			Path:     "/",
 			HttpOnly: true,
-			Secure:   manager.config.Secure,
-			Domain:   manager.config.Domain}
-		if manager.config.CookieLifeTime >= 0 {
+			Secure:   manager.isSecure(r),
+			Domain:   manager.config.Domain,
+		}
+		if manager.config.CookieLifeTime > 0 {
 			cookie.MaxAge = manager.config.CookieLifeTime
+			cookie.Expires = time.Now().Add(time.Duration(manager.config.CookieLifeTime) * time.Second)
 		}
 		if manager.config.EnableSetCookie {
 			http.SetCookie(w, cookie)
 		}
 		r.AddCookie(cookie)
 	} else {
-		sid, _ := url.QueryUnescape(cookie.Value)
+		sid, errs := url.QueryUnescape(cookie.Value)
+		if errs != nil {
+			return nil, errs
+		}
 		if manager.provider.SessionExist(sid) {
-			session, _ = manager.provider.SessionRead(sid)
+			session, err = manager.provider.SessionRead(sid)
 		} else {
-			sid = manager.sessionId(r)
-			session, _ = manager.provider.SessionRead(sid)
-			cookie = &http.Cookie{Name: manager.config.CookieName,
+			sid, err = manager.sessionId(r)
+			if err != nil {
+				return nil, err
+			}
+			session, err = manager.provider.SessionRead(sid)
+			cookie = &http.Cookie{
+				Name:     manager.config.CookieName,
 				Value:    url.QueryEscape(sid),
 				Path:     "/",
 				HttpOnly: true,
-				Secure:   manager.config.Secure,
-				Domain:   manager.config.Domain}
-			if manager.config.CookieLifeTime >= 0 {
+				Secure:   manager.isSecure(r),
+				Domain:   manager.config.Domain,
+			}
+			if manager.config.CookieLifeTime > 0 {
 				cookie.MaxAge = manager.config.CookieLifeTime
+				cookie.Expires = time.Now().Add(time.Duration(manager.config.CookieLifeTime) * time.Second)
 			}
 			if manager.config.EnableSetCookie {
 				http.SetCookie(w, cookie)
@@ -219,7 +225,10 @@ func (manager *Manager) GC() {
 
 // Regenerate a session id for this SessionStore who's id is saving in http request.
 func (manager *Manager) SessionRegenerateId(w http.ResponseWriter, r *http.Request) (session SessionStore) {
-	sid := manager.sessionId(r)
+	sid, err := manager.sessionId(r)
+	if err != nil {
+		return
+	}
 	cookie, err := r.Cookie(manager.config.CookieName)
 	if err != nil && cookie.Value == "" {
 		//delete old cookie
@@ -228,7 +237,7 @@ func (manager *Manager) SessionRegenerateId(w http.ResponseWriter, r *http.Reque
 			Value:    url.QueryEscape(sid),
 			Path:     "/",
 			HttpOnly: true,
-			Secure:   manager.config.Secure,
+			Secure:   manager.isSecure(r),
 			Domain:   manager.config.Domain,
 		}
 	} else {
@@ -238,8 +247,9 @@ func (manager *Manager) SessionRegenerateId(w http.ResponseWriter, r *http.Reque
 		cookie.HttpOnly = true
 		cookie.Path = "/"
 	}
-	if manager.config.CookieLifeTime >= 0 {
+	if manager.config.CookieLifeTime > 0 {
 		cookie.MaxAge = manager.config.CookieLifeTime
+		cookie.Expires = time.Now().Add(time.Duration(manager.config.CookieLifeTime) * time.Second)
 	}
 	http.SetCookie(w, cookie)
 	r.AddCookie(cookie)
@@ -251,36 +261,30 @@ func (manager *Manager) GetActiveSession() int {
 	return manager.provider.SessionAll()
 }
 
-// Set hash function for generating session id.
-func (manager *Manager) SetHashFunc(hasfunc, hashkey string) {
-	manager.config.SessionIDHashFunc = hasfunc
-	manager.config.SessionIDHashKey = hashkey
-}
-
 // Set cookie with https.
 func (manager *Manager) SetSecure(secure bool) {
 	manager.config.Secure = secure
 }
 
-// generate session id with rand string, unix nano time, remote addr by hash function.
-func (manager *Manager) sessionId(r *http.Request) (sid string) {
-	bs := make([]byte, 32)
-	if n, err := io.ReadFull(rand.Reader, bs); n != 32 || err != nil {
-		bs = utils.RandomCreateBytes(32)
+func (manager *Manager) sessionId(r *http.Request) (string, error) {
+	b := make([]byte, manager.config.SessionIdLength)
+	n, err := rand.Read(b)
+	if n != len(b) || err != nil {
+		return "", fmt.Errorf("Could not successfully read from the system CSPRNG.")
 	}
-	sig := fmt.Sprintf("%s%d%s", r.RemoteAddr, time.Now().UnixNano(), bs)
-	if manager.config.SessionIDHashFunc == "md5" {
-		h := md5.New()
-		h.Write([]byte(sig))
-		sid = hex.EncodeToString(h.Sum(nil))
-	} else if manager.config.SessionIDHashFunc == "sha1" {
-		h := hmac.New(sha1.New, []byte(manager.config.SessionIDHashKey))
-		fmt.Fprintf(h, "%s", sig)
-		sid = hex.EncodeToString(h.Sum(nil))
-	} else {
-		h := hmac.New(sha1.New, []byte(manager.config.SessionIDHashKey))
-		fmt.Fprintf(h, "%s", sig)
-		sid = hex.EncodeToString(h.Sum(nil))
-	}
-	return
+	return hex.EncodeToString(b), nil
+}
+
+// Set cookie with https.
+func (manager *Manager) isSecure(req *http.Request) bool {
+	if !manager.config.Secure {
+		return false
+	}
+	if req.URL.Scheme != "" {
+		return req.URL.Scheme == "https"
+	}
+	if req.TLS == nil {
+		return false
+	}
+	return true
 }

staticfile.go

@@ -22,7 +22,6 @@ import (
 	"strings"
 
 	"github.com/astaxie/beego/context"
-	"github.com/astaxie/beego/middleware"
 	"github.com/astaxie/beego/utils"
 )
 
@@ -31,6 +30,7 @@ func serverStaticRouter(ctx *context.Context) {
 		return
 	}
 	requestPath := path.Clean(ctx.Input.Request.URL.Path)
+	i := 0
 	for prefix, staticDir := range StaticDir {
 		if len(prefix) == 0 {
 			continue
@@ -41,8 +41,13 @@ func serverStaticRouter(ctx *context.Context) {
 				http.ServeFile(ctx.ResponseWriter, ctx.Request, file)
 				return
 			} else {
-				http.NotFound(ctx.ResponseWriter, ctx.Request)
-				return
+				i++
+				if i == len(StaticDir) {
+					http.NotFound(ctx.ResponseWriter, ctx.Request)
+					return
+				} else {
+					continue
+				}
 			}
 		}
 		if strings.HasPrefix(requestPath, prefix) {
@@ -53,15 +58,26 @@ func serverStaticRouter(ctx *context.Context) {
 			finfo, err := os.Stat(file)
 			if err != nil {
 				if RunMode == "dev" {
-					Warn(err)
+					Warn("Can't find the file:", file, err)
 				}
 				http.NotFound(ctx.ResponseWriter, ctx.Request)
 				return
 			}
 			//if the request is dir and DirectoryIndex is false then
-			if finfo.IsDir() && !DirectoryIndex {
-				middleware.Exception("403", ctx.ResponseWriter, ctx.Request, "403 Forbidden")
-				return
+			if finfo.IsDir() {
+				if !DirectoryIndex {
+					exception("403", ctx)
+					return
+				} else if ctx.Input.Request.URL.Path[len(ctx.Input.Request.URL.Path)-1] != '/' {
+					http.Redirect(ctx.ResponseWriter, ctx.Request, ctx.Input.Request.URL.Path+"/", 302)
+					return
+				}
+			} else if strings.HasSuffix(requestPath, "/index.html") {
+				file := path.Join(staticDir, requestPath)
+				if utils.FileExists(file) {
+					http.ServeFile(ctx.ResponseWriter, ctx.Request, file)
+					return
+				}
 			}
 
 			//This block obtained from (https://github.com/smithfox/beego) - it should probably get merged into astaxie/beego after a pull request

template.go

@@ -42,6 +42,9 @@ func init() {
 	beegoTplFuncMap["dateformat"] = DateFormat
 	beegoTplFuncMap["date"] = Date
 	beegoTplFuncMap["compare"] = Compare
+	beegoTplFuncMap["compare_not"] = CompareNot
+	beegoTplFuncMap["not_nil"] = NotNil
+	beegoTplFuncMap["not_null"] = NotNil
 	beegoTplFuncMap["substr"] = Substr
 	beegoTplFuncMap["html2str"] = Html2str
 	beegoTplFuncMap["str2html"] = Str2html

templatefunc.go

@@ -139,6 +139,14 @@ func Compare(a, b interface{}) (equal bool) {
 	return
 }
 
+func CompareNot(a, b interface{}) (equal bool) {
+    return ! Compare(a, b)
+}
+
+func NotNil(a interface{}) (is_nil bool) {
+    return CompareNot(a, nil)
+}
+
 func Config(returnType, key string, defaultVal interface{}) (value interface{}, err error) {
 	switch returnType {
 	case "String":
@@ -246,7 +254,7 @@ func Htmlunquote(src string) string {
 //	/user/John%20Doe
 //
 //  more detail http://beego.me/docs/mvc/controller/urlbuilding.md
-func UrlFor(endpoint string, values ...string) string {
+func UrlFor(endpoint string, values ...interface{}) string {
 	return BeeApp.Handlers.UrlFor(endpoint, values...)
 }
 
@@ -302,6 +310,14 @@ func ParseForm(form url.Values, obj interface{}) error {
 
 		switch fieldT.Type.Kind() {
 		case reflect.Bool:
+			if strings.ToLower(value) == "on" || strings.ToLower(value) == "1" || strings.ToLower(value) == "yes" {
+				fieldV.SetBool(true)
+				continue
+			}
+			if strings.ToLower(value) == "off" || strings.ToLower(value) == "0" || strings.ToLower(value) == "no" {
+				fieldV.SetBool(false)
+				continue
+			}
 			b, err := strconv.ParseBool(value)
 			if err != nil {
 				return err
@@ -329,11 +345,45 @@ func ParseForm(form url.Values, obj interface{}) error {
 			fieldV.Set(reflect.ValueOf(value))
 		case reflect.String:
 			fieldV.SetString(value)
+		case reflect.Struct:
+			switch fieldT.Type.String() {
+			case "time.Time":
+				format := time.RFC3339
+				if len(tags) > 1 {
+					format = tags[1]
+				}
+				t, err := time.Parse(format, value)
+				if err != nil {
+					return err
+				}
+				fieldV.Set(reflect.ValueOf(t))
+			}
+		case reflect.Slice:
+			if fieldT.Type == sliceOfInts {
+				formVals := form[tag]
+				fieldV.Set(reflect.MakeSlice(reflect.SliceOf(reflect.TypeOf(int(1))), len(formVals), len(formVals)))
+				for i := 0; i < len(formVals); i++ {
+					val, err := strconv.Atoi(formVals[i])
+					if err != nil {
+						return err
+					}
+					fieldV.Index(i).SetInt(int64(val))
+				}
+			} else if fieldT.Type == sliceOfStrings {
+				formVals := form[tag]
+				fieldV.Set(reflect.MakeSlice(reflect.SliceOf(reflect.TypeOf("")), len(formVals), len(formVals)))
+				for i := 0; i < len(formVals); i++ {
+					fieldV.Index(i).SetString(formVals[i])
+				}
+			}
 		}
 	}
 	return nil
 }
 
+var sliceOfInts = reflect.TypeOf([]int(nil))
+var sliceOfStrings = reflect.TypeOf([]string(nil))
+
 var unKind = map[reflect.Kind]bool{
 	reflect.Uintptr:       true,
 	reflect.Complex64:     true,
@@ -368,23 +418,31 @@ func RenderForm(obj interface{}) template.HTML {
 
 		fieldT := objT.Field(i)
 
-		label, name, fType, ignored := parseFormTag(fieldT)
+		label, name, fType, id, class, ignored := parseFormTag(fieldT)
 		if ignored {
 			continue
 		}
 
-		raw = append(raw, renderFormField(label, name, fType, fieldV.Interface()))
+		raw = append(raw, renderFormField(label, name, fType, fieldV.Interface(), id, class))
 	}
 	return template.HTML(strings.Join(raw, "</br>"))
 }
 
 // renderFormField returns a string containing HTML of a single form field.
-func renderFormField(label, name, fType string, value interface{}) string {
-	if isValidForInput(fType) {
-		return fmt.Sprintf(`%v<input name="%v" type="%v" value="%v">`, label, name, fType, value)
+func renderFormField(label, name, fType string, value interface{}, id string, class string) string {
+	if id != "" {
+		id = " id=\"" + id + "\""
 	}
 
-	return fmt.Sprintf(`%v<%v name="%v">%v</%v>`, label, fType, name, value, fType)
+	if class != "" {
+		class = " class=\"" + class + "\""
+	}
+
+	if isValidForInput(fType) {
+		return fmt.Sprintf(`%v<input%v%v name="%v" type="%v" value="%v">`, label, id, class, name, fType, value)
+	}
+
+	return fmt.Sprintf(`%v<%v%v%v name="%v">%v</%v>`, label, fType, id, class, name, value, fType)
 }
 
 // isValidForInput checks if fType is a valid value for the `type` property of an HTML input element.
@@ -400,12 +458,14 @@ func isValidForInput(fType string) bool {
 
 // parseFormTag takes the stuct-tag of a StructField and parses the `form` value.
 // returned are the form label, name-property, type and wether the field should be ignored.
-func parseFormTag(fieldT reflect.StructField) (label, name, fType string, ignored bool) {
+func parseFormTag(fieldT reflect.StructField) (label, name, fType string, id string, class string, ignored bool) {
 	tags := strings.Split(fieldT.Tag.Get("form"), ",")
 	label = fieldT.Name + ": "
 	name = fieldT.Name
 	fType = "text"
 	ignored = false
+	id = fieldT.Tag.Get("id")
+	class = fieldT.Tag.Get("class")
 
 	switch len(tags) {
 	case 1:

templatefunc_test.go

@@ -72,7 +72,7 @@ func TestDate(t *testing.T) {
 	}
 }
 
-func TestCompare(t *testing.T) {
+func TestCompareRelated(t *testing.T) {
 	if !Compare("abc", "abc") {
 		t.Error("should be equal")
 	}
@@ -82,6 +82,15 @@ func TestCompare(t *testing.T) {
 	if !Compare("1", 1) {
 		t.Error("should be equal")
 	}
+    if CompareNot("abc", "abc") {
+        t.Error("should be equal")
+    }
+    if !CompareNot("abc", "aBc") {
+        t.Error("should be not equal")
+    }
+    if !NotNil("a string") {
+        t.Error("should not be nil")
+    }
 }
 
 func TestHtmlquote(t *testing.T) {
@@ -102,12 +111,14 @@ func TestHtmlunquote(t *testing.T) {
 
 func TestParseForm(t *testing.T) {
 	type user struct {
-		Id    int         `form:"-"`
-		tag   string      `form:"tag"`
-		Name  interface{} `form:"username"`
-		Age   int         `form:"age,text"`
-		Email string
-		Intro string `form:",textarea"`
+		Id      int         `form:"-"`
+		tag     string      `form:"tag"`
+		Name    interface{} `form:"username"`
+		Age     int         `form:"age,text"`
+		Email   string
+		Intro   string    `form:",textarea"`
+		StrBool bool      `form:"strbool"`
+		Date    time.Time `form:"date,2006-01-02"`
 	}
 
 	u := user{}
@@ -119,6 +130,8 @@ func TestParseForm(t *testing.T) {
 		"age":      []string{"40"},
 		"Email":    []string{"test@gmail.com"},
 		"Intro":    []string{"I am an engineer!"},
+		"strbool":  []string{"yes"},
+		"date":     []string{"2014-11-12"},
 	}
 	if err := ParseForm(form, u); err == nil {
 		t.Fatal("nothing will be changed")
@@ -144,6 +157,13 @@ func TestParseForm(t *testing.T) {
 	if u.Intro != "I am an engineer!" {
 		t.Errorf("Intro should equal `I am an engineer!` but got `%v`", u.Intro)
 	}
+	if u.StrBool != true {
+		t.Errorf("strboll should equal `true`, but got `%v`", u.StrBool)
+	}
+	y, m, d := u.Date.Date()
+	if y != 2014 || m.String() != "November" || d != 12 {
+		t.Errorf("Date should equal `2014-11-12`, but got `%v`", u.Date.String())
+	}
 }
 
 func TestRenderForm(t *testing.T) {
@@ -175,12 +195,12 @@ func TestRenderForm(t *testing.T) {
 }
 
 func TestRenderFormField(t *testing.T) {
-	html := renderFormField("Label: ", "Name", "text", "Value")
+	html := renderFormField("Label: ", "Name", "text", "Value", "", "")
 	if html != `Label: <input name="Name" type="text" value="Value">` {
 		t.Errorf("Wrong html output for input[type=text]: %v ", html)
 	}
 
-	html = renderFormField("Label: ", "Name", "textarea", "Value")
+	html = renderFormField("Label: ", "Name", "textarea", "Value", "", "")
 	if html != `Label: <textarea name="Name">Value</textarea>` {
 		t.Errorf("Wrong html output for textarea: %v ", html)
 	}
@@ -192,33 +212,34 @@ func TestParseFormTag(t *testing.T) {
 		All       int `form:"name,text,年龄："`
 		NoName    int `form:",hidden,年龄："`
 		OnlyLabel int `form:",,年龄："`
-		OnlyName  int `form:"name"`
+		OnlyName  int `form:"name" id:"name" class:"form-name"`
 		Ignored   int `form:"-"`
 	}
 
 	objT := reflect.TypeOf(&user{}).Elem()
 
-	label, name, fType, ignored := parseFormTag(objT.Field(0))
+	label, name, fType, id, class, ignored := parseFormTag(objT.Field(0))
 	if !(name == "name" && label == "年龄：" && fType == "text" && ignored == false) {
 		t.Errorf("Form Tag with name, label and type was not correctly parsed.")
 	}
 
-	label, name, fType, ignored = parseFormTag(objT.Field(1))
+	label, name, fType, id, class, ignored = parseFormTag(objT.Field(1))
 	if !(name == "NoName" && label == "年龄：" && fType == "hidden" && ignored == false) {
 		t.Errorf("Form Tag with label and type but without name was not correctly parsed.")
 	}
 
-	label, name, fType, ignored = parseFormTag(objT.Field(2))
+	label, name, fType, id, class, ignored = parseFormTag(objT.Field(2))
 	if !(name == "OnlyLabel" && label == "年龄：" && fType == "text" && ignored == false) {
 		t.Errorf("Form Tag containing only label was not correctly parsed.")
 	}
 
-	label, name, fType, ignored = parseFormTag(objT.Field(3))
-	if !(name == "name" && label == "OnlyName: " && fType == "text" && ignored == false) {
+	label, name, fType, id, class, ignored = parseFormTag(objT.Field(3))
+	if !(name == "name" && label == "OnlyName: " && fType == "text" && ignored == false &&
+		id == "name" && class == "form-name") {
 		t.Errorf("Form Tag containing only name was not correctly parsed.")
 	}
 
-	label, name, fType, ignored = parseFormTag(objT.Field(4))
+	label, name, fType, id, class, ignored = parseFormTag(objT.Field(4))
 	if ignored == false {
 		t.Errorf("Form Tag that should be ignored was not correctly parsed.")
 	}

toolbox/statistics.go

@@ -83,13 +83,16 @@ func (m *UrlMap) AddStatistics(requestMethod, requestUrl, requestController stri
 }
 
 // put url statistics result in io.Writer
-func (m *UrlMap) GetMap() [][]string {
+func (m *UrlMap) GetMap() map[string]interface{} {
 	m.lock.RLock()
 	defer m.lock.RUnlock()
-	resultLists := make([][]string, 0)
 
-	var result = []string{"requestUrl", "method", "times", "used", "max used", "min used", "avg used"}
-	resultLists = append(resultLists, result)
+	var fields = []string{"requestUrl", "method", "times", "used", "max used", "min used", "avg used"}
+
+	resultLists := make([][]string, 0)
+	content := make(map[string]interface{})
+	content["Fields"] = fields
+
 	for k, v := range m.urlmap {
 		for kk, vv := range v {
 			result := []string{
@@ -104,6 +107,28 @@ func (m *UrlMap) GetMap() [][]string {
 			resultLists = append(resultLists, result)
 		}
 	}
+	content["Data"] = resultLists
+	return content
+}
+
+func (m *UrlMap) GetMapData() []map[string]interface{} {
+
+	resultLists := make([]map[string]interface{}, 0)
+
+	for k, v := range m.urlmap {
+		for kk, vv := range v {
+			result := map[string]interface{}{
+				"request_url": k,
+				"method":      kk,
+				"times":       vv.RequestNum,
+				"total_time":  toS(vv.TotalTime),
+				"max_time":    toS(vv.MaxTime),
+				"min_time":    toS(vv.MinTime),
+				"avg_time":    toS(time.Duration(int64(vv.TotalTime) / vv.RequestNum)),
+			}
+			resultLists = append(resultLists, result)
+		}
+	}
 	return resultLists
 }
 

toolbox/statistics_test.go

@@ -15,6 +15,7 @@
 package toolbox
 
 import (
+	"encoding/json"
 	"testing"
 	"time"
 )
@@ -28,4 +29,12 @@ func TestStatics(t *testing.T) {
 	StatisticsMap.AddStatistics("POST", "/api/user/xiemengjun", "&admin.user", time.Duration(13000))
 	StatisticsMap.AddStatistics("DELETE", "/api/user", "&admin.user", time.Duration(1400))
 	t.Log(StatisticsMap.GetMap())
+
+	data := StatisticsMap.GetMapData()
+	b, err := json.Marshal(data)
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+
+	t.Log(string(b))
 }

toolbox/task.go

@@ -33,6 +33,8 @@ type bounds struct {
 var (
 	AdminTaskList map[string]Tasker
 	stop          chan bool
+	changed       chan bool
+	isstart       bool
 	seconds       = bounds{0, 59, nil}
 	minutes       = bounds{0, 59, nil}
 	hours         = bounds{0, 23, nil}
@@ -82,6 +84,7 @@ type TaskFunc func() error
 
 // task interface
 type Tasker interface {
+	GetSpec() string
 	GetStatus() string
 	Run() error
 	SetNext(time.Time)
@@ -100,6 +103,7 @@ type taskerr struct {
 type Task struct {
 	Taskname string
 	Spec     *Schedule
+	SpecStr  string
 	DoFunc   TaskFunc
 	Prev     time.Time
 	Next     time.Time
@@ -114,16 +118,22 @@ func NewTask(tname string, spec string, f TaskFunc) *Task {
 		Taskname: tname,
 		DoFunc:   f,
 		ErrLimit: 100,
+		SpecStr:  spec,
 	}
 	task.SetCron(spec)
 	return task
 }
 
+//get spec string
+func (s *Task) GetSpec() string {
+	return s.SpecStr
+}
+
 // get current task status
 func (tk *Task) GetStatus() string {
 	var str string
 	for _, v := range tk.Errlist {
-		str += v.t.String() + ":" + v.errinfo + "\n"
+		str += v.t.String() + ":" + v.errinfo + "<br>"
 	}
 	return str
 }
@@ -379,6 +389,7 @@ func dayMatches(s *Schedule, t time.Time) bool {
 
 // start all tasks
 func StartTask() {
+	isstart = true
 	go run()
 }
 
@@ -411,6 +422,8 @@ func run() {
 				e.SetNext(effective)
 			}
 			continue
+		case <-changed:
+			continue
 		case <-stop:
 			return
 		}
@@ -419,12 +432,24 @@ func run() {
 
 // start all tasks
 func StopTask() {
+	isstart = false
 	stop <- true
 }
 
 // add task with name
 func AddTask(taskname string, t Tasker) {
 	AdminTaskList[taskname] = t
+	if isstart {
+		changed <- true
+	}
+}
+
+// add task with name
+func DeleteTask(taskname string) {
+	delete(AdminTaskList, taskname)
+	if isstart {
+		changed <- true
+	}
 }
 
 // sort map for tasker
@@ -578,4 +603,5 @@ func all(r bounds) uint64 {
 func init() {
 	AdminTaskList = make(map[string]Tasker)
 	stop = make(chan bool)
+	changed = make(chan bool)
 }

tree.go

@@ -70,18 +70,23 @@ func (t *Tree) addtree(segments []string, tree *Tree, wildcards []string, reg st
 				} else {
 					regexpStr = "/" + regexpStr
 				}
-			} else {
-				for _, w := range wildcards {
-					if w == "." || w == ":" {
-						continue
+			} else if reg != "" {
+				if seg == "*.*" {
+					regexpStr = "([^.]+).(.+)"
+				} else {
+					for _, w := range params {
+						if w == "." || w == ":" {
+							continue
+						}
+						regexpStr = "([^/]+)/" + regexpStr
 					}
-					regexpStr = "([^/]+)/" + regexpStr
 				}
 			}
-			reg = strings.Trim(reg+regexpStr, "/")
+			reg = strings.Trim(reg+"/"+regexpStr, "/")
 			filterTreeWithPrefix(tree, append(wildcards, params...), reg)
 			t.wildcard = tree
 		} else {
+			reg = strings.Trim(reg+"/"+regexpStr, "/")
 			filterTreeWithPrefix(tree, append(wildcards, params...), reg)
 			t.fixrouters[seg] = tree
 		}
@@ -104,23 +109,23 @@ func (t *Tree) addtree(segments []string, tree *Tree, wildcards []string, reg st
 						rr = rr + "([^/]+)/"
 					}
 				}
-				regexpStr = rr + regexpStr + "/"
+				regexpStr = rr + regexpStr
 			} else {
-				regexpStr = "/" + regexpStr + "/"
+				regexpStr = "/" + regexpStr
 			}
-		} else {
-			for _, w := range wildcards {
-				if w == "." || w == ":" {
-					continue
-				}
-				if w == ":splat" {
-					regexpStr = "(.+)/" + regexpStr
-				} else {
+		} else if reg != "" {
+			if seg == "*.*" {
+				regexpStr = "([^.]+).(.+)"
+			} else {
+				for _, w := range params {
+					if w == "." || w == ":" {
+						continue
+					}
 					regexpStr = "([^/]+)/" + regexpStr
 				}
 			}
 		}
-		reg = reg + regexpStr
+		reg = strings.TrimRight(strings.TrimRight(reg, "/")+"/"+regexpStr, "/")
 		t.wildcard.addtree(segments[1:], tree, append(wildcards, params...), reg)
 	} else {
 		subTree := NewTree()
@@ -140,7 +145,7 @@ func filterTreeWithPrefix(t *Tree, wildcards []string, reg string) {
 		if reg != "" {
 			if l.regexps != nil {
 				l.wildcards = append(wildcards, l.wildcards...)
-				l.regexps = regexp.MustCompile("^" + reg + strings.Trim(l.regexps.String(), "^$") + "$")
+				l.regexps = regexp.MustCompile("^" + reg + "/" + strings.Trim(l.regexps.String(), "^$") + "$")
 			} else {
 				for _, v := range l.wildcards {
 					if v == ":" || v == "." {
@@ -237,11 +242,16 @@ func (t *Tree) addseg(segments []string, route interface{}, wildcards []string,
 					regexpStr = "/" + regexpStr
 				}
 			} else if reg != "" {
-				for _, w := range params {
-					if w == "." || w == ":" {
-						continue
+				if seg == "*.*" {
+					regexpStr = "/([^.]+).(.+)"
+				} else {
+					for _, w := range params {
+
+						if w == "." || w == ":" {
+							continue
+						}
+						regexpStr = "/([^/]+)" + regexpStr
 					}
-					regexpStr = "/([^/]+)" + regexpStr
 				}
 			}
 			t.wildcard.addseg(segments[1:], route, append(wildcards, params...), reg+regexpStr)
@@ -388,6 +398,9 @@ func (leaf *leafInfo) match(wildcardValues []string) (ok bool, params map[string
 				}
 				return true, params
 			}
+			if len(wildcardValues) <= j {
+				return false, nil
+			}
 			params[v] = wildcardValues[j]
 			j += 1
 		}
@@ -396,6 +409,7 @@ func (leaf *leafInfo) match(wildcardValues []string) (ok bool, params map[string
 		}
 		return true, params
 	}
+
 	if !leaf.regexps.MatchString(path.Join(wildcardValues...)) {
 		return false, nil
 	}
@@ -412,6 +426,9 @@ func (leaf *leafInfo) match(wildcardValues []string) (ok bool, params map[string
 // "/admin/" -> ["admin"]
 // "/admin/users" -> ["admin", "users"]
 func splitPath(key string) []string {
+	if key == "" {
+		return []string{}
+	}
 	elements := strings.Split(key, "/")
 	if elements[0] == "" {
 		elements = elements[1:]

tree_test.go

@@ -42,6 +42,9 @@ func init() {
 	routers = append(routers, testinfo{"/*.*", "/nice/api.json", map[string]string{":path": "nice/api", ":ext": "json"}})
 	routers = append(routers, testinfo{"/:name/*.*", "/nice/api.json", map[string]string{":name": "nice", ":path": "api", ":ext": "json"}})
 	routers = append(routers, testinfo{"/:name/test/*.*", "/nice/test/api.json", map[string]string{":name": "nice", ":path": "api", ":ext": "json"}})
+	routers = append(routers, testinfo{"/dl/:width:int/:height:int/*.*",
+		"/dl/48/48/05ac66d9bda00a3acf948c43e306fc9a.jpg",
+		map[string]string{":width": "48", ":height": "48", ":ext": "jpg", ":path": "05ac66d9bda00a3acf948c43e306fc9a"}})
 	routers = append(routers, testinfo{"/v1/shop/:id:int", "/v1/shop/123", map[string]string{":id": "123"}})
 	routers = append(routers, testinfo{"/:year:int/:month:int/:id/:endid", "/1111/111/aaa/aaa", map[string]string{":year": "1111", ":month": "111", ":id": "aaa", ":endid": "aaa"}})
 	routers = append(routers, testinfo{"/v1/shop/:id/:name", "/v1/shop/123/nike", map[string]string{":id": "123", ":name": "nike"}})
@@ -145,8 +148,56 @@ func TestAddTree2(t *testing.T) {
 	}
 }
 
+func TestAddTree3(t *testing.T) {
+	tr := NewTree()
+	tr.AddRouter("/create", "astaxie")
+	tr.AddRouter("/shop/:sd/account", "astaxie")
+	t3 := NewTree()
+	t3.AddTree("/table/:num", tr)
+	obj, param := t3.Match("/table/123/shop/123/account")
+	if obj == nil || obj.(string) != "astaxie" {
+		t.Fatal("/table/:num/shop/:sd/account can't get obj ")
+	}
+	if param == nil {
+		t.Fatal("get param error")
+	}
+	if param[":num"] != "123" || param[":sd"] != "123" {
+		t.Fatal("get :num :sd param error")
+	}
+	obj, param = t3.Match("/table/123/create")
+	if obj == nil || obj.(string) != "astaxie" {
+		t.Fatal("/table/:num/create can't get obj ")
+	}
+}
+
+func TestAddTree4(t *testing.T) {
+	tr := NewTree()
+	tr.AddRouter("/create", "astaxie")
+	tr.AddRouter("/shop/:sd/:account", "astaxie")
+	t4 := NewTree()
+	t4.AddTree("/:info:int/:num/:id", tr)
+	obj, param := t4.Match("/12/123/456/shop/123/account")
+	if obj == nil || obj.(string) != "astaxie" {
+		t.Fatal("/:info:int/:num/:id/shop/:sd/:account can't get obj ")
+	}
+	if param == nil {
+		t.Fatal("get param error")
+	}
+	if param[":info"] != "12" || param[":num"] != "123" || param[":id"] != "456" || param[":sd"] != "123" || param[":account"] != "account" {
+		t.Fatal("get :info :num :id :sd :account param error")
+	}
+	obj, param = t4.Match("/12/123/456/create")
+	if obj == nil || obj.(string) != "astaxie" {
+		t.Fatal("/:info:int/:num/:id/create can't get obj ")
+	}
+}
+
 func TestSplitPath(t *testing.T) {
-	a := splitPath("/")
+	a := splitPath("")
+	if len(a) != 0 {
+		t.Fatal("/ should retrun []")
+	}
+	a = splitPath("/")
 	if len(a) != 0 {
 		t.Fatal("/ should retrun []")
 	}

utils/captcha/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011-2014 Dmitry Chestnykh <dmitry@codingrobots.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

utils/captcha/captcha.go

@@ -132,15 +132,6 @@ func (c *Captcha) Handler(ctx *context.Context) {
 
 	key := c.key(id)
 
-	if v, ok := c.store.Get(key).([]byte); ok {
-		chars = v
-	} else {
-		ctx.Output.SetStatus(404)
-		ctx.WriteString("captcha not found")
-		return
-	}
-
-	// reload captcha
 	if len(ctx.Input.Query("reload")) > 0 {
 		chars = c.genRandChars()
 		if err := c.store.Put(key, chars, c.Expiration); err != nil {
@@ -149,6 +140,14 @@ func (c *Captcha) Handler(ctx *context.Context) {
 			beego.Error("Reload Create Captcha Error:", err)
 			return
 		}
+	} else {
+		if v, ok := c.store.Get(key).([]byte); ok {
+			chars = v
+		} else {
+			ctx.Output.SetStatus(404)
+			ctx.WriteString("captcha not found")
+			return
+		}
 	}
 
 	img := NewImage(chars, c.StdWidth, c.StdHeight)

utils/mail.go

@@ -157,19 +157,37 @@ func (e *Email) Bytes() ([]byte, error) {
 }
 
 // Add attach file to the send mail
-func (e *Email) AttachFile(filename string) (a *Attachment, err error) {
+func (e *Email) AttachFile(args ...string) (a *Attachment, err error) {
+	if len(args) < 1 && len(args) > 2 {
+		err = errors.New("Must specify a file name and number of parameters can not exceed at least two")
+		return
+	}
+	filename := args[0]
+	id := ""
+	if len(args) > 1 {
+		id = args[1]
+	}
 	f, err := os.Open(filename)
 	if err != nil {
 		return
 	}
 	ct := mime.TypeByExtension(filepath.Ext(filename))
 	basename := path.Base(filename)
-	return e.Attach(f, basename, ct)
+	return e.Attach(f, basename, ct, id)
 }
 
 // Attach is used to attach content from an io.Reader to the email.
 // Parameters include an io.Reader, the desired filename for the attachment, and the Content-Type.
-func (e *Email) Attach(r io.Reader, filename string, c string) (a *Attachment, err error) {
+func (e *Email) Attach(r io.Reader, filename string, args ...string) (a *Attachment, err error) {
+	if len(args) < 1 && len(args) > 2 {
+		err = errors.New("Must specify the file type and number of parameters can not exceed at least two")
+		return
+	}
+	c := args[0] //Content-Type
+	id := ""
+	if len(args) > 1 {
+		id = args[1] //Content-ID
+	}
 	var buffer bytes.Buffer
 	if _, err = io.Copy(&buffer, r); err != nil {
 		return
@@ -186,7 +204,12 @@ func (e *Email) Attach(r io.Reader, filename string, c string) (a *Attachment, e
 		// If the Content-Type is blank, set the Content-Type to "application/octet-stream"
 		at.Header.Set("Content-Type", "application/octet-stream")
 	}
-	at.Header.Set("Content-Disposition", fmt.Sprintf("attachment;\r\n filename=\"%s\"", filename))
+	if id != "" {
+		at.Header.Set("Content-Disposition", fmt.Sprintf("inline;\r\n filename=\"%s\"", filename))
+		at.Header.Set("Content-ID", fmt.Sprintf("<%s>", id))
+	} else {
+		at.Header.Set("Content-Disposition", fmt.Sprintf("attachment;\r\n filename=\"%s\"", filename))
+	}
 	at.Header.Set("Content-Transfer-Encoding", "base64")
 	e.Attachments = append(e.Attachments, at)
 	return at, nil

utils/pagination/controller.go

@@ -0,0 +1,26 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pagination
+
+import (
+	"github.com/astaxie/beego/context"
+)
+
+// Instantiates a Paginator and assigns it to context.Input.Data["paginator"].
+func SetPaginator(context *context.Context, per int, nums int64) (paginator *Paginator) {
+	paginator = NewPaginator(context.Request, per, nums)
+	context.Input.Data["paginator"] = &paginator
+	return
+}

utils/pagination/doc.go

@@ -0,0 +1,59 @@
+/*
+
+The pagination package provides utilities to setup a paginator within the
+context of a http request.
+
+Usage
+
+In your beego.Controller:
+
+ package controllers
+
+ import "github.com/astaxie/beego/utils/pagination"
+
+ type PostsController struct {
+   beego.Controller
+ }
+
+ func (this *PostsController) ListAllPosts() {
+     // sets this.Data["paginator"] with the current offset (from the url query param)
+     postsPerPage := 20
+     paginator := pagination.SetPaginator(this.Ctx, postsPerPage, CountPosts())
+
+     // fetch the next 20 posts
+     this.Data["posts"] = ListPostsByOffsetAndLimit(paginator.Offset(), postsPerPage)
+ }
+
+
+In your view templates:
+
+ {{if .paginator.HasPages}}
+ <ul class="pagination pagination">
+     {{if .paginator.HasPrev}}
+         <li><a href="{{.paginator.PageLinkFirst}}">{{ i18n .Lang "paginator.first_page"}}</a></li>
+         <li><a href="{{.paginator.PageLinkPrev}}">&laquo;</a></li>
+     {{else}}
+         <li class="disabled"><a>{{ i18n .Lang "paginator.first_page"}}</a></li>
+         <li class="disabled"><a>&laquo;</a></li>
+     {{end}}
+     {{range $index, $page := .paginator.Pages}}
+         <li{{if $.paginator.IsActive .}} class="active"{{end}}>
+             <a href="{{$.paginator.PageLink $page}}">{{$page}}</a>
+         </li>
+     {{end}}
+     {{if .paginator.HasNext}}
+         <li><a href="{{.paginator.PageLinkNext}}">&raquo;</a></li>
+         <li><a href="{{.paginator.PageLinkLast}}">{{ i18n .Lang "paginator.last_page"}}</a></li>
+     {{else}}
+         <li class="disabled"><a>&raquo;</a></li>
+         <li class="disabled"><a>{{ i18n .Lang "paginator.last_page"}}</a></li>
+     {{end}}
+ </ul>
+ {{end}}
+
+See also
+
+http://beego.me/docs/mvc/view/page.md
+
+*/
+package pagination

utils/pagination/paginator.go

@@ -0,0 +1,189 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pagination
+
+import (
+	"math"
+	"net/http"
+	"net/url"
+	"strconv"
+)
+
+// Paginator within the state of a http request.
+type Paginator struct {
+	Request     *http.Request
+	PerPageNums int
+	MaxPages    int
+
+	nums      int64
+	pageRange []int
+	pageNums  int
+	page      int
+}
+
+// Returns the total number of pages.
+func (p *Paginator) PageNums() int {
+	if p.pageNums != 0 {
+		return p.pageNums
+	}
+	pageNums := math.Ceil(float64(p.nums) / float64(p.PerPageNums))
+	if p.MaxPages > 0 {
+		pageNums = math.Min(pageNums, float64(p.MaxPages))
+	}
+	p.pageNums = int(pageNums)
+	return p.pageNums
+}
+
+// Returns the total number of items (e.g. from doing SQL count).
+func (p *Paginator) Nums() int64 {
+	return p.nums
+}
+
+// Sets the total number of items.
+func (p *Paginator) SetNums(nums interface{}) {
+	p.nums, _ = ToInt64(nums)
+}
+
+// Returns the current page.
+func (p *Paginator) Page() int {
+	if p.page != 0 {
+		return p.page
+	}
+	if p.Request.Form == nil {
+		p.Request.ParseForm()
+	}
+	p.page, _ = strconv.Atoi(p.Request.Form.Get("p"))
+	if p.page > p.PageNums() {
+		p.page = p.PageNums()
+	}
+	if p.page <= 0 {
+		p.page = 1
+	}
+	return p.page
+}
+
+// Returns a list of all pages.
+//
+// Usage (in a view template):
+//
+//  {{range $index, $page := .paginator.Pages}}
+//    <li{{if $.paginator.IsActive .}} class="active"{{end}}>
+//      <a href="{{$.paginator.PageLink $page}}">{{$page}}</a>
+//    </li>
+//  {{end}}
+func (p *Paginator) Pages() []int {
+	if p.pageRange == nil && p.nums > 0 {
+		var pages []int
+		pageNums := p.PageNums()
+		page := p.Page()
+		switch {
+		case page >= pageNums-4 && pageNums > 9:
+			start := pageNums - 9 + 1
+			pages = make([]int, 9)
+			for i := range pages {
+				pages[i] = start + i
+			}
+		case page >= 5 && pageNums > 9:
+			start := page - 5 + 1
+			pages = make([]int, int(math.Min(9, float64(page+4+1))))
+			for i := range pages {
+				pages[i] = start + i
+			}
+		default:
+			pages = make([]int, int(math.Min(9, float64(pageNums))))
+			for i := range pages {
+				pages[i] = i + 1
+			}
+		}
+		p.pageRange = pages
+	}
+	return p.pageRange
+}
+
+// Returns URL for a given page index.
+func (p *Paginator) PageLink(page int) string {
+	link, _ := url.ParseRequestURI(p.Request.URL.String())
+	values := link.Query()
+	if page == 1 {
+		values.Del("p")
+	} else {
+		values.Set("p", strconv.Itoa(page))
+	}
+	link.RawQuery = values.Encode()
+	return link.String()
+}
+
+// Returns URL to the previous page.
+func (p *Paginator) PageLinkPrev() (link string) {
+	if p.HasPrev() {
+		link = p.PageLink(p.Page() - 1)
+	}
+	return
+}
+
+// Returns URL to the next page.
+func (p *Paginator) PageLinkNext() (link string) {
+	if p.HasNext() {
+		link = p.PageLink(p.Page() + 1)
+	}
+	return
+}
+
+// Returns URL to the first page.
+func (p *Paginator) PageLinkFirst() (link string) {
+	return p.PageLink(1)
+}
+
+// Returns URL to the last page.
+func (p *Paginator) PageLinkLast() (link string) {
+	return p.PageLink(p.PageNums())
+}
+
+// Returns true if the current page has a predecessor.
+func (p *Paginator) HasPrev() bool {
+	return p.Page() > 1
+}
+
+// Returns true if the current page has a successor.
+func (p *Paginator) HasNext() bool {
+	return p.Page() < p.PageNums()
+}
+
+// Returns true if the given page index points to the current page.
+func (p *Paginator) IsActive(page int) bool {
+	return p.Page() == page
+}
+
+// Returns the current offset.
+func (p *Paginator) Offset() int {
+	return (p.Page() - 1) * p.PerPageNums
+}
+
+// Returns true if there is more than one page.
+func (p *Paginator) HasPages() bool {
+	return p.PageNums() > 1
+}
+
+// Instantiates a paginator struct for the current http request.
+func NewPaginator(req *http.Request, per int, nums interface{}) *Paginator {
+	p := Paginator{}
+	p.Request = req
+	if per <= 0 {
+		per = 10
+	}
+	p.PerPageNums = per
+	p.SetNums(nums)
+	return &p
+}

utils/pagination/utils.go

@@ -0,0 +1,34 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pagination
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// convert any numeric value to int64
+func ToInt64(value interface{}) (d int64, err error) {
+	val := reflect.ValueOf(value)
+	switch value.(type) {
+	case int, int8, int16, int32, int64:
+		d = val.Int()
+	case uint, uint8, uint16, uint32, uint64:
+		d = int64(val.Uint())
+	default:
+		err = fmt.Errorf("ToInt64 need numeric not `%T`", value)
+	}
+	return
+}

utils/slice.go

@@ -51,7 +51,7 @@ func SliceRandList(min, max int) []int {
 	t0 := time.Now()
 	rand.Seed(int64(t0.Nanosecond()))
 	list := rand.Perm(length)
-	for index, _ := range list {
+	for index := range list {
 		list[index] += min
 	}
 	return list
@@ -106,10 +106,10 @@ func SliceDiff(slice1, slice2 []interface{}) (diffslice []interface{}) {
 	return
 }
 
-// SliceIntersect returns diff slice of slice1 - slice2.
+// SliceIntersect returns slice that are present in all the slice1 and slice2.
 func SliceIntersect(slice1, slice2 []interface{}) (diffslice []interface{}) {
 	for _, v := range slice1 {
-		if !InSliceIface(v, slice2) {
+		if InSliceIface(v, slice2) {
 			diffslice = append(diffslice, v)
 		}
 	}

validation/util.go

@@ -137,7 +137,7 @@ func getRegFuncs(tag, key string) (vfs []ValidFunc, str string, err error) {
 	if err != nil {
 		return
 	}
-	vfs = []ValidFunc{ValidFunc{"Match", []interface{}{reg, key + ".Match"}}}
+	vfs = []ValidFunc{{"Match", []interface{}{reg, key + ".Match"}}}
 	str = strings.TrimSpace(tag[:index]) + strings.TrimSpace(tag[end+len("/)"):])
 	return
 }