Merge branch 'astaxie-master'

+.idea
 .DS_Store
 .DS_Store
 *.swp
 *.swp
 *.swo
 *.swo

+{
+    "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"
+    ]
+}

@@ -2,9 +2,7 @@
 
 
 [![Build Status](https://drone.io/github.com/astaxie/beego/status.png)](https://drone.io/github.com/astaxie/beego/latest)
 [![Build Status](https://drone.io/github.com/astaxie/beego/status.png)](https://drone.io/github.com/astaxie/beego/latest)
 
 
-beego is a Go Framework inspired by tornado and sinatra.
-
-It is a simple & powerful web framework.
+beego is an open-source, high-performance, modularity, full-stack web framework.
 
 
 More info [beego.me](http://beego.me)
 More info [beego.me](http://beego.me)
 
 
@@ -12,20 +10,18 @@ More info [beego.me](http://beego.me)
 
 
 * RESTful support
 * RESTful support
 * MVC architecture
 * MVC architecture
-* Session support (store in memory, file, Redis or MySQL)
-* Cache support (store in memory, Redis or Memcache)
-* Global Config
-* Intelligent routing
-* Thread-safe map
-* Friendly displaying of errors
-* Useful template functions
-
+* modularity
+* auto API documents
+* annotation router
+* namespace
+* powerful develop tools
+* full stack for web & API
 
 
 ## Documentation
 ## Documentation
 
 
 [English](http://beego.me/docs/intro/)
 [English](http://beego.me/docs/intro/)
 
 
-[API](http://gowalker.org/github.com/astaxie/beego)
+[API](http://godoc.org/github.com/astaxie/beego)
 
 
 [中文文档](http://beego.me/docs/intro/)
 [中文文档](http://beego.me/docs/intro/)
 
 
@@ -33,7 +29,4 @@ More info [beego.me](http://beego.me)
 ## LICENSE
 ## LICENSE
 
 
 beego is licensed under the Apache Licence, Version 2.0
 beego is licensed under the Apache Licence, Version 2.0
-(http://www.apache.org/licenses/LICENSE-2.0.html).
-
-[![Clone in Koding](http://learn.koding.com/btn/clone_d.png)][koding]
-[koding]: https://koding.com/Teamwork?import=https://github.com/astaxie/beego/archive/master.zip&c=git1
\ No newline at end of file
+(http://www.apache.org/licenses/LICENSE-2.0.html).
\ No newline at end of file

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package beego
 
 
@@ -66,6 +74,7 @@ func (app *App) Run() {
 
 
 		if EnableHttpTLS {
 		if EnableHttpTLS {
 			go func() {
 			go func() {
+				time.Sleep(20 * time.Microsecond)
 				if HttpsPort != 0 {
 				if HttpsPort != 0 {
 					app.Server.Addr = fmt.Sprintf("%s:%d", HttpAddr, HttpsPort)
 					app.Server.Addr = fmt.Sprintf("%s:%d", HttpAddr, HttpsPort)
 				}
 				}
@@ -80,6 +89,7 @@ func (app *App) Run() {
 
 
 		if EnableHttpListen {
 		if EnableHttpListen {
 			go func() {
 			go func() {
+				app.Server.Addr = addr
 				err := app.Server.ListenAndServe()
 				err := app.Server.ListenAndServe()
 				if err != nil {
 				if err != nil {
 					BeeLogger.Critical("ListenAndServe: ", err)
 					BeeLogger.Critical("ListenAndServe: ", err)

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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.
 
 
+// beego is an open-source, high-performance, modularity, full-stack web framework
+//
+//		package main
+//
+// 		import "github.com/astaxie/beego"
+//
+//		 func main() {
+//  			  beego.Run()
+// 		}
+//
+// more infomation: http://beego.me
 package beego
 package beego
 
 
 import (
 import (
@@ -19,7 +38,7 @@ import (
 )
 )
 
 
 // beego web framework version.
 // beego web framework version.
-const VERSION = "1.3.1"
+const VERSION = "1.4.0"
 
 
 type hookfunc func() error //hook function to run
 type hookfunc func() error //hook function to run
 var hooks []hookfunc       //hook function slice to store the hookfunc
 var hooks []hookfunc       //hook function slice to store the hookfunc
@@ -359,6 +378,7 @@ func initBeforeHttpRun() {
 				`"sessionIDHashFunc":"` + SessionHashFunc + `",` +
 				`"sessionIDHashFunc":"` + SessionHashFunc + `",` +
 				`"sessionIDHashKey":"` + SessionHashKey + `",` +
 				`"sessionIDHashKey":"` + SessionHashKey + `",` +
 				`"enableSetCookie":` + strconv.FormatBool(SessionAutoSetCookie) + `,` +
 				`"enableSetCookie":` + strconv.FormatBool(SessionAutoSetCookie) + `,` +
+				`"domain":"` + SessionDomain + `",` +
 				`"cookieLifeTime":` + strconv.Itoa(SessionCookieLifeTime) + `}`
 				`"cookieLifeTime":` + strconv.Itoa(SessionCookieLifeTime) + `}`
 		}
 		}
 		GlobalSessions, err = session.NewManager(SessionProvider,
 		GlobalSessions, err = session.NewManager(SessionProvider,
@@ -380,14 +400,13 @@ func initBeforeHttpRun() {
 	middleware.AppName = AppName
 	middleware.AppName = AppName
 	middleware.RegisterErrorHandler()
 	middleware.RegisterErrorHandler()
 
 
-	for u, _ := range StaticDir {
-		Get(u, serverStaticRouter)
-		Get(u+"/*", serverStaticRouter)
-	}
 	if EnableDocs {
 	if EnableDocs {
 		Get("/docs", serverDocs)
 		Get("/docs", serverDocs)
 		Get("/docs/*", serverDocs)
 		Get("/docs/*", serverDocs)
 	}
 	}
+
+	//init mime
+	AddAPPStartHook(initMime)
 }
 }
 
 
 // this function is for test package init
 // this function is for test package init
@@ -406,6 +425,4 @@ func TestBeegoInit(apppath string) {
 
 
 func init() {
 func init() {
 	hooks = make([]hookfunc, 0)
 	hooks = make([]hookfunc, 0)
-	//init mime
-	AddAPPStartHook(initMime)
 }
 }

@@ -22,7 +22,7 @@ First you must import it
 
 
 Then init a Cache (example with memory adapter)
 Then init a Cache (example with memory adapter)
 
 
-	bm, err := NewCache("memory", `{"interval":60}`)	
+	bm, err := cache.NewCache("memory", `{"interval":60}`)	
 
 
 Use it like this:	
 Use it like this:	
 	
 	

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
+// Usage:
+//
+// import(
+//   "github.com/astaxie/beego/cache"
+// )
+//
+// bm, err := cache.NewCache("memory", `{"interval":60}`)
+//
+// Use it like this:
+//
+//	bm.Put("astaxie", 1, 10)
+//	bm.Get("astaxie")
+//	bm.IsExist("astaxie")
+//	bm.Delete("astaxie")
+//
+//  more docs http://beego.me/docs/module/cache.md
 package cache
 package cache
 
 
 import (
 import (
@@ -13,7 +37,7 @@ import (
 // Cache interface contains all behaviors for cache adapter.
 // Cache interface contains all behaviors for cache adapter.
 // usage:
 // usage:
 //	cache.Register("file",cache.NewFileCache()) // this operation is run in init method of file.go.
 //	cache.Register("file",cache.NewFileCache()) // this operation is run in init method of file.go.
-//	c := cache.NewCache("file","{....}")
+//	c,err := cache.NewCache("file","{....}")
 //	c.Put("key",value,3600)
 //	c.Put("key",value,3600)
 //	v := c.Get("key")
 //	v := c.Get("key")
 //
 //
@@ -31,11 +55,11 @@ type Cache interface {
 	Incr(key string) error
 	Incr(key string) error
 	// decrease cached int value by key, as a counter.
 	// decrease cached int value by key, as a counter.
 	Decr(key string) error
 	Decr(key string) error
-	// check cached value is existed or not.
+	// check if cached value exists or not.
 	IsExist(key string) bool
 	IsExist(key string) bool
 	// clear all cache.
 	// clear all cache.
 	ClearAll() error
 	ClearAll() error
-	// start gc routine via config string setting.
+	// start gc routine based on config string settings.
 	StartAndGC(config string) error
 	StartAndGC(config string) error
 }
 }
 
 
@@ -48,23 +72,24 @@ func Register(name string, adapter Cache) {
 	if adapter == nil {
 	if adapter == nil {
 		panic("cache: Register adapter is nil")
 		panic("cache: Register adapter is nil")
 	}
 	}
-	if _, dup := adapters[name]; dup {
+	if _, ok := adapters[name]; ok {
 		panic("cache: Register called twice for adapter " + name)
 		panic("cache: Register called twice for adapter " + name)
 	}
 	}
 	adapters[name] = adapter
 	adapters[name] = adapter
 }
 }
 
 
-// Create a new cache driver by adapter and config string.
+// Create a new cache driver by adapter name and config string.
 // config need to be correct JSON as string: {"interval":360}.
 // config need to be correct JSON as string: {"interval":360}.
 // it will start gc automatically.
 // it will start gc automatically.
-func NewCache(adapterName, config string) (Cache, error) {
+func NewCache(adapterName, config string) (adapter Cache, e error) {
 	adapter, ok := adapters[adapterName]
 	adapter, ok := adapters[adapterName]
 	if !ok {
 	if !ok {
-		return nil, fmt.Errorf("cache: unknown adaptername %q (forgotten import?)", adapterName)
+		e = fmt.Errorf("cache: unknown adapter name %q (forgot to import?)", adapterName)
+		return
 	}
 	}
 	err := adapter.StartAndGC(config)
 	err := adapter.StartAndGC(config)
 	if err != nil {
 	if err != nil {
-		return nil, err
+		adapter = nil
 	}
 	}
-	return adapter, nil
+	return
 }
 }

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 cache
 package cache
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 cache
 package cache
 
 
@@ -19,12 +27,11 @@ func GetString(v interface{}) string {
 	case []byte:
 	case []byte:
 		return string(result)
 		return string(result)
 	default:
 	default:
-		if v == nil {
-			return ""
-		} else {
+		if v != nil {
 			return fmt.Sprintf("%v", result)
 			return fmt.Sprintf("%v", result)
 		}
 		}
 	}
 	}
+	return ""
 }
 }
 
 
 // convert interface to int.
 // convert interface to int.
@@ -37,12 +44,9 @@ func GetInt(v interface{}) int {
 	case int64:
 	case int64:
 		return int(result)
 		return int(result)
 	default:
 	default:
-		d := GetString(v)
-		if d != "" {
-			value, err := strconv.Atoi(d)
-			if err == nil {
-				return value
-			}
+		if d := GetString(v); d != "" {
+			value, _ := strconv.Atoi(d)
+			return value
 		}
 		}
 	}
 	}
 	return 0
 	return 0
@@ -58,12 +62,10 @@ func GetInt64(v interface{}) int64 {
 	case int64:
 	case int64:
 		return result
 		return result
 	default:
 	default:
-		d := GetString(v)
-		if d != "" {
-			result, err := strconv.ParseInt(d, 10, 64)
-			if err == nil {
-				return result
-			}
+
+		if d := GetString(v); d != "" {
+			value, _ := strconv.ParseInt(d, 10, 64)
+			return value
 		}
 		}
 	}
 	}
 	return 0
 	return 0
@@ -75,12 +77,9 @@ func GetFloat64(v interface{}) float64 {
 	case float64:
 	case float64:
 		return result
 		return result
 	default:
 	default:
-		d := GetString(v)
-		if d != "" {
-			value, err := strconv.ParseFloat(d, 64)
-			if err == nil {
-				return value
-			}
+		if d := GetString(v); d != "" {
+			value, _ := strconv.ParseFloat(d, 64)
+			return value
 		}
 		}
 	}
 	}
 	return 0
 	return 0
@@ -92,12 +91,9 @@ func GetBool(v interface{}) bool {
 	case bool:
 	case bool:
 		return result
 		return result
 	default:
 	default:
-		d := GetString(v)
-		if d != "" {
-			result, err := strconv.ParseBool(d)
-			if err == nil {
-				return result
-			}
+		if d := GetString(v); d != "" {
+			value, _ := strconv.ParseBool(d)
+			return value
 		}
 		}
 	}
 	}
 	return false
 	return false

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 cache
 package cache
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 cache
 package cache
 
 
@@ -57,12 +65,10 @@ func NewFileCache() *FileCache {
 
 
 // Start and begin gc for file cache.
 // Start and begin gc for file cache.
 // the config need to be like {CachePath:"/cache","FileSuffix":".bin","DirectoryLevel":2,"EmbedExpiry":0}
 // the config need to be like {CachePath:"/cache","FileSuffix":".bin","DirectoryLevel":2,"EmbedExpiry":0}
-func (this *FileCache) StartAndGC(config string) error {
+func (fc *FileCache) StartAndGC(config string) error {
 
 
 	var cfg map[string]string
 	var cfg map[string]string
 	json.Unmarshal([]byte(config), &cfg)
 	json.Unmarshal([]byte(config), &cfg)
-	//fmt.Println(cfg)
-	//fmt.Println(config)
 	if _, ok := cfg["CachePath"]; !ok {
 	if _, ok := cfg["CachePath"]; !ok {
 		cfg["CachePath"] = FileCachePath
 		cfg["CachePath"] = FileCachePath
 	}
 	}
@@ -75,69 +81,53 @@ func (this *FileCache) StartAndGC(config string) error {
 	if _, ok := cfg["EmbedExpiry"]; !ok {
 	if _, ok := cfg["EmbedExpiry"]; !ok {
 		cfg["EmbedExpiry"] = strconv.FormatInt(FileCacheEmbedExpiry, 10)
 		cfg["EmbedExpiry"] = strconv.FormatInt(FileCacheEmbedExpiry, 10)
 	}
 	}
-	this.CachePath = cfg["CachePath"]
-	this.FileSuffix = cfg["FileSuffix"]
-	this.DirectoryLevel, _ = strconv.Atoi(cfg["DirectoryLevel"])
-	this.EmbedExpiry, _ = strconv.Atoi(cfg["EmbedExpiry"])
+	fc.CachePath = cfg["CachePath"]
+	fc.FileSuffix = cfg["FileSuffix"]
+	fc.DirectoryLevel, _ = strconv.Atoi(cfg["DirectoryLevel"])
+	fc.EmbedExpiry, _ = strconv.Atoi(cfg["EmbedExpiry"])
 
 
-	this.Init()
+	fc.Init()
 	return nil
 	return nil
 }
 }
 
 
 // Init will make new dir for file cache if not exist.
 // Init will make new dir for file cache if not exist.
-func (this *FileCache) Init() {
+func (fc *FileCache) Init() {
 	app := filepath.Dir(os.Args[0])
 	app := filepath.Dir(os.Args[0])
-	this.CachePath = filepath.Join(app, this.CachePath)
-	ok, err := exists(this.CachePath)
-	if err != nil { // print error
-		//fmt.Println(err)
+	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
 	}
 	}
-	if !ok {
-		if err = os.Mkdir(this.CachePath, os.ModePerm); err != nil {
-			//fmt.Println(err);
-		}
-	}
-	//fmt.Println(this.getCacheFileName("123456"));
 }
 }
 
 
 // get cached file name. it's md5 encoded.
 // get cached file name. it's md5 encoded.
-func (this *FileCache) getCacheFileName(key string) string {
+func (fc *FileCache) getCacheFileName(key string) string {
 	m := md5.New()
 	m := md5.New()
 	io.WriteString(m, key)
 	io.WriteString(m, key)
 	keyMd5 := hex.EncodeToString(m.Sum(nil))
 	keyMd5 := hex.EncodeToString(m.Sum(nil))
-	cachePath := this.CachePath
-	//fmt.Println("cachepath : " , cachePath)
-	//fmt.Println("md5" , keyMd5);
-	switch this.DirectoryLevel {
+	cachePath := fc.CachePath
+	switch fc.DirectoryLevel {
 	case 2:
 	case 2:
 		cachePath = filepath.Join(cachePath, keyMd5[0:2], keyMd5[2:4])
 		cachePath = filepath.Join(cachePath, keyMd5[0:2], keyMd5[2:4])
 	case 1:
 	case 1:
 		cachePath = filepath.Join(cachePath, keyMd5[0:2])
 		cachePath = filepath.Join(cachePath, keyMd5[0:2])
 	}
 	}
 
 
-	ok, err := exists(cachePath)
-	if err != nil {
-		//fmt.Println(err)
+	if ok, _ := exists(cachePath); !ok { // todo : error handle
+		_ = os.MkdirAll(cachePath, os.ModePerm) // todo : error handle
 	}
 	}
-	if !ok {
-		if err = os.MkdirAll(cachePath, os.ModePerm); err != nil {
-			//fmt.Println(err);
-		}
-	}
-	return filepath.Join(cachePath, fmt.Sprintf("%s%s", keyMd5, this.FileSuffix))
+
+	return filepath.Join(cachePath, fmt.Sprintf("%s%s", keyMd5, fc.FileSuffix))
 }
 }
 
 
 // Get value from file cache.
 // Get value from file cache.
 // if non-exist or expired, return empty string.
 // if non-exist or expired, return empty string.
-func (this *FileCache) Get(key string) interface{} {
-	filename := this.getCacheFileName(key)
-	filedata, err := File_get_contents(filename)
-	//fmt.Println("get length:" , len(filedata));
+func (fc *FileCache) Get(key string) interface{} {
+	fileData, err := File_get_contents(fc.getCacheFileName(key))
 	if err != nil {
 	if err != nil {
 		return ""
 		return ""
 	}
 	}
 	var to FileCacheItem
 	var to FileCacheItem
-	Gob_decode(filedata, &to)
+	Gob_decode(fileData, &to)
 	if to.Expired < time.Now().Unix() {
 	if to.Expired < time.Now().Unix() {
 		return ""
 		return ""
 	}
 	}
@@ -147,12 +137,10 @@ func (this *FileCache) Get(key string) interface{} {
 // Put value into file cache.
 // Put value into file cache.
 // timeout means how long to keep this file, unit of ms.
 // timeout means how long to keep this file, unit of ms.
 // if timeout equals FileCacheEmbedExpiry(default is 0), cache this item forever.
 // if timeout equals FileCacheEmbedExpiry(default is 0), cache this item forever.
-func (this *FileCache) Put(key string, val interface{}, timeout int64) error {
+func (fc *FileCache) Put(key string, val interface{}, timeout int64) error {
 	gob.Register(val)
 	gob.Register(val)
 
 
-	filename := this.getCacheFileName(key)
-	var item FileCacheItem
-	item.Data = val
+	item := FileCacheItem{Data: val}
 	if timeout == FileCacheEmbedExpiry {
 	if timeout == FileCacheEmbedExpiry {
 		item.Expired = time.Now().Unix() + (86400 * 365 * 10) // ten years
 		item.Expired = time.Now().Unix() + (86400 * 365 * 10) // ten years
 	} else {
 	} else {
@@ -163,13 +151,12 @@ func (this *FileCache) Put(key string, val interface{}, timeout int64) error {
 	if err != nil {
 	if err != nil {
 		return err
 		return err
 	}
 	}
-	err = File_put_contents(filename, data)
-	return err
+	return File_put_contents(fc.getCacheFileName(key), data)
 }
 }
 
 
 // Delete file cache value.
 // Delete file cache value.
-func (this *FileCache) Delete(key string) error {
-	filename := this.getCacheFileName(key)
+func (fc *FileCache) Delete(key string) error {
+	filename := fc.getCacheFileName(key)
 	if ok, _ := exists(filename); ok {
 	if ok, _ := exists(filename); ok {
 		return os.Remove(filename)
 		return os.Remove(filename)
 	}
 	}
@@ -177,44 +164,41 @@ func (this *FileCache) Delete(key string) error {
 }
 }
 
 
 // Increase cached int value.
 // Increase cached int value.
-// this value is saving forever unless Delete.
-func (this *FileCache) Incr(key string) error {
-	data := this.Get(key)
+// fc value is saving forever unless Delete.
+func (fc *FileCache) Incr(key string) error {
+	data := fc.Get(key)
 	var incr int
 	var incr int
-	//fmt.Println(reflect.TypeOf(data).Name())
 	if reflect.TypeOf(data).Name() != "int" {
 	if reflect.TypeOf(data).Name() != "int" {
 		incr = 0
 		incr = 0
 	} else {
 	} else {
 		incr = data.(int) + 1
 		incr = data.(int) + 1
 	}
 	}
-	this.Put(key, incr, FileCacheEmbedExpiry)
+	fc.Put(key, incr, FileCacheEmbedExpiry)
 	return nil
 	return nil
 }
 }
 
 
 // Decrease cached int value.
 // Decrease cached int value.
-func (this *FileCache) Decr(key string) error {
-	data := this.Get(key)
+func (fc *FileCache) Decr(key string) error {
+	data := fc.Get(key)
 	var decr int
 	var decr int
 	if reflect.TypeOf(data).Name() != "int" || data.(int)-1 <= 0 {
 	if reflect.TypeOf(data).Name() != "int" || data.(int)-1 <= 0 {
 		decr = 0
 		decr = 0
 	} else {
 	} else {
 		decr = data.(int) - 1
 		decr = data.(int) - 1
 	}
 	}
-	this.Put(key, decr, FileCacheEmbedExpiry)
+	fc.Put(key, decr, FileCacheEmbedExpiry)
 	return nil
 	return nil
 }
 }
 
 
 // Check value is exist.
 // Check value is exist.
-func (this *FileCache) IsExist(key string) bool {
-	filename := this.getCacheFileName(key)
-	ret, _ := exists(filename)
+func (fc *FileCache) IsExist(key string) bool {
+	ret, _ := exists(fc.getCacheFileName(key))
 	return ret
 	return ret
 }
 }
 
 
 // Clean cached files.
 // Clean cached files.
 // not implemented.
 // not implemented.
-func (this *FileCache) ClearAll() error {
-	//this.CachePath
+func (fc *FileCache) ClearAll() error {
 	return nil
 	return nil
 }
 }
 
 
@@ -232,22 +216,22 @@ func exists(path string) (bool, error) {
 
 
 // Get bytes to file.
 // Get bytes to file.
 // if non-exist, create this file.
 // if non-exist, create this file.
-func File_get_contents(filename string) ([]byte, error) {
-	f, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
-	if err != nil {
-		return []byte(""), err
+func File_get_contents(filename string) (data []byte, e error) {
+	f, e := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
+	if e != nil {
+		return
 	}
 	}
 	defer f.Close()
 	defer f.Close()
-	stat, err := f.Stat()
-	if err != nil {
-		return []byte(""), err
+	stat, e := f.Stat()
+	if e != nil {
+		return
 	}
 	}
-	data := make([]byte, stat.Size())
-	result, err := f.Read(data)
-	if int64(result) == stat.Size() {
-		return data, err
+	data = make([]byte, stat.Size())
+	result, e := f.Read(data)
+	if e != nil || int64(result) != stat.Size() {
+		return nil, e
 	}
 	}
-	return []byte(""), err
+	return
 }
 }
 
 
 // Put bytes to file.
 // Put bytes to file.

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
-
-package cache
+// 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 memcahe for cache provider
+//
+// depend on github.com/bradfitz/gomemcache/memcache
+//
+// go install github.com/bradfitz/gomemcache/memcache
+//
+// Usage:
+// import(
+//   _ "github.com/astaxie/beego/cache/memcache"
+//   "github.com/astaxie/beego/cache"
+// )
+//
+//  bm, err := cache.NewCache("memcache", `{"conn":"127.0.0.1:11211"}`)
+//
+//  more docs http://beego.me/docs/module/cache.md
+package memcache
 
 
 import (
 import (
 	"encoding/json"
 	"encoding/json"
 	"errors"
 	"errors"
+	"strings"
 
 
-	"github.com/beego/memcache"
+	"github.com/bradfitz/gomemcache/memcache"
 
 
 	"github.com/astaxie/beego/cache"
 	"github.com/astaxie/beego/cache"
 )
 )
 
 
 // Memcache adapter.
 // Memcache adapter.
 type MemcacheCache struct {
 type MemcacheCache struct {
-	c        *memcache.Connection
-	conninfo string
+	conn     *memcache.Client
+	conninfo []string
 }
 }
 
 
 // create new memcache adapter.
 // create new memcache adapter.
@@ -28,32 +52,21 @@ func NewMemCache() *MemcacheCache {
 
 
 // get value from memcache.
 // get value from memcache.
 func (rc *MemcacheCache) Get(key string) interface{} {
 func (rc *MemcacheCache) Get(key string) interface{} {
-	if rc.c == nil {
-		var err error
-		rc.c, err = rc.connectInit()
-		if err != nil {
+	if rc.conn == nil {
+		if err := rc.connectInit(); err != nil {
 			return err
 			return err
 		}
 		}
 	}
 	}
-	v, err := rc.c.Get(key)
-	if err != nil {
-		return nil
-	}
-	var contain interface{}
-	if len(v) > 0 {
-		contain = string(v[0].Value)
-	} else {
-		contain = nil
+	if item, err := rc.conn.Get(key); err == nil {
+		return string(item.Value)
 	}
 	}
-	return contain
+	return nil
 }
 }
 
 
 // put value to memcache. only support string.
 // put value to memcache. only support string.
 func (rc *MemcacheCache) Put(key string, val interface{}, timeout int64) error {
 func (rc *MemcacheCache) Put(key string, val interface{}, timeout int64) error {
-	if rc.c == nil {
-		var err error
-		rc.c, err = rc.connectInit()
-		if err != nil {
+	if rc.conn == nil {
+		if err := rc.connectInit(); err != nil {
 			return err
 			return err
 		}
 		}
 	}
 	}
@@ -61,69 +74,64 @@ func (rc *MemcacheCache) Put(key string, val interface{}, timeout int64) error {
 	if !ok {
 	if !ok {
 		return errors.New("val must string")
 		return errors.New("val must string")
 	}
 	}
-	stored, err := rc.c.Set(key, 0, uint64(timeout), []byte(v))
-	if err == nil && stored == false {
-		return errors.New("stored fail")
-	}
-	return err
+	item := memcache.Item{Key: key, Value: []byte(v), Expiration: int32(timeout)}
+	return rc.conn.Set(&item)
 }
 }
 
 
 // delete value in memcache.
 // delete value in memcache.
 func (rc *MemcacheCache) Delete(key string) error {
 func (rc *MemcacheCache) Delete(key string) error {
-	if rc.c == nil {
-		var err error
-		rc.c, err = rc.connectInit()
-		if err != nil {
+	if rc.conn == nil {
+		if err := rc.connectInit(); err != nil {
 			return err
 			return err
 		}
 		}
 	}
 	}
-	_, err := rc.c.Delete(key)
-	return err
+	return rc.conn.Delete(key)
 }
 }
 
 
-// [Not Support]
 // increase counter.
 // increase counter.
 func (rc *MemcacheCache) Incr(key string) error {
 func (rc *MemcacheCache) Incr(key string) error {
-	return errors.New("not support in memcache")
+	if rc.conn == nil {
+		if err := rc.connectInit(); err != nil {
+			return err
+		}
+	}
+	_, err := rc.conn.Increment(key, 1)
+	return err
 }
 }
 
 
-// [Not Support]
 // decrease counter.
 // decrease counter.
 func (rc *MemcacheCache) Decr(key string) error {
 func (rc *MemcacheCache) Decr(key string) error {
-	return errors.New("not support in memcache")
+	if rc.conn == nil {
+		if err := rc.connectInit(); err != nil {
+			return err
+		}
+	}
+	_, err := rc.conn.Decrement(key, 1)
+	return err
 }
 }
 
 
 // check value exists in memcache.
 // check value exists in memcache.
 func (rc *MemcacheCache) IsExist(key string) bool {
 func (rc *MemcacheCache) IsExist(key string) bool {
-	if rc.c == nil {
-		var err error
-		rc.c, err = rc.connectInit()
-		if err != nil {
+	if rc.conn == nil {
+		if err := rc.connectInit(); err != nil {
 			return false
 			return false
 		}
 		}
 	}
 	}
-	v, err := rc.c.Get(key)
+	_, err := rc.conn.Get(key)
 	if err != nil {
 	if err != nil {
 		return false
 		return false
 	}
 	}
-	if len(v) == 0 {
-		return false
-	} else {
-		return true
-	}
+	return true
 }
 }
 
 
 // clear all cached in memcache.
 // clear all cached in memcache.
 func (rc *MemcacheCache) ClearAll() error {
 func (rc *MemcacheCache) ClearAll() error {
-	if rc.c == nil {
-		var err error
-		rc.c, err = rc.connectInit()
-		if err != nil {
+	if rc.conn == nil {
+		if err := rc.connectInit(); err != nil {
 			return err
 			return err
 		}
 		}
 	}
 	}
-	err := rc.c.FlushAll()
-	return err
+	return rc.conn.FlushAll()
 }
 }
 
 
 // start memcache adapter.
 // start memcache adapter.
@@ -135,24 +143,19 @@ func (rc *MemcacheCache) StartAndGC(config string) error {
 	if _, ok := cf["conn"]; !ok {
 	if _, ok := cf["conn"]; !ok {
 		return errors.New("config has no conn key")
 		return errors.New("config has no conn key")
 	}
 	}
-	rc.conninfo = cf["conn"]
-	var err error
-	if rc.c != nil {
-		rc.c, err = rc.connectInit()
-		if err != nil {
-			return errors.New("dial tcp conn error")
+	rc.conninfo = strings.Split(cf["conn"], ";")
+	if rc.conn == nil {
+		if err := rc.connectInit(); err != nil {
+			return err
 		}
 		}
 	}
 	}
 	return nil
 	return nil
 }
 }
 
 
 // connect to memcache and keep the connection.
 // connect to memcache and keep the connection.
-func (rc *MemcacheCache) connectInit() (*memcache.Connection, error) {
-	c, err := memcache.Connect(rc.conninfo)
-	if err != nil {
-		return nil, err
-	}
-	return c, nil
+func (rc *MemcacheCache) connectInit() error {
+	rc.conn = memcache.New(rc.conninfo...)
+	return nil
 }
 }
 
 
 func init() {
 func init() {

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 cache
 package cache
 
 
@@ -46,15 +54,14 @@ func NewMemoryCache() *MemoryCache {
 func (bc *MemoryCache) Get(name string) interface{} {
 func (bc *MemoryCache) Get(name string) interface{} {
 	bc.lock.RLock()
 	bc.lock.RLock()
 	defer bc.lock.RUnlock()
 	defer bc.lock.RUnlock()
-	itm, ok := bc.items[name]
-	if !ok {
-		return nil
-	}
-	if (time.Now().Unix() - itm.Lastaccess.Unix()) > itm.expired {
-		go bc.Delete(name)
-		return nil
+	if itm, ok := bc.items[name]; ok {
+		if (time.Now().Unix() - itm.Lastaccess.Unix()) > itm.expired {
+			go bc.Delete(name)
+			return nil
+		}
+		return itm.val
 	}
 	}
-	return itm.val
+	return nil
 }
 }
 
 
 // Put cache to memory.
 // Put cache to memory.
@@ -62,12 +69,11 @@ func (bc *MemoryCache) Get(name string) interface{} {
 func (bc *MemoryCache) Put(name string, value interface{}, expired int64) error {
 func (bc *MemoryCache) Put(name string, value interface{}, expired int64) error {
 	bc.lock.Lock()
 	bc.lock.Lock()
 	defer bc.lock.Unlock()
 	defer bc.lock.Unlock()
-	t := MemoryItem{
+	bc.items[name] = &MemoryItem{
 		val:        value,
 		val:        value,
 		Lastaccess: time.Now(),
 		Lastaccess: time.Now(),
 		expired:    expired,
 		expired:    expired,
 	}
 	}
-	bc.items[name] = &t
 	return nil
 	return nil
 }
 }
 
 
@@ -79,8 +85,7 @@ func (bc *MemoryCache) Delete(name string) error {
 		return errors.New("key not exist")
 		return errors.New("key not exist")
 	}
 	}
 	delete(bc.items, name)
 	delete(bc.items, name)
-	_, valid := bc.items[name]
-	if valid {
+	if _, ok := bc.items[name]; ok {
 		return errors.New("delete key error")
 		return errors.New("delete key error")
 	}
 	}
 	return nil
 	return nil
@@ -211,8 +216,7 @@ func (bc *MemoryCache) item_expired(name string) bool {
 	if !ok {
 	if !ok {
 		return true
 		return true
 	}
 	}
-	sec := time.Now().Unix() - itm.Lastaccess.Unix()
-	if sec >= itm.expired {
+	if time.Now().Unix()-itm.Lastaccess.Unix() >= itm.expired {
 		delete(bc.items, name)
 		delete(bc.items, name)
 		return true
 		return true
 	}
 	}

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
-
-package cache
+// 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 redis for cache provider
+//
+// depend on github.com/garyburd/redigo/redis
+//
+// go install github.com/garyburd/redigo/redis
+//
+// Usage:
+// import(
+//   _ "github.com/astaxie/beego/cache/redis"
+//   "github.com/astaxie/beego/cache"
+// )
+//
+//  bm, err := cache.NewCache("redis", `{"conn":"127.0.0.1:11211"}`)
+//
+//  more docs http://beego.me/docs/module/cache.md
+package redis
 
 
 import (
 import (
 	"encoding/json"
 	"encoding/json"
 	"errors"
 	"errors"
 	"time"
 	"time"
 
 
-	"github.com/beego/redigo/redis"
+	"github.com/garyburd/redigo/redis"
 
 
 	"github.com/astaxie/beego/cache"
 	"github.com/astaxie/beego/cache"
 )
 )
@@ -43,52 +66,74 @@ func (rc *RedisCache) do(commandName string, args ...interface{}) (reply interfa
 
 
 // Get cache from redis.
 // Get cache from redis.
 func (rc *RedisCache) Get(key string) interface{} {
 func (rc *RedisCache) Get(key string) interface{} {
-	v, err := rc.do("HGET", rc.key, key)
-	if err != nil {
-		return nil
+	if v, err := rc.do("GET", key); err == nil {
+		return v
 	}
 	}
-
-	return v
+	return nil
 }
 }
 
 
 // put cache to redis.
 // put cache to redis.
-// timeout is ignored.
 func (rc *RedisCache) Put(key string, val interface{}, timeout int64) error {
 func (rc *RedisCache) Put(key string, val interface{}, timeout int64) error {
-	_, err := rc.do("HSET", rc.key, key, val)
+	var err error
+	if _, err = rc.do("SET", key, 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
 	return err
 }
 }
 
 
 // delete cache in redis.
 // delete cache in redis.
 func (rc *RedisCache) Delete(key string) error {
 func (rc *RedisCache) Delete(key string) error {
-	_, err := rc.do("HDEL", rc.key, key)
+	var err error
+	if _, err = rc.do("DEL", key); err != nil {
+		return err
+	}
+	_, err = rc.do("HDEL", rc.key, key)
 	return err
 	return err
 }
 }
 
 
-// check cache exist in redis.
+// check cache's existence in redis.
 func (rc *RedisCache) IsExist(key string) bool {
 func (rc *RedisCache) IsExist(key string) bool {
-	v, err := redis.Bool(rc.do("HEXISTS", rc.key, key))
+	v, err := redis.Bool(rc.do("EXISTS", key))
 	if err != nil {
 	if err != nil {
 		return false
 		return false
 	}
 	}
-
+	if v == false {
+		if _, err = rc.do("HDEL", rc.key, key); err != nil {
+			return false
+		}
+	}
 	return v
 	return v
 }
 }
 
 
 // increase counter in redis.
 // increase counter in redis.
 func (rc *RedisCache) Incr(key string) error {
 func (rc *RedisCache) Incr(key string) error {
-	_, err := redis.Bool(rc.do("HINCRBY", rc.key, key, 1))
+	_, err := redis.Bool(rc.do("INCRBY", key, 1))
 	return err
 	return err
 }
 }
 
 
 // decrease counter in redis.
 // decrease counter in redis.
 func (rc *RedisCache) Decr(key string) error {
 func (rc *RedisCache) Decr(key string) error {
-	_, err := redis.Bool(rc.do("HINCRBY", rc.key, key, -1))
+	_, err := redis.Bool(rc.do("INCRBY", key, -1))
 	return err
 	return err
 }
 }
 
 
 // clean all cache in redis. delete this redis collection.
 // clean all cache in redis. delete this redis collection.
 func (rc *RedisCache) ClearAll() error {
 func (rc *RedisCache) ClearAll() error {
-	_, err := rc.do("DEL", rc.key)
+	cachedKeys, err := redis.Strings(rc.do("HKEYS", rc.key))
+	if err != nil {
+		return err
+	}
+	for _, str := range cachedKeys {
+		if _, err = rc.do("DEL", str); err != nil {
+			return err
+		}
+	}
+	_, err = rc.do("DEL", rc.key)
 	return err
 	return err
 }
 }
 
 
@@ -114,26 +159,21 @@ func (rc *RedisCache) StartAndGC(config string) error {
 
 
 	c := rc.p.Get()
 	c := rc.p.Get()
 	defer c.Close()
 	defer c.Close()
-	if err := c.Err(); err != nil {
-		return err
-	}
 
 
-	return nil
+	return c.Err()
 }
 }
 
 
 // connect to redis.
 // connect to redis.
 func (rc *RedisCache) connectInit() {
 func (rc *RedisCache) connectInit() {
+	dialFunc := func() (c redis.Conn, err error) {
+		c, err = redis.Dial("tcp", rc.conninfo)
+		return
+	}
 	// initialize a new pool
 	// initialize a new pool
 	rc.p = &redis.Pool{
 	rc.p = &redis.Pool{
 		MaxIdle:     3,
 		MaxIdle:     3,
 		IdleTimeout: 180 * time.Second,
 		IdleTimeout: 180 * time.Second,
-		Dial: func() (redis.Conn, error) {
-			c, err := redis.Dial("tcp", rc.conninfo)
-			if err != nil {
-				return nil, err
-			}
-			return c, nil
-		},
+		Dial:        dialFunc,
 	}
 	}
 }
 }
 
 

+// 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 redis
+
+import (
+	"testing"
+	"time"
+
+	"github.com/garyburd/redigo/redis"
+
+	"github.com/astaxie/beego/cache"
+)
+
+func TestRedisCache(t *testing.T) {
+	bm, err := cache.NewCache("redis", `{"conn": "127.0.0.1:6379"}`)
+	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, _ := redis.Int(bm.Get("astaxie"), err); v != 1 {
+		t.Error("get err")
+	}
+
+	if err = bm.Incr("astaxie"); err != nil {
+		t.Error("Incr Error", err)
+	}
+
+	if v, _ := redis.Int(bm.Get("astaxie"), err); v != 2 {
+		t.Error("get err")
+	}
+
+	if err = bm.Decr("astaxie"); err != nil {
+		t.Error("Decr Error", err)
+	}
+
+	if v, _ := redis.Int(bm.Get("astaxie"), err); 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, _ := redis.String(bm.Get("astaxie"), err); v != "author" {
+		t.Error("get err")
+	}
+	// test clear all
+	if err = bm.ClearAll(); err != nil {
+		t.Error("clear all err")
+	}
+}

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package beego
 
 
@@ -52,6 +60,7 @@ var (
 	SessionHashKey         string           // session hash salt string.
 	SessionHashKey         string           // session hash salt string.
 	SessionCookieLifeTime  int              // the life time of session id in cookie.
 	SessionCookieLifeTime  int              // the life time of session id in cookie.
 	SessionAutoSetCookie   bool             // auto setcookie
 	SessionAutoSetCookie   bool             // auto setcookie
+	SessionDomain          string           // the cookie domain default is empty
 	UseFcgi                bool
 	UseFcgi                bool
 	MaxMemory              int64
 	MaxMemory              int64
 	EnableGzip             bool // flag of enable gzip
 	EnableGzip             bool // flag of enable gzip
@@ -180,147 +189,147 @@ func ParseConfig() (err error) {
 		return err
 		return err
 	} else {
 	} else {
 
 
-		if v, err := getConfig("string", "HttpAddr"); err == nil {
+		if v, err := GetConfig("string", "HttpAddr"); err == nil {
 			HttpAddr = v.(string)
 			HttpAddr = v.(string)
 		}
 		}
 
 
-		if v, err := getConfig("int", "HttpPort"); err == nil {
+		if v, err := GetConfig("int", "HttpPort"); err == nil {
 			HttpPort = v.(int)
 			HttpPort = v.(int)
 		}
 		}
 
 
-		if v, err := getConfig("bool", "EnableHttpListen"); err == nil {
+		if v, err := GetConfig("bool", "EnableHttpListen"); err == nil {
 			EnableHttpListen = v.(bool)
 			EnableHttpListen = v.(bool)
 		}
 		}
 
 
-		if maxmemory, err := getConfig("int64", "MaxMemory"); err == nil {
+		if maxmemory, err := GetConfig("int64", "MaxMemory"); err == nil {
 			MaxMemory = maxmemory.(int64)
 			MaxMemory = maxmemory.(int64)
 		}
 		}
 
 
-		if appname, _ := getConfig("string", "AppName"); appname != "" {
+		if appname, _ := GetConfig("string", "AppName"); appname != "" {
 			AppName = appname.(string)
 			AppName = appname.(string)
 		}
 		}
 
 
-		if runmode, _ := getConfig("string", "RunMode"); runmode != "" {
+		if runmode, _ := GetConfig("string", "RunMode"); runmode != "" {
 			RunMode = runmode.(string)
 			RunMode = runmode.(string)
 		}
 		}
 
 
-		if autorender, err := getConfig("bool", "AutoRender"); err == nil {
+		if autorender, err := GetConfig("bool", "AutoRender"); err == nil {
 			AutoRender = autorender.(bool)
 			AutoRender = autorender.(bool)
 		}
 		}
 
 
-		if autorecover, err := getConfig("bool", "RecoverPanic"); err == nil {
+		if autorecover, err := GetConfig("bool", "RecoverPanic"); err == nil {
 			RecoverPanic = autorecover.(bool)
 			RecoverPanic = autorecover.(bool)
 		}
 		}
 
 
-		if views, _ := getConfig("string", "ViewsPath"); views != "" {
+		if views, _ := GetConfig("string", "ViewsPath"); views != "" {
 			ViewsPath = views.(string)
 			ViewsPath = views.(string)
 		}
 		}
 
 
-		if sessionon, err := getConfig("bool", "SessionOn"); err == nil {
+		if sessionon, err := GetConfig("bool", "SessionOn"); err == nil {
 			SessionOn = sessionon.(bool)
 			SessionOn = sessionon.(bool)
 		}
 		}
 
 
-		if sessProvider, _ := getConfig("string", "SessionProvider"); sessProvider != "" {
+		if sessProvider, _ := GetConfig("string", "SessionProvider"); sessProvider != "" {
 			SessionProvider = sessProvider.(string)
 			SessionProvider = sessProvider.(string)
 		}
 		}
 
 
-		if sessName, _ := getConfig("string", "SessionName"); sessName != "" {
+		if sessName, _ := GetConfig("string", "SessionName"); sessName != "" {
 			SessionName = sessName.(string)
 			SessionName = sessName.(string)
 		}
 		}
 
 
-		if sesssavepath, _ := getConfig("string", "SessionSavePath"); sesssavepath != "" {
+		if sesssavepath, _ := GetConfig("string", "SessionSavePath"); sesssavepath != "" {
 			SessionSavePath = sesssavepath.(string)
 			SessionSavePath = sesssavepath.(string)
 		}
 		}
 
 
-		if sesshashfunc, _ := getConfig("string", "SessionHashFunc"); sesshashfunc != "" {
+		if sesshashfunc, _ := GetConfig("string", "SessionHashFunc"); sesshashfunc != "" {
 			SessionHashFunc = sesshashfunc.(string)
 			SessionHashFunc = sesshashfunc.(string)
 		}
 		}
 
 
-		if sesshashkey, _ := getConfig("string", "SessionHashKey"); sesshashkey != "" {
+		if sesshashkey, _ := GetConfig("string", "SessionHashKey"); sesshashkey != "" {
 			SessionHashKey = sesshashkey.(string)
 			SessionHashKey = sesshashkey.(string)
 		}
 		}
 
 
-		if sessMaxLifeTime, err := getConfig("int64", "SessionGCMaxLifetime"); err == nil && sessMaxLifeTime != 0 {
+		if sessMaxLifeTime, err := GetConfig("int64", "SessionGCMaxLifetime"); err == nil && sessMaxLifeTime != 0 {
 			SessionGCMaxLifetime = sessMaxLifeTime.(int64)
 			SessionGCMaxLifetime = sessMaxLifeTime.(int64)
 		}
 		}
 
 
-		if sesscookielifetime, err := getConfig("int", "SessionCookieLifeTime"); err == nil && sesscookielifetime != 0 {
+		if sesscookielifetime, err := GetConfig("int", "SessionCookieLifeTime"); err == nil && sesscookielifetime != 0 {
 			SessionCookieLifeTime = sesscookielifetime.(int)
 			SessionCookieLifeTime = sesscookielifetime.(int)
 		}
 		}
 
 
-		if usefcgi, err := getConfig("bool", "UseFcgi"); err == nil {
+		if usefcgi, err := GetConfig("bool", "UseFcgi"); err == nil {
 			UseFcgi = usefcgi.(bool)
 			UseFcgi = usefcgi.(bool)
 		}
 		}
 
 
-		if enablegzip, err := getConfig("bool", "EnableGzip"); err == nil {
+		if enablegzip, err := GetConfig("bool", "EnableGzip"); err == nil {
 			EnableGzip = enablegzip.(bool)
 			EnableGzip = enablegzip.(bool)
 		}
 		}
 
 
-		if directoryindex, err := getConfig("bool", "DirectoryIndex"); err == nil {
+		if directoryindex, err := GetConfig("bool", "DirectoryIndex"); err == nil {
 			DirectoryIndex = directoryindex.(bool)
 			DirectoryIndex = directoryindex.(bool)
 		}
 		}
 
 
-		if timeout, err := getConfig("int64", "HttpServerTimeOut"); err == nil {
+		if timeout, err := GetConfig("int64", "HttpServerTimeOut"); err == nil {
 			HttpServerTimeOut = timeout.(int64)
 			HttpServerTimeOut = timeout.(int64)
 		}
 		}
 
 
-		if errorsshow, err := getConfig("bool", "ErrorsShow"); err == nil {
+		if errorsshow, err := GetConfig("bool", "ErrorsShow"); err == nil {
 			ErrorsShow = errorsshow.(bool)
 			ErrorsShow = errorsshow.(bool)
 		}
 		}
 
 
-		if copyrequestbody, err := getConfig("bool", "CopyRequestBody"); err == nil {
+		if copyrequestbody, err := GetConfig("bool", "CopyRequestBody"); err == nil {
 			CopyRequestBody = copyrequestbody.(bool)
 			CopyRequestBody = copyrequestbody.(bool)
 		}
 		}
 
 
-		if xsrfkey, _ := getConfig("string", "XSRFKEY"); xsrfkey != "" {
+		if xsrfkey, _ := GetConfig("string", "XSRFKEY"); xsrfkey != "" {
 			XSRFKEY = xsrfkey.(string)
 			XSRFKEY = xsrfkey.(string)
 		}
 		}
 
 
-		if enablexsrf, err := getConfig("bool", "EnableXSRF"); err == nil {
+		if enablexsrf, err := GetConfig("bool", "EnableXSRF"); err == nil {
 			EnableXSRF = enablexsrf.(bool)
 			EnableXSRF = enablexsrf.(bool)
 		}
 		}
 
 
-		if expire, err := getConfig("int", "XSRFExpire"); err == nil {
+		if expire, err := GetConfig("int", "XSRFExpire"); err == nil {
 			XSRFExpire = expire.(int)
 			XSRFExpire = expire.(int)
 		}
 		}
 
 
-		if tplleft, _ := getConfig("string", "TemplateLeft"); tplleft != "" {
+		if tplleft, _ := GetConfig("string", "TemplateLeft"); tplleft != "" {
 			TemplateLeft = tplleft.(string)
 			TemplateLeft = tplleft.(string)
 		}
 		}
 
 
-		if tplright, _ := getConfig("string", "TemplateRight"); tplright != "" {
+		if tplright, _ := GetConfig("string", "TemplateRight"); tplright != "" {
 			TemplateRight = tplright.(string)
 			TemplateRight = tplright.(string)
 		}
 		}
 
 
-		if httptls, err := getConfig("bool", "EnableHttpTLS"); err == nil {
+		if httptls, err := GetConfig("bool", "EnableHttpTLS"); err == nil {
 			EnableHttpTLS = httptls.(bool)
 			EnableHttpTLS = httptls.(bool)
 		}
 		}
 
 
-		if httpsport, err := getConfig("int", "HttpsPort"); err == nil {
+		if httpsport, err := GetConfig("int", "HttpsPort"); err == nil {
 			HttpsPort = httpsport.(int)
 			HttpsPort = httpsport.(int)
 		}
 		}
 
 
-		if certfile, _ := getConfig("string", "HttpCertFile"); certfile != "" {
+		if certfile, _ := GetConfig("string", "HttpCertFile"); certfile != "" {
 			HttpCertFile = certfile.(string)
 			HttpCertFile = certfile.(string)
 		}
 		}
 
 
-		if keyfile, _ := getConfig("string", "HttpKeyFile"); keyfile != "" {
+		if keyfile, _ := GetConfig("string", "HttpKeyFile"); keyfile != "" {
 			HttpKeyFile = keyfile.(string)
 			HttpKeyFile = keyfile.(string)
 		}
 		}
 
 
-		if serverName, _ := getConfig("string", "BeegoServerName"); serverName != "" {
+		if serverName, _ := GetConfig("string", "BeegoServerName"); serverName != "" {
 			BeegoServerName = serverName.(string)
 			BeegoServerName = serverName.(string)
 		}
 		}
 
 
-		if flashname, _ := getConfig("string", "FlashName"); flashname != "" {
+		if flashname, _ := GetConfig("string", "FlashName"); flashname != "" {
 			FlashName = flashname.(string)
 			FlashName = flashname.(string)
 		}
 		}
 
 
-		if flashseperator, _ := getConfig("string", "FlashSeperator"); flashseperator != "" {
+		if flashseperator, _ := GetConfig("string", "FlashSeperator"); flashseperator != "" {
 			FlashSeperator = flashseperator.(string)
 			FlashSeperator = flashseperator.(string)
 		}
 		}
 
 
-		if sd, _ := getConfig("string", "StaticDir"); sd != "" {
+		if sd, _ := GetConfig("string", "StaticDir"); sd != "" {
 			for k := range StaticDir {
 			for k := range StaticDir {
 				delete(StaticDir, k)
 				delete(StaticDir, k)
 			}
 			}
@@ -334,7 +343,7 @@ func ParseConfig() (err error) {
 			}
 			}
 		}
 		}
 
 
-		if sgz, _ := getConfig("string", "StaticExtensionsToGzip"); sgz != "" {
+		if sgz, _ := GetConfig("string", "StaticExtensionsToGzip"); sgz != "" {
 			extensions := strings.Split(sgz.(string), ",")
 			extensions := strings.Split(sgz.(string), ",")
 			if len(extensions) > 0 {
 			if len(extensions) > 0 {
 				StaticExtensionsToGzip = []string{}
 				StaticExtensionsToGzip = []string{}
@@ -351,26 +360,37 @@ func ParseConfig() (err error) {
 			}
 			}
 		}
 		}
 
 
-		if enableadmin, err := getConfig("bool", "EnableAdmin"); err == nil {
+		if enableadmin, err := GetConfig("bool", "EnableAdmin"); err == nil {
 			EnableAdmin = enableadmin.(bool)
 			EnableAdmin = enableadmin.(bool)
 		}
 		}
 
 
-		if adminhttpaddr, _ := getConfig("string", "AdminHttpAddr"); adminhttpaddr != "" {
+		if adminhttpaddr, _ := GetConfig("string", "AdminHttpAddr"); adminhttpaddr != "" {
 			AdminHttpAddr = adminhttpaddr.(string)
 			AdminHttpAddr = adminhttpaddr.(string)
 		}
 		}
 
 
-		if adminhttpport, err := getConfig("int", "AdminHttpPort"); err == nil {
+		if adminhttpport, err := GetConfig("int", "AdminHttpPort"); err == nil {
 			AdminHttpPort = adminhttpport.(int)
 			AdminHttpPort = adminhttpport.(int)
 		}
 		}
 
 
-		if enabledocs, err := getConfig("bool", "EnableDocs"); err == nil {
+		if enabledocs, err := GetConfig("bool", "EnableDocs"); err == nil {
 			EnableDocs = enabledocs.(bool)
 			EnableDocs = enabledocs.(bool)
 		}
 		}
 	}
 	}
 	return nil
 	return nil
 }
 }
 
 
-func getConfig(typ, key string) (interface{}, error) {
+// 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 {
 	switch typ {
 	case "string":
 	case "string":
 		v := AppConfig.String(RunMode + "::" + key)
 		v := AppConfig.String(RunMode + "::" + key)

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
+// Usage:
+// import(
+//   "github.com/astaxie/beego/config"
+// )
+//
+//  cnf, err := config.NewConfig("ini", "config.conf")
+//
+//  cnf APIS:
+//
+//  cnf.Set(key, val string) error
+//  cnf.String(key string) string
+//  cnf.Strings(key string) []string
+//  cnf.Int(key string) (int, error)
+//  cnf.Int64(key string) (int64, error)
+//  cnf.Bool(key string) (bool, error)
+//  cnf.Float(key string) (float64, error)
+//  cnf.DefaultString(key string, defaultval string) string
+//  cnf.DefaultStrings(key string, defaultval []string) []string
+//  cnf.DefaultInt(key string, defaultval int) int
+//  cnf.DefaultInt64(key string, defaultval int64) int64
+//  cnf.DefaultBool(key string, defaultval bool) bool
+//  cnf.DefaultFloat(key string, defaultval float64) float64
+//  cnf.DIY(key string) (interface{}, error)
+//  cnf.GetSection(section string) (map[string]string, error)
+//  cnf.SaveConfigFile(filename string) error
+//
+//  more docs http://beego.me/docs/module/config.md
 package config
 package config
 
 
 import (
 import (
@@ -19,12 +54,21 @@ type ConfigContainer interface {
 	Int64(key string) (int64, error)
 	Int64(key string) (int64, error)
 	Bool(key string) (bool, error)
 	Bool(key string) (bool, error)
 	Float(key string) (float64, error)
 	Float(key string) (float64, error)
+	DefaultString(key string, defaultval string) string      // support section::key type in key string when using ini and json type; Int,Int64,Bool,Float,DIY are same.
+	DefaultStrings(key string, defaultval []string) []string //get string slice
+	DefaultInt(key string, defaultval int) int
+	DefaultInt64(key string, defaultval int64) int64
+	DefaultBool(key string, defaultval bool) bool
+	DefaultFloat(key string, defaultval float64) float64
 	DIY(key string) (interface{}, error)
 	DIY(key string) (interface{}, error)
+	GetSection(section string) (map[string]string, error)
+	SaveConfigFile(filename string) error
 }
 }
 
 
 // Config is the adapter interface for parsing config file to get raw data to ConfigContainer.
 // Config is the adapter interface for parsing config file to get raw data to ConfigContainer.
 type Config interface {
 type Config interface {
 	Parse(key string) (ConfigContainer, error)
 	Parse(key string) (ConfigContainer, error)
+	ParseData(data []byte) (ConfigContainer, error)
 }
 }
 
 
 var adapters = make(map[string]Config)
 var adapters = make(map[string]Config)
@@ -36,7 +80,7 @@ func Register(name string, adapter Config) {
 	if adapter == nil {
 	if adapter == nil {
 		panic("config: Register adapter is nil")
 		panic("config: Register adapter is nil")
 	}
 	}
-	if _, dup := adapters[name]; dup {
+	if _, ok := adapters[name]; ok {
 		panic("config: Register called twice for adapter " + name)
 		panic("config: Register called twice for adapter " + name)
 	}
 	}
 	adapters[name] = adapter
 	adapters[name] = adapter
@@ -51,3 +95,13 @@ func NewConfig(adapterName, fileaname string) (ConfigContainer, error) {
 	}
 	}
 	return adapter.Parse(fileaname)
 	return adapter.Parse(fileaname)
 }
 }
+
+// adapterName is ini/json/xml/yaml.
+// data is the config data.
+func NewConfigData(adapterName string, data []byte) (ConfigContainer, error) {
+	adapter, ok := adapters[adapterName]
+	if !ok {
+		return nil, fmt.Errorf("config: unknown adaptername %q (forgotten import?)", adapterName)
+	}
+	return adapter.ParseData(data)
+}

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 config
 package config
 
 
@@ -17,13 +25,11 @@ type fakeConfigContainer struct {
 }
 }
 
 
 func (c *fakeConfigContainer) getData(key string) string {
 func (c *fakeConfigContainer) getData(key string) string {
-	key = strings.ToLower(key)
-	return c.data[key]
+	return c.data[strings.ToLower(key)]
 }
 }
 
 
 func (c *fakeConfigContainer) Set(key, val string) error {
 func (c *fakeConfigContainer) Set(key, val string) error {
-	key = strings.ToLower(key)
-	c.data[key] = val
+	c.data[strings.ToLower(key)] = val
 	return nil
 	return nil
 }
 }
 
 
@@ -31,34 +37,89 @@ func (c *fakeConfigContainer) String(key string) string {
 	return c.getData(key)
 	return c.getData(key)
 }
 }
 
 
+func (c *fakeConfigContainer) DefaultString(key string, defaultval string) string {
+	if v := c.getData(key); v == "" {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 func (c *fakeConfigContainer) Strings(key string) []string {
 func (c *fakeConfigContainer) Strings(key string) []string {
 	return strings.Split(c.getData(key), ";")
 	return strings.Split(c.getData(key), ";")
 }
 }
 
 
+func (c *fakeConfigContainer) DefaultStrings(key string, defaultval []string) []string {
+	if v := c.Strings(key); len(v) == 0 {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 func (c *fakeConfigContainer) Int(key string) (int, error) {
 func (c *fakeConfigContainer) Int(key string) (int, error) {
 	return strconv.Atoi(c.getData(key))
 	return strconv.Atoi(c.getData(key))
 }
 }
 
 
+func (c *fakeConfigContainer) DefaultInt(key string, defaultval int) int {
+	if v, err := c.Int(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 func (c *fakeConfigContainer) Int64(key string) (int64, error) {
 func (c *fakeConfigContainer) Int64(key string) (int64, error) {
 	return strconv.ParseInt(c.getData(key), 10, 64)
 	return strconv.ParseInt(c.getData(key), 10, 64)
 }
 }
 
 
+func (c *fakeConfigContainer) DefaultInt64(key string, defaultval int64) int64 {
+	if v, err := c.Int64(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 func (c *fakeConfigContainer) Bool(key string) (bool, error) {
 func (c *fakeConfigContainer) Bool(key string) (bool, error) {
 	return strconv.ParseBool(c.getData(key))
 	return strconv.ParseBool(c.getData(key))
 }
 }
 
 
+func (c *fakeConfigContainer) DefaultBool(key string, defaultval bool) bool {
+	if v, err := c.Bool(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 func (c *fakeConfigContainer) Float(key string) (float64, error) {
 func (c *fakeConfigContainer) Float(key string) (float64, error) {
 	return strconv.ParseFloat(c.getData(key), 64)
 	return strconv.ParseFloat(c.getData(key), 64)
 }
 }
 
 
+func (c *fakeConfigContainer) DefaultFloat(key string, defaultval float64) float64 {
+	if v, err := c.Float(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 func (c *fakeConfigContainer) DIY(key string) (interface{}, error) {
 func (c *fakeConfigContainer) DIY(key string) (interface{}, error) {
-	key = strings.ToLower(key)
-	if v, ok := c.data[key]; ok {
+	if v, ok := c.data[strings.ToLower(key)]; ok {
 		return v, nil
 		return v, nil
 	}
 	}
 	return nil, errors.New("key not find")
 	return nil, errors.New("key not find")
 }
 }
 
 
+func (c *fakeConfigContainer) GetSection(section string) (map[string]string, error) {
+	return nil, errors.New("not implement in the fakeConfigContainer")
+}
+
+func (c *fakeConfigContainer) SaveConfigFile(filename string) error {
+	return errors.New("not implement in the fakeConfigContainer")
+}
+
 var _ ConfigContainer = new(fakeConfigContainer)
 var _ ConfigContainer = new(fakeConfigContainer)
 
 
 func NewFakeConfig() ConfigContainer {
 func NewFakeConfig() ConfigContainer {

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 config
 package config
 
 
@@ -10,11 +18,15 @@ import (
 	"bufio"
 	"bufio"
 	"bytes"
 	"bytes"
 	"errors"
 	"errors"
+	"fmt"
 	"io"
 	"io"
+	"io/ioutil"
 	"os"
 	"os"
+	"path"
 	"strconv"
 	"strconv"
 	"strings"
 	"strings"
 	"sync"
 	"sync"
+	"time"
 	"unicode"
 	"unicode"
 )
 )
 
 
@@ -27,6 +39,7 @@ var (
 	bDQuote         = []byte{'"'} // quote signal
 	bDQuote         = []byte{'"'} // quote signal
 	sectionStart    = []byte{'['} // section start signal
 	sectionStart    = []byte{'['} // section start signal
 	sectionEnd      = []byte{']'} // section end signal
 	sectionEnd      = []byte{']'} // section end signal
+	lineBreak       = "\n"
 )
 )
 
 
 // IniConfig implements Config to parse ini file.
 // IniConfig implements Config to parse ini file.
@@ -80,8 +93,7 @@ func (ini *IniConfig) Parse(name string) (ConfigContainer, error) {
 		}
 		}
 
 
 		if bytes.HasPrefix(line, sectionStart) && bytes.HasSuffix(line, sectionEnd) {
 		if bytes.HasPrefix(line, sectionStart) && bytes.HasSuffix(line, sectionEnd) {
-			section = string(line[1 : len(line)-1])
-			section = strings.ToLower(section) // section name case insensitive
+			section = strings.ToLower(string(line[1 : len(line)-1])) // section name case insensitive
 			if comment.Len() > 0 {
 			if comment.Len() > 0 {
 				cfg.sectionComment[section] = comment.String()
 				cfg.sectionComment[section] = comment.String()
 				comment.Reset()
 				comment.Reset()
@@ -89,67 +101,124 @@ func (ini *IniConfig) Parse(name string) (ConfigContainer, error) {
 			if _, ok := cfg.data[section]; !ok {
 			if _, ok := cfg.data[section]; !ok {
 				cfg.data[section] = make(map[string]string)
 				cfg.data[section] = make(map[string]string)
 			}
 			}
-		} else {
-			if _, ok := cfg.data[section]; !ok {
-				cfg.data[section] = make(map[string]string)
-			}
-			keyval := bytes.SplitN(line, bEqual, 2)
-			val := bytes.TrimSpace(keyval[1])
-			if bytes.HasPrefix(val, bDQuote) {
-				val = bytes.Trim(val, `"`)
-			}
+			continue
+		}
 
 
-			key := string(bytes.TrimSpace(keyval[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()
-				comment.Reset()
-			}
+		if _, ok := cfg.data[section]; !ok {
+			cfg.data[section] = make(map[string]string)
+		}
+		keyValue := bytes.SplitN(line, bEqual, 2)
+		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()
+			comment.Reset()
 		}
 		}
 
 
 	}
 	}
 	return cfg, nil
 	return cfg, nil
 }
 }
 
 
+func (ini *IniConfig) 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 ini.Parse(tmpName)
+}
+
 // A Config represents the ini configuration.
 // A Config represents the ini configuration.
 // When set and get value, support key as section:name type.
 // When set and get value, support key as section:name type.
 type IniConfigContainer struct {
 type IniConfigContainer struct {
 	filename       string
 	filename       string
 	data           map[string]map[string]string // section=> key:val
 	data           map[string]map[string]string // section=> key:val
 	sectionComment map[string]string            // section : comment
 	sectionComment map[string]string            // section : comment
-	keycomment     map[string]string            // id: []{comment, key...}; id 1 is for main comment.
+	keyComment     map[string]string            // id: []{comment, key...}; id 1 is for main comment.
 	sync.RWMutex
 	sync.RWMutex
 }
 }
 
 
 // Bool returns the boolean value for a given key.
 // Bool returns the boolean value for a given key.
 func (c *IniConfigContainer) Bool(key string) (bool, error) {
 func (c *IniConfigContainer) Bool(key string) (bool, error) {
-	key = strings.ToLower(key)
-	return strconv.ParseBool(c.getdata(key))
+	return strconv.ParseBool(c.getdata(strings.ToLower(key)))
+}
+
+// DefaultBool returns the boolean value for a given key.
+// if err != nil return defaltval
+func (c *IniConfigContainer) DefaultBool(key string, defaultval bool) bool {
+	if v, err := c.Bool(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
 }
 }
 
 
 // Int returns the integer value for a given key.
 // Int returns the integer value for a given key.
 func (c *IniConfigContainer) Int(key string) (int, error) {
 func (c *IniConfigContainer) Int(key string) (int, error) {
-	key = strings.ToLower(key)
-	return strconv.Atoi(c.getdata(key))
+	return strconv.Atoi(c.getdata(strings.ToLower(key)))
+}
+
+// DefaultInt returns the integer value for a given key.
+// if err != nil return defaltval
+func (c *IniConfigContainer) DefaultInt(key string, defaultval int) int {
+	if v, err := c.Int(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
 }
 }
 
 
 // Int64 returns the int64 value for a given key.
 // Int64 returns the int64 value for a given key.
 func (c *IniConfigContainer) Int64(key string) (int64, error) {
 func (c *IniConfigContainer) Int64(key string) (int64, error) {
-	key = strings.ToLower(key)
-	return strconv.ParseInt(c.getdata(key), 10, 64)
+	return strconv.ParseInt(c.getdata(strings.ToLower(key)), 10, 64)
+}
+
+// DefaultInt64 returns the int64 value for a given key.
+// if err != nil return defaltval
+func (c *IniConfigContainer) DefaultInt64(key string, defaultval int64) int64 {
+	if v, err := c.Int64(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
 }
 }
 
 
 // Float returns the float value for a given key.
 // Float returns the float value for a given key.
 func (c *IniConfigContainer) Float(key string) (float64, error) {
 func (c *IniConfigContainer) Float(key string) (float64, error) {
-	key = strings.ToLower(key)
-	return strconv.ParseFloat(c.getdata(key), 64)
+	return strconv.ParseFloat(c.getdata(strings.ToLower(key)), 64)
+}
+
+// DefaultFloat returns the float64 value for a given key.
+// if err != nil return defaltval
+func (c *IniConfigContainer) DefaultFloat(key string, defaultval float64) float64 {
+	if v, err := c.Float(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
 }
 }
 
 
 // String returns the string value for a given key.
 // String returns the string value for a given key.
 func (c *IniConfigContainer) String(key string) string {
 func (c *IniConfigContainer) String(key string) string {
 	key = strings.ToLower(key)
 	key = strings.ToLower(key)
-	return c.getdata(key)
+	return c.getdata(strings.ToLower(key))
+}
+
+// DefaultString returns the string value for a given key.
+// if err != nil return defaltval
+func (c *IniConfigContainer) DefaultString(key string, defaultval string) string {
+	if v := c.String(key); v == "" {
+		return defaultval
+	} else {
+		return v
+	}
 }
 }
 
 
 // Strings returns the []string value for a given key.
 // Strings returns the []string value for a given key.
@@ -157,6 +226,78 @@ func (c *IniConfigContainer) Strings(key string) []string {
 	return strings.Split(c.String(key), ";")
 	return strings.Split(c.String(key), ";")
 }
 }
 
 
+// DefaultStrings returns the []string value for a given key.
+// if err != nil return defaltval
+func (c *IniConfigContainer) DefaultStrings(key string, defaultval []string) []string {
+	if v := c.Strings(key); len(v) == 0 {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
+// GetSection returns map for the given section
+func (c *IniConfigContainer) GetSection(section string) (map[string]string, error) {
+	if v, ok := c.data[section]; ok {
+		return v, nil
+	} else {
+		return nil, errors.New("not exist setction")
+	}
+}
+
+// SaveConfigFile save the config into file
+func (c *IniConfigContainer) SaveConfigFile(filename string) (err error) {
+	// Write configuration file by filename.
+	f, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	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
+			}
+		}
+
+		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
+	}
+	return nil
+}
+
 // WriteValue writes a new value for key.
 // WriteValue writes a new value for key.
 // if write to one section, the key need be "section::key".
 // if write to one section, the key need be "section::key".
 // if the section is not existed, it panics.
 // if the section is not existed, it panics.
@@ -167,16 +308,19 @@ func (c *IniConfigContainer) Set(key, value string) error {
 		return errors.New("key is empty")
 		return errors.New("key is empty")
 	}
 	}
 
 
-	var section, k string
-	key = strings.ToLower(key)
-	sectionkey := strings.Split(key, "::")
-	if len(sectionkey) >= 2 {
-		section = sectionkey[0]
-		k = sectionkey[1]
+	var (
+		section, k string
+		sectionKey []string = strings.Split(key, "::")
+	)
+
+	if len(sectionKey) >= 2 {
+		section = sectionKey[0]
+		k = sectionKey[1]
 	} else {
 	} else {
 		section = DEFAULT_SECTION
 		section = DEFAULT_SECTION
-		k = sectionkey[0]
+		k = sectionKey[0]
 	}
 	}
+
 	if _, ok := c.data[section]; !ok {
 	if _, ok := c.data[section]; !ok {
 		c.data[section] = make(map[string]string)
 		c.data[section] = make(map[string]string)
 	}
 	}
@@ -186,8 +330,7 @@ func (c *IniConfigContainer) Set(key, value string) error {
 
 
 // DIY returns the raw value by a given key.
 // DIY returns the raw value by a given key.
 func (c *IniConfigContainer) DIY(key string) (v interface{}, err error) {
 func (c *IniConfigContainer) DIY(key string) (v interface{}, err error) {
-	key = strings.ToLower(key)
-	if v, ok := c.data[key]; ok {
+	if v, ok := c.data[strings.ToLower(key)]; ok {
 		return v, nil
 		return v, nil
 	}
 	}
 	return v, errors.New("key not find")
 	return v, errors.New("key not find")
@@ -201,18 +344,19 @@ func (c *IniConfigContainer) getdata(key string) string {
 		return ""
 		return ""
 	}
 	}
 
 
-	var section, k string
-	key = strings.ToLower(key)
-	sectionkey := strings.Split(key, "::")
-	if len(sectionkey) >= 2 {
-		section = sectionkey[0]
-		k = sectionkey[1]
+	var (
+		section, k string
+		sectionKey []string = strings.Split(key, "::")
+	)
+	if len(sectionKey) >= 2 {
+		section = sectionKey[0]
+		k = sectionKey[1]
 	} else {
 	} else {
 		section = DEFAULT_SECTION
 		section = DEFAULT_SECTION
-		k = sectionkey[0]
+		k = sectionKey[0]
 	}
 	}
 	if v, ok := c.data[section]; ok {
 	if v, ok := c.data[section]; ok {
-		if vv, o := v[k]; o {
+		if vv, ok := v[k]; ok {
 			return vv
 			return vv
 		}
 		}
 	}
 	}

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 config
 package config
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 config
 package config
 
 
 import (
 import (
 	"encoding/json"
 	"encoding/json"
 	"errors"
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"io/ioutil"
 	"os"
 	"os"
+	"path"
 	"strings"
 	"strings"
 	"sync"
 	"sync"
+	"time"
 )
 )
 
 
 // JsonConfig is a json config parser and implements Config interface.
 // JsonConfig is a json config parser and implements Config interface.
@@ -26,13 +37,13 @@ func (js *JsonConfig) Parse(filename string) (ConfigContainer, error) {
 		return nil, err
 		return nil, err
 	}
 	}
 	defer file.Close()
 	defer file.Close()
-	x := &JsonConfigContainer{
-		data: make(map[string]interface{}),
-	}
 	content, err := ioutil.ReadAll(file)
 	content, err := ioutil.ReadAll(file)
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
+	x := &JsonConfigContainer{
+		data: make(map[string]interface{}),
+	}
 	err = json.Unmarshal(content, &x.data)
 	err = json.Unmarshal(content, &x.data)
 	if err != nil {
 	if err != nil {
 		var wrappingArray []interface{}
 		var wrappingArray []interface{}
@@ -45,6 +56,16 @@ func (js *JsonConfig) Parse(filename string) (ConfigContainer, error) {
 	return x, nil
 	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.
 // A Config represents the json configuration.
 // Only when get value, support key as section:name type.
 // Only when get value, support key as section:name type.
 type JsonConfigContainer struct {
 type JsonConfigContainer struct {
@@ -54,71 +75,110 @@ type JsonConfigContainer struct {
 
 
 // Bool returns the boolean value for a given key.
 // Bool returns the boolean value for a given key.
 func (c *JsonConfigContainer) Bool(key string) (bool, error) {
 func (c *JsonConfigContainer) Bool(key string) (bool, error) {
-	val := c.getdata(key)
+	val := c.getData(key)
 	if val != nil {
 	if val != nil {
 		if v, ok := val.(bool); ok {
 		if v, ok := val.(bool); ok {
 			return v, nil
 			return v, nil
-		} else {
-			return false, errors.New("not bool value")
 		}
 		}
+		return false, errors.New("not bool value")
+	}
+	return false, errors.New("not exist key:" + key)
+}
+
+// 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 {
 	} else {
-		return false, errors.New("not exist key:" + key)
+		return v
 	}
 	}
 }
 }
 
 
 // Int returns the integer value for a given key.
 // Int returns the integer value for a given key.
 func (c *JsonConfigContainer) Int(key string) (int, error) {
 func (c *JsonConfigContainer) Int(key string) (int, error) {
-	val := c.getdata(key)
+	val := c.getData(key)
 	if val != nil {
 	if val != nil {
 		if v, ok := val.(float64); ok {
 		if v, ok := val.(float64); ok {
 			return int(v), nil
 			return int(v), nil
-		} else {
-			return 0, errors.New("not int value")
 		}
 		}
+		return 0, errors.New("not int value")
+	}
+	return 0, errors.New("not exist key:" + key)
+}
+
+// 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 {
 	} else {
-		return 0, errors.New("not exist key:" + key)
+		return v
 	}
 	}
 }
 }
 
 
 // Int64 returns the int64 value for a given key.
 // Int64 returns the int64 value for a given key.
 func (c *JsonConfigContainer) Int64(key string) (int64, error) {
 func (c *JsonConfigContainer) Int64(key string) (int64, error) {
-	val := c.getdata(key)
+	val := c.getData(key)
 	if val != nil {
 	if val != nil {
 		if v, ok := val.(float64); ok {
 		if v, ok := val.(float64); ok {
 			return int64(v), nil
 			return int64(v), nil
-		} else {
-			return 0, errors.New("not int64 value")
 		}
 		}
+		return 0, errors.New("not int64 value")
+	}
+	return 0, errors.New("not exist key:" + key)
+}
+
+// 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 {
 	} else {
-		return 0, errors.New("not exist key:" + key)
+		return v
 	}
 	}
 }
 }
 
 
 // Float returns the float value for a given key.
 // Float returns the float value for a given key.
 func (c *JsonConfigContainer) Float(key string) (float64, error) {
 func (c *JsonConfigContainer) Float(key string) (float64, error) {
-	val := c.getdata(key)
+	val := c.getData(key)
 	if val != nil {
 	if val != nil {
 		if v, ok := val.(float64); ok {
 		if v, ok := val.(float64); ok {
 			return v, nil
 			return v, nil
-		} else {
-			return 0.0, errors.New("not float64 value")
 		}
 		}
+		return 0.0, errors.New("not float64 value")
+	}
+	return 0.0, errors.New("not exist key:" + key)
+}
+
+// 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 {
 	} else {
-		return 0.0, errors.New("not exist key:" + key)
+		return v
 	}
 	}
 }
 }
 
 
 // String returns the string value for a given key.
 // String returns the string value for a given key.
 func (c *JsonConfigContainer) String(key string) string {
 func (c *JsonConfigContainer) String(key string) string {
-	val := c.getdata(key)
+	val := c.getData(key)
 	if val != nil {
 	if val != nil {
 		if v, ok := val.(string); ok {
 		if v, ok := val.(string); ok {
 			return v
 			return v
-		} else {
-			return ""
 		}
 		}
+	}
+	return ""
+}
+
+// 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 {
 	} else {
-		return ""
+		return v
 	}
 	}
 }
 }
 
 
@@ -127,6 +187,41 @@ func (c *JsonConfigContainer) Strings(key string) []string {
 	return strings.Split(c.String(key), ";")
 	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 {
+		return v
+	}
+}
+
+// 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")
+	}
+}
+
+// SaveConfigFile save the config into file
+func (c *JsonConfigContainer) SaveConfigFile(filename string) (err error) {
+	// Write configuration file by filename.
+	f, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	b, err := json.MarshalIndent(c.data, "", "  ")
+	if err != nil {
+		return err
+	}
+	_, err = f.Write(b)
+	return err
+}
+
 // WriteValue writes a new value for key.
 // WriteValue writes a new value for key.
 func (c *JsonConfigContainer) Set(key, val string) error {
 func (c *JsonConfigContainer) Set(key, val string) error {
 	c.Lock()
 	c.Lock()
@@ -137,39 +232,37 @@ func (c *JsonConfigContainer) Set(key, val string) error {
 
 
 // DIY returns the raw value by a given key.
 // DIY returns the raw value by a given key.
 func (c *JsonConfigContainer) DIY(key string) (v interface{}, err error) {
 func (c *JsonConfigContainer) DIY(key string) (v interface{}, err error) {
-	val := c.getdata(key)
+	val := c.getData(key)
 	if val != nil {
 	if val != nil {
 		return val, nil
 		return val, nil
-	} else {
-		return nil, errors.New("not exist key")
 	}
 	}
+	return nil, errors.New("not exist key")
 }
 }
 
 
 // section.key or key
 // section.key or key
-func (c *JsonConfigContainer) getdata(key string) interface{} {
+func (c *JsonConfigContainer) getData(key string) interface{} {
 	c.RLock()
 	c.RLock()
 	defer c.RUnlock()
 	defer c.RUnlock()
 	if len(key) == 0 {
 	if len(key) == 0 {
 		return nil
 		return nil
 	}
 	}
-	sectionkey := strings.Split(key, "::")
-	if len(sectionkey) >= 2 {
-		cruval, ok := c.data[sectionkey[0]]
+	sectionKey := strings.Split(key, "::")
+	if len(sectionKey) >= 2 {
+		curValue, ok := c.data[sectionKey[0]]
 		if !ok {
 		if !ok {
 			return nil
 			return nil
 		}
 		}
-		for _, key := range sectionkey[1:] {
-			if v, ok := cruval.(map[string]interface{}); !ok {
-				return nil
-			} else if cruval, ok = v[key]; !ok {
-				return nil
+		for _, key := range sectionKey[1:] {
+			if v, ok := curValue.(map[string]interface{}); ok {
+				if curValue, ok = v[key]; !ok {
+					return nil
+				}
 			}
 			}
 		}
 		}
-		return cruval
-	} else {
-		if v, ok := c.data[key]; ok {
-			return v
-		}
+		return curValue
+	}
+	if v, ok := c.data[key]; ok {
+		return v
 	}
 	}
 	return nil
 	return nil
 }
 }

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 config
 package config
 
 
@@ -61,13 +69,13 @@ func TestJsonStartsWithArray(t *testing.T) {
 		t.Fatal(err)
 		t.Fatal(err)
 	}
 	}
 	rootArray, err := jsonconf.DIY("rootArray")
 	rootArray, err := jsonconf.DIY("rootArray")
-	if (err != nil) {
+	if err != nil {
 		t.Error("array does not exist as element")
 		t.Error("array does not exist as element")
 	}
 	}
 	rootArrayCasted := rootArray.([]interface{})
 	rootArrayCasted := rootArray.([]interface{})
-	if (rootArrayCasted == nil) {
+	if rootArrayCasted == nil {
 		t.Error("array from root is nil")
 		t.Error("array from root is nil")
-	}else {
+	} else {
 		elem := rootArrayCasted[0].(map[string]interface{})
 		elem := rootArrayCasted[0].(map[string]interface{})
 		if elem["url"] != "user" || elem["serviceAPI"] != "http://www.test.com/user" {
 		if elem["url"] != "user" || elem["serviceAPI"] != "http://www.test.com/user" {
 			t.Error("array[0] values are not valid")
 			t.Error("array[0] values are not valid")

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 config
+// package xml for config provider
+//
+// depend on github.com/beego/x2j
+//
+// go install github.com/beego/x2j
+//
+// Usage:
+// import(
+//   _ "github.com/astaxie/beego/config/xml"
+//   "github.com/astaxie/beego/config"
+// )
+//
+//  cnf, err := config.NewConfig("xml", "config.xml")
+//
+//  more docs http://beego.me/docs/module/config.md
+package xml
 
 
 import (
 import (
+	"encoding/xml"
 	"errors"
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"io/ioutil"
 	"os"
 	"os"
+	"path"
 	"strconv"
 	"strconv"
 	"strings"
 	"strings"
 	"sync"
 	"sync"
+	"time"
 
 
 	"github.com/astaxie/beego/config"
 	"github.com/astaxie/beego/config"
 	"github.com/beego/x2j"
 	"github.com/beego/x2j"
@@ -21,31 +48,41 @@ import (
 // XmlConfig is a xml config parser and implements Config interface.
 // XmlConfig is a xml config parser and implements Config interface.
 // xml configurations should be included in <config></config> tag.
 // xml configurations should be included in <config></config> tag.
 // only support key/value pair as <key>value</key> as each item.
 // only support key/value pair as <key>value</key> as each item.
-type XMLConfig struct {
-}
+type XMLConfig struct{}
 
 
 // Parse returns a ConfigContainer with parsed xml config map.
 // Parse returns a ConfigContainer with parsed xml config map.
-func (xmls *XMLConfig) Parse(filename string) (config.ConfigContainer, error) {
+func (xc *XMLConfig) Parse(filename string) (config.ConfigContainer, error) {
 	file, err := os.Open(filename)
 	file, err := os.Open(filename)
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
 	defer file.Close()
 	defer file.Close()
-	x := &XMLConfigContainer{
-		data: make(map[string]interface{}),
-	}
+
+	x := &XMLConfigContainer{data: make(map[string]interface{})}
 	content, err := ioutil.ReadAll(file)
 	content, err := ioutil.ReadAll(file)
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
+
 	d, err := x2j.DocToMap(string(content))
 	d, err := x2j.DocToMap(string(content))
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
+
 	x.data = d["config"].(map[string]interface{})
 	x.data = d["config"].(map[string]interface{})
 	return x, nil
 	return x, nil
 }
 }
 
 
+func (x *XMLConfig) ParseData(data []byte) (config.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 x.Parse(tmpName)
+}
+
 // A Config represents the xml configuration.
 // A Config represents the xml configuration.
 type XMLConfigContainer struct {
 type XMLConfigContainer struct {
 	data map[string]interface{}
 	data map[string]interface{}
@@ -57,21 +94,61 @@ func (c *XMLConfigContainer) Bool(key string) (bool, error) {
 	return strconv.ParseBool(c.data[key].(string))
 	return strconv.ParseBool(c.data[key].(string))
 }
 }
 
 
+// DefaultBool return the bool value if has no error
+// otherwise return the defaultval
+func (c *XMLConfigContainer) DefaultBool(key string, defaultval bool) bool {
+	if v, err := c.Bool(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 // Int returns the integer value for a given key.
 // Int returns the integer value for a given key.
 func (c *XMLConfigContainer) Int(key string) (int, error) {
 func (c *XMLConfigContainer) Int(key string) (int, error) {
 	return strconv.Atoi(c.data[key].(string))
 	return strconv.Atoi(c.data[key].(string))
 }
 }
 
 
+// DefaultInt returns the integer value for a given key.
+// if err != nil return defaltval
+func (c *XMLConfigContainer) DefaultInt(key string, defaultval int) int {
+	if v, err := c.Int(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 // Int64 returns the int64 value for a given key.
 // Int64 returns the int64 value for a given key.
 func (c *XMLConfigContainer) Int64(key string) (int64, error) {
 func (c *XMLConfigContainer) Int64(key string) (int64, error) {
 	return strconv.ParseInt(c.data[key].(string), 10, 64)
 	return strconv.ParseInt(c.data[key].(string), 10, 64)
 }
 }
 
 
+// DefaultInt64 returns the int64 value for a given key.
+// if err != nil return defaltval
+func (c *XMLConfigContainer) DefaultInt64(key string, defaultval int64) int64 {
+	if v, err := c.Int64(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 // Float returns the float value for a given key.
 // Float returns the float value for a given key.
 func (c *XMLConfigContainer) Float(key string) (float64, error) {
 func (c *XMLConfigContainer) Float(key string) (float64, error) {
 	return strconv.ParseFloat(c.data[key].(string), 64)
 	return strconv.ParseFloat(c.data[key].(string), 64)
 }
 }
 
 
+// DefaultFloat returns the float64 value for a given key.
+// if err != nil return defaltval
+func (c *XMLConfigContainer) DefaultFloat(key string, defaultval float64) float64 {
+	if v, err := c.Float(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 // String returns the string value for a given key.
 // String returns the string value for a given key.
 func (c *XMLConfigContainer) String(key string) string {
 func (c *XMLConfigContainer) String(key string) string {
 	if v, ok := c.data[key].(string); ok {
 	if v, ok := c.data[key].(string); ok {
@@ -80,11 +157,56 @@ func (c *XMLConfigContainer) String(key string) string {
 	return ""
 	return ""
 }
 }
 
 
+// DefaultString returns the string value for a given key.
+// if err != nil return defaltval
+func (c *XMLConfigContainer) DefaultString(key string, defaultval string) string {
+	if v := c.String(key); v == "" {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 // Strings returns the []string value for a given key.
 // Strings returns the []string value for a given key.
 func (c *XMLConfigContainer) Strings(key string) []string {
 func (c *XMLConfigContainer) Strings(key string) []string {
 	return strings.Split(c.String(key), ";")
 	return strings.Split(c.String(key), ";")
 }
 }
 
 
+// DefaultStrings returns the []string value for a given key.
+// if err != nil return defaltval
+func (c *XMLConfigContainer) DefaultStrings(key string, defaultval []string) []string {
+	if v := c.Strings(key); len(v) == 0 {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
+// GetSection returns map for the given section
+func (c *XMLConfigContainer) 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")
+	}
+}
+
+// SaveConfigFile save the config into file
+func (c *XMLConfigContainer) SaveConfigFile(filename string) (err error) {
+	// Write configuration file by filename.
+	f, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	b, err := xml.MarshalIndent(c.data, "  ", "    ")
+	if err != nil {
+		return err
+	}
+	_, err = f.Write(b)
+	return err
+}
+
 // WriteValue writes a new value for key.
 // WriteValue writes a new value for key.
 func (c *XMLConfigContainer) Set(key, val string) error {
 func (c *XMLConfigContainer) Set(key, val string) error {
 	c.Lock()
 	c.Lock()

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 config
+package xml
 
 
 import (
 import (
 	"os"
 	"os"

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 config
+// package yaml for config provider
+//
+// depend on github.com/beego/goyaml2
+//
+// go install github.com/beego/goyaml2
+//
+// Usage:
+// import(
+//   _ "github.com/astaxie/beego/config/yaml"
+//   "github.com/astaxie/beego/config"
+// )
+//
+//  cnf, err := config.NewConfig("yaml", "config.yaml")
+//
+//  more docs http://beego.me/docs/module/config.md
+package yaml
 
 
 import (
 import (
 	"bytes"
 	"bytes"
 	"encoding/json"
 	"encoding/json"
 	"errors"
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"io/ioutil"
 	"log"
 	"log"
 	"os"
 	"os"
+	"path"
 	"strings"
 	"strings"
 	"sync"
 	"sync"
+	"time"
 
 
 	"github.com/astaxie/beego/config"
 	"github.com/astaxie/beego/config"
 	"github.com/beego/goyaml2"
 	"github.com/beego/goyaml2"
 )
 )
 
 
 // YAMLConfig is a yaml config parser and implements Config interface.
 // YAMLConfig is a yaml config parser and implements Config interface.
-type YAMLConfig struct {
-}
+type YAMLConfig struct{}
 
 
 // Parse returns a ConfigContainer with parsed yaml config map.
 // Parse returns a ConfigContainer with parsed yaml config map.
-func (yaml *YAMLConfig) Parse(filename string) (config.ConfigContainer, error) {
-	y := &YAMLConfigContainer{
-		data: make(map[string]interface{}),
-	}
+func (yaml *YAMLConfig) Parse(filename string) (y config.ConfigContainer, err error) {
 	cnf, err := ReadYmlReader(filename)
 	cnf, err := ReadYmlReader(filename)
 	if err != nil {
 	if err != nil {
+		return
+	}
+	y = &YAMLConfigContainer{
+		data: cnf,
+	}
+	return
+}
+
+func (yaml *YAMLConfig) ParseData(data []byte) (config.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 nil, err
 	}
 	}
-	y.data = cnf
-	return y, nil
+	return yaml.Parse(tmpName)
 }
 }
 
 
 // Read yaml file to map.
 // Read yaml file to map.
 // if json like, use json package, unless goyaml2 package.
 // if json like, use json package, unless goyaml2 package.
 func ReadYmlReader(path string) (cnf map[string]interface{}, err error) {
 func ReadYmlReader(path string) (cnf map[string]interface{}, err error) {
-	err = nil
 	f, err := os.Open(path)
 	f, err := os.Open(path)
 	if err != nil {
 	if err != nil {
 		return
 		return
 	}
 	}
 	defer f.Close()
 	defer f.Close()
-	err = nil
+
 	buf, err := ioutil.ReadAll(f)
 	buf, err := ioutil.ReadAll(f)
 	if err != nil || len(buf) < 3 {
 	if err != nil || len(buf) < 3 {
 		return
 		return
 	}
 	}
 
 
 	if string(buf[0:1]) == "{" {
 	if string(buf[0:1]) == "{" {
-		log.Println("Look lile a Json, try it")
+		log.Println("Look like a Json, try json umarshal")
 		err = json.Unmarshal(buf, &cnf)
 		err = json.Unmarshal(buf, &cnf)
 		if err == nil {
 		if err == nil {
 			log.Println("It is Json Map")
 			log.Println("It is Json Map")
@@ -61,19 +94,19 @@ func ReadYmlReader(path string) (cnf map[string]interface{}, err error) {
 		}
 		}
 	}
 	}
 
 
-	_map, _err := goyaml2.Read(bytes.NewBuffer(buf))
-	if _err != nil {
-		log.Println("Goyaml2 ERR>", string(buf), _err)
-		//err = goyaml.Unmarshal(buf, &cnf)
-		err = _err
+	data, err := goyaml2.Read(bytes.NewBuffer(buf))
+	if err != nil {
+		log.Println("Goyaml2 ERR>", string(buf), err)
 		return
 		return
 	}
 	}
-	if _map == nil {
+
+	if data == nil {
 		log.Println("Goyaml2 output nil? Pls report bug\n" + string(buf))
 		log.Println("Goyaml2 output nil? Pls report bug\n" + string(buf))
+		return
 	}
 	}
-	cnf, ok := _map.(map[string]interface{})
+	cnf, ok := data.(map[string]interface{})
 	if !ok {
 	if !ok {
-		log.Println("Not a Map? >> ", string(buf), _map)
+		log.Println("Not a Map? >> ", string(buf), data)
 		cnf = nil
 		cnf = nil
 	}
 	}
 	return
 	return
@@ -93,6 +126,16 @@ func (c *YAMLConfigContainer) Bool(key string) (bool, error) {
 	return false, errors.New("not bool value")
 	return false, errors.New("not bool value")
 }
 }
 
 
+// DefaultBool return the bool value if has no error
+// otherwise return the defaultval
+func (c *YAMLConfigContainer) DefaultBool(key string, defaultval bool) bool {
+	if v, err := c.Bool(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 // Int returns the integer value for a given key.
 // Int returns the integer value for a given key.
 func (c *YAMLConfigContainer) Int(key string) (int, error) {
 func (c *YAMLConfigContainer) Int(key string) (int, error) {
 	if v, ok := c.data[key].(int64); ok {
 	if v, ok := c.data[key].(int64); ok {
@@ -101,6 +144,16 @@ func (c *YAMLConfigContainer) Int(key string) (int, error) {
 	return 0, errors.New("not int value")
 	return 0, errors.New("not int value")
 }
 }
 
 
+// DefaultInt returns the integer value for a given key.
+// if err != nil return defaltval
+func (c *YAMLConfigContainer) DefaultInt(key string, defaultval int) int {
+	if v, err := c.Int(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 // Int64 returns the int64 value for a given key.
 // Int64 returns the int64 value for a given key.
 func (c *YAMLConfigContainer) Int64(key string) (int64, error) {
 func (c *YAMLConfigContainer) Int64(key string) (int64, error) {
 	if v, ok := c.data[key].(int64); ok {
 	if v, ok := c.data[key].(int64); ok {
@@ -109,6 +162,16 @@ func (c *YAMLConfigContainer) Int64(key string) (int64, error) {
 	return 0, errors.New("not bool value")
 	return 0, errors.New("not bool value")
 }
 }
 
 
+// DefaultInt64 returns the int64 value for a given key.
+// if err != nil return defaltval
+func (c *YAMLConfigContainer) DefaultInt64(key string, defaultval int64) int64 {
+	if v, err := c.Int64(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 // Float returns the float value for a given key.
 // Float returns the float value for a given key.
 func (c *YAMLConfigContainer) Float(key string) (float64, error) {
 func (c *YAMLConfigContainer) Float(key string) (float64, error) {
 	if v, ok := c.data[key].(float64); ok {
 	if v, ok := c.data[key].(float64); ok {
@@ -117,6 +180,16 @@ func (c *YAMLConfigContainer) Float(key string) (float64, error) {
 	return 0.0, errors.New("not float64 value")
 	return 0.0, errors.New("not float64 value")
 }
 }
 
 
+// DefaultFloat returns the float64 value for a given key.
+// if err != nil return defaltval
+func (c *YAMLConfigContainer) DefaultFloat(key string, defaultval float64) float64 {
+	if v, err := c.Float(key); err != nil {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 // String returns the string value for a given key.
 // String returns the string value for a given key.
 func (c *YAMLConfigContainer) String(key string) string {
 func (c *YAMLConfigContainer) String(key string) string {
 	if v, ok := c.data[key].(string); ok {
 	if v, ok := c.data[key].(string); ok {
@@ -125,11 +198,52 @@ func (c *YAMLConfigContainer) String(key string) string {
 	return ""
 	return ""
 }
 }
 
 
+// DefaultString returns the string value for a given key.
+// if err != nil return defaltval
+func (c *YAMLConfigContainer) DefaultString(key string, defaultval string) string {
+	if v := c.String(key); v == "" {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
 // Strings returns the []string value for a given key.
 // Strings returns the []string value for a given key.
 func (c *YAMLConfigContainer) Strings(key string) []string {
 func (c *YAMLConfigContainer) Strings(key string) []string {
 	return strings.Split(c.String(key), ";")
 	return strings.Split(c.String(key), ";")
 }
 }
 
 
+// DefaultStrings returns the []string value for a given key.
+// if err != nil return defaltval
+func (c *YAMLConfigContainer) DefaultStrings(key string, defaultval []string) []string {
+	if v := c.Strings(key); len(v) == 0 {
+		return defaultval
+	} else {
+		return v
+	}
+}
+
+// GetSection returns map for the given section
+func (c *YAMLConfigContainer) 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")
+	}
+}
+
+// SaveConfigFile save the config into file
+func (c *YAMLConfigContainer) SaveConfigFile(filename string) (err error) {
+	// Write configuration file by filename.
+	f, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	err = goyaml2.Write(f, c.data)
+	return err
+}
+
 // WriteValue writes a new value for key.
 // WriteValue writes a new value for key.
 func (c *YAMLConfigContainer) Set(key, val string) error {
 func (c *YAMLConfigContainer) Set(key, val string) error {
 	c.Lock()
 	c.Lock()

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 config
+package yaml
 
 
 import (
 import (
 	"os"
 	"os"

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package beego
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
-
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Usage:
+//
+//	import "github.com/astaxie/beego/context"
+//
+//	ctx := context.Context{Request:req,ResponseWriter:rw}
+//
+//  more docs http://beego.me/docs/module/context.md
 package context
 package context
 
 
 import (
 import (
@@ -17,6 +32,7 @@ import (
 	"time"
 	"time"
 
 
 	"github.com/astaxie/beego/middleware"
 	"github.com/astaxie/beego/middleware"
+	"github.com/astaxie/beego/utils"
 )
 )
 
 
 // Http request context struct including BeegoInput, BeegoOutput, http.Request and http.ResponseWriter.
 // Http request context struct including BeegoInput, BeegoOutput, http.Request and http.ResponseWriter.
@@ -26,20 +42,21 @@ type Context struct {
 	Output         *BeegoOutput
 	Output         *BeegoOutput
 	Request        *http.Request
 	Request        *http.Request
 	ResponseWriter http.ResponseWriter
 	ResponseWriter http.ResponseWriter
+	_xsrf_token    string
 }
 }
 
 
 // Redirect does redirection to localurl with http header status code.
 // Redirect does redirection to localurl with http header status code.
 // It sends http response header directly.
 // It sends http response header directly.
 func (ctx *Context) Redirect(status int, localurl string) {
 func (ctx *Context) Redirect(status int, localurl string) {
 	ctx.Output.Header("Location", localurl)
 	ctx.Output.Header("Location", localurl)
-	ctx.Output.SetStatus(status)
+	ctx.ResponseWriter.WriteHeader(status)
 }
 }
 
 
 // Abort stops this request.
 // Abort stops this request.
 // if middleware.ErrorMaps exists, panic body.
 // if middleware.ErrorMaps exists, panic body.
 // if middleware.HTTPExceptionMaps exists, panic HTTPException struct with status and body string.
 // if middleware.HTTPExceptionMaps exists, panic HTTPException struct with status and body string.
 func (ctx *Context) Abort(status int, body string) {
 func (ctx *Context) Abort(status int, body string) {
-	ctx.Output.SetStatus(status)
+	ctx.ResponseWriter.WriteHeader(status)
 	// first panic from ErrorMaps, is is user defined error functions.
 	// first panic from ErrorMaps, is is user defined error functions.
 	if _, ok := middleware.ErrorMaps[body]; ok {
 	if _, ok := middleware.ErrorMaps[body]; ok {
 		panic(body)
 		panic(body)
@@ -58,7 +75,7 @@ func (ctx *Context) Abort(status int, body string) {
 // Write string to response body.
 // Write string to response body.
 // it sends response body.
 // it sends response body.
 func (ctx *Context) WriteString(content string) {
 func (ctx *Context) WriteString(content string) {
-	ctx.Output.Body([]byte(content))
+	ctx.ResponseWriter.Write([]byte(content))
 }
 }
 
 
 // Get cookie from request by a given key.
 // Get cookie from request by a given key.
@@ -110,3 +127,35 @@ func (ctx *Context) SetSecureCookie(Secret, name, value string, others ...interf
 	cookie := strings.Join([]string{vs, timestamp, sig}, "|")
 	cookie := strings.Join([]string{vs, timestamp, sig}, "|")
 	ctx.Output.Cookie(name, cookie, others...)
 	ctx.Output.Cookie(name, cookie, others...)
 }
 }
+
+// XsrfToken creates a xsrf token string and returns.
+func (ctx *Context) XsrfToken(key string, expire int64) string {
+	if ctx._xsrf_token == "" {
+		token, ok := ctx.GetSecureCookie(key, "_xsrf")
+		if !ok {
+			token = string(utils.RandomCreateBytes(32))
+			ctx.SetSecureCookie(key, "_xsrf", token, expire)
+		}
+		ctx._xsrf_token = token
+	}
+	return ctx._xsrf_token
+}
+
+// CheckXsrfCookie checks xsrf token in this request is valid or not.
+// the token can provided in request header "X-Xsrftoken" and "X-CsrfToken"
+// or in form field value named as "_xsrf".
+func (ctx *Context) CheckXsrfCookie() bool {
+	token := ctx.Input.Query("_xsrf")
+	if token == "" {
+		token = ctx.Request.Header.Get("X-Xsrftoken")
+	}
+	if token == "" {
+		token = ctx.Request.Header.Get("X-Csrftoken")
+	}
+	if token == "" {
+		ctx.Abort(403, "'_xsrf' argument missing from POST")
+	} else if ctx._xsrf_token != token {
+		ctx.Abort(403, "XSRF cookie does not match POST argument")
+	}
+	return true
+}

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 context
 package context
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 context
 package context
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 context
 package context
 
 
@@ -68,6 +76,14 @@ func (output *BeegoOutput) Body(content []byte) {
 	} else {
 	} else {
 		output.Header("Content-Length", strconv.Itoa(len(content)))
 		output.Header("Content-Length", strconv.Itoa(len(content)))
 	}
 	}
+
+	// Write status code if it has been set manually
+	// Set it to 0 afterwards to prevent "multiple response.WriteHeader calls"
+	if output.Status != 0 {
+		output.Context.ResponseWriter.WriteHeader(output.Status)
+		output.Status = 0
+	}
+
 	output_writer.Write(content)
 	output_writer.Write(content)
 	switch output_writer.(type) {
 	switch output_writer.(type) {
 	case *gzip.Writer:
 	case *gzip.Writer:
@@ -267,7 +283,6 @@ func (output *BeegoOutput) ContentType(ext string) {
 // SetStatus sets response status code.
 // SetStatus sets response status code.
 // It writes response header directly.
 // It writes response header directly.
 func (output *BeegoOutput) SetStatus(status int) {
 func (output *BeegoOutput) SetStatus(status int) {
-	output.Context.ResponseWriter.WriteHeader(status)
 	output.Status = status
 	output.Status = status
 }
 }
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package beego
 
 
@@ -22,7 +30,6 @@ import (
 
 
 	"github.com/astaxie/beego/context"
 	"github.com/astaxie/beego/context"
 	"github.com/astaxie/beego/session"
 	"github.com/astaxie/beego/session"
-	"github.com/astaxie/beego/utils"
 )
 )
 
 
 //commonly used mime-types
 //commonly used mime-types
@@ -270,6 +277,11 @@ func (c *Controller) Abort(code string) {
 	}
 	}
 }
 }
 
 
+// CustomAbort stops controller handler and show the error data, it's similar Aborts, but support status code and body.
+func (c *Controller) CustomAbort(status int, body string) {
+	c.Ctx.Abort(status, body)
+}
+
 // StopRun makes panic of USERSTOPRUN error and go to recover function if defined.
 // StopRun makes panic of USERSTOPRUN error and go to recover function if defined.
 func (c *Controller) StopRun() {
 func (c *Controller) StopRun() {
 	panic(USERSTOPRUN)
 	panic(USERSTOPRUN)
@@ -474,18 +486,13 @@ func (c *Controller) SetSecureCookie(Secret, name, value string, others ...inter
 // XsrfToken creates a xsrf token string and returns.
 // XsrfToken creates a xsrf token string and returns.
 func (c *Controller) XsrfToken() string {
 func (c *Controller) XsrfToken() string {
 	if c._xsrf_token == "" {
 	if c._xsrf_token == "" {
-		token, ok := c.GetSecureCookie(XSRFKEY, "_xsrf")
-		if !ok {
-			var expire int64
-			if c.XSRFExpire > 0 {
-				expire = int64(c.XSRFExpire)
-			} else {
-				expire = int64(XSRFExpire)
-			}
-			token = string(utils.RandomCreateBytes(32))
-			c.SetSecureCookie(XSRFKEY, "_xsrf", token, expire)
+		var expire int64
+		if c.XSRFExpire > 0 {
+			expire = int64(c.XSRFExpire)
+		} else {
+			expire = int64(XSRFExpire)
 		}
 		}
-		c._xsrf_token = token
+		c._xsrf_token = c.Ctx.XsrfToken(XSRFKEY, expire)
 	}
 	}
 	return c._xsrf_token
 	return c._xsrf_token
 }
 }
@@ -497,19 +504,7 @@ func (c *Controller) CheckXsrfCookie() bool {
 	if !c.EnableXSRF {
 	if !c.EnableXSRF {
 		return true
 		return true
 	}
 	}
-	token := c.GetString("_xsrf")
-	if token == "" {
-		token = c.Ctx.Request.Header.Get("X-Xsrftoken")
-	}
-	if token == "" {
-		token = c.Ctx.Request.Header.Get("X-Csrftoken")
-	}
-	if token == "" {
-		c.Ctx.Abort(403, "'_xsrf' argument missing from POST")
-	} else if c._xsrf_token != token {
-		c.Ctx.Abort(403, "XSRF cookie does not match POST argument")
-	}
-	return true
+	return c.Ctx.CheckXsrfCookie()
 }
 }
 
 
 // XsrfFormHtml writes an input field contains xsrf token value.
 // XsrfFormHtml writes an input field contains xsrf token value.

+// 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
 package beego
 
 
 import (
 import (

 // Beego (http://beego.me/)
 // Beego (http://beego.me/)
+
 // @description beego is an open-source, high-performance web framework for the Go programming language.
 // @description beego is an open-source, high-performance web framework for the Go programming language.
+
 // @link        http://github.com/astaxie/beego for the canonical source repository
 // @link        http://github.com/astaxie/beego for the canonical source repository
+
 // @license     http://github.com/astaxie/beego/blob/master/LICENSE
 // @license     http://github.com/astaxie/beego/blob/master/LICENSE
+
 // @authors     astaxie
 // @authors     astaxie
 
 
 package main
 package main

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package beego
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package beego
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package beego
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package beego
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
+// Usage:
+//
+// import "github.com/astaxie/beego/context"
+//
+//	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()
+//	if err != nil {
+//		t.Fatal(err)
+//	}
+//	fmt.Println(str)
+//
+//  more docs http://beego.me/docs/module/httplib.md
 package httplib
 package httplib
 
 
 import (
 import (
@@ -52,41 +76,46 @@ func SetDefaultSetting(setting BeegoHttpSettings) {
 // Get returns *BeegoHttpRequest with GET method.
 // Get returns *BeegoHttpRequest with GET method.
 func Get(url string) *BeegoHttpRequest {
 func Get(url string) *BeegoHttpRequest {
 	var req http.Request
 	var req http.Request
+	var resp http.Response
 	req.Method = "GET"
 	req.Method = "GET"
 	req.Header = http.Header{}
 	req.Header = http.Header{}
-	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting}
+	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting, &resp, nil}
 }
 }
 
 
 // Post returns *BeegoHttpRequest with POST method.
 // Post returns *BeegoHttpRequest with POST method.
 func Post(url string) *BeegoHttpRequest {
 func Post(url string) *BeegoHttpRequest {
 	var req http.Request
 	var req http.Request
+	var resp http.Response
 	req.Method = "POST"
 	req.Method = "POST"
 	req.Header = http.Header{}
 	req.Header = http.Header{}
-	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting}
+	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting, &resp, nil}
 }
 }
 
 
 // Put returns *BeegoHttpRequest with PUT method.
 // Put returns *BeegoHttpRequest with PUT method.
 func Put(url string) *BeegoHttpRequest {
 func Put(url string) *BeegoHttpRequest {
 	var req http.Request
 	var req http.Request
+	var resp http.Response
 	req.Method = "PUT"
 	req.Method = "PUT"
 	req.Header = http.Header{}
 	req.Header = http.Header{}
-	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting}
+	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting, &resp, nil}
 }
 }
 
 
 // Delete returns *BeegoHttpRequest DELETE GET method.
 // Delete returns *BeegoHttpRequest DELETE GET method.
 func Delete(url string) *BeegoHttpRequest {
 func Delete(url string) *BeegoHttpRequest {
 	var req http.Request
 	var req http.Request
+	var resp http.Response
 	req.Method = "DELETE"
 	req.Method = "DELETE"
 	req.Header = http.Header{}
 	req.Header = http.Header{}
-	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting}
+	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting, &resp, nil}
 }
 }
 
 
 // Head returns *BeegoHttpRequest with HEAD method.
 // Head returns *BeegoHttpRequest with HEAD method.
 func Head(url string) *BeegoHttpRequest {
 func Head(url string) *BeegoHttpRequest {
 	var req http.Request
 	var req http.Request
+	var resp http.Response
 	req.Method = "HEAD"
 	req.Method = "HEAD"
 	req.Header = http.Header{}
 	req.Header = http.Header{}
-	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting}
+	return &BeegoHttpRequest{url, &req, map[string]string{}, map[string]string{}, defaultSetting, &resp, nil}
 }
 }
 
 
 // BeegoHttpSettings
 // BeegoHttpSettings
@@ -108,6 +137,8 @@ type BeegoHttpRequest struct {
 	params  map[string]string
 	params  map[string]string
 	files   map[string]string
 	files   map[string]string
 	setting BeegoHttpSettings
 	setting BeegoHttpSettings
+	resp    *http.Response
+	body    []byte
 }
 }
 
 
 // Change request settings
 // Change request settings
@@ -123,7 +154,7 @@ func (b *BeegoHttpRequest) SetEnableCookie(enable bool) *BeegoHttpRequest {
 }
 }
 
 
 // SetUserAgent sets User-Agent header field
 // SetUserAgent sets User-Agent header field
-func (b *BeegoHttpRequest) SetAgent(useragent string) *BeegoHttpRequest {
+func (b *BeegoHttpRequest) SetUserAgent(useragent string) *BeegoHttpRequest {
 	b.setting.UserAgent = useragent
 	b.setting.UserAgent = useragent
 	return b
 	return b
 }
 }
@@ -223,6 +254,9 @@ func (b *BeegoHttpRequest) Body(data interface{}) *BeegoHttpRequest {
 }
 }
 
 
 func (b *BeegoHttpRequest) getResponse() (*http.Response, error) {
 func (b *BeegoHttpRequest) getResponse() (*http.Response, error) {
+	if b.resp.StatusCode != 0 {
+		return b.resp, nil
+	}
 	var paramBody string
 	var paramBody string
 	if len(b.params) > 0 {
 	if len(b.params) > 0 {
 		var buf bytes.Buffer
 		var buf bytes.Buffer
@@ -341,6 +375,7 @@ func (b *BeegoHttpRequest) getResponse() (*http.Response, error) {
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
+	b.resp = resp
 	return resp, nil
 	return resp, nil
 }
 }
 
 
@@ -358,6 +393,9 @@ func (b *BeegoHttpRequest) String() (string, error) {
 // Bytes returns the body []byte in response.
 // Bytes returns the body []byte in response.
 // it calls Response inner.
 // it calls Response inner.
 func (b *BeegoHttpRequest) Bytes() ([]byte, error) {
 func (b *BeegoHttpRequest) Bytes() ([]byte, error) {
+	if b.body != nil {
+		return b.body, nil
+	}
 	resp, err := b.getResponse()
 	resp, err := b.getResponse()
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
@@ -370,6 +408,7 @@ func (b *BeegoHttpRequest) Bytes() ([]byte, error) {
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
+	b.body = data
 	return data, nil
 	return data, nil
 }
 }
 
 
@@ -391,10 +430,7 @@ func (b *BeegoHttpRequest) ToFile(filename string) error {
 	}
 	}
 	defer resp.Body.Close()
 	defer resp.Body.Close()
 	_, err = io.Copy(f, resp.Body)
 	_, err = io.Copy(f, resp.Body)
-	if err != nil {
-		return err
-	}
-	return nil
+	return err
 }
 }
 
 
 // ToJson returns the map that marshals from the body bytes as json in response .
 // ToJson returns the map that marshals from the body bytes as json in response .
@@ -405,24 +441,18 @@ func (b *BeegoHttpRequest) ToJson(v interface{}) error {
 		return err
 		return err
 	}
 	}
 	err = json.Unmarshal(data, v)
 	err = json.Unmarshal(data, v)
-	if err != nil {
-		return err
-	}
-	return nil
+	return err
 }
 }
 
 
 // ToXml returns the map that marshals from the body bytes as xml in response .
 // ToXml returns the map that marshals from the body bytes as xml in response .
 // it calls Response inner.
 // it calls Response inner.
-func (b *BeegoHttpRequest) ToXML(v interface{}) error {
+func (b *BeegoHttpRequest) ToXml(v interface{}) error {
 	data, err := b.Bytes()
 	data, err := b.Bytes()
 	if err != nil {
 	if err != nil {
 		return err
 		return err
 	}
 	}
 	err = xml.Unmarshal(data, v)
 	err = xml.Unmarshal(data, v)
-	if err != nil {
-		return err
-	}
-	return nil
+	return err
 }
 }
 
 
 // Response executes request client gets response mannually.
 // Response executes request client gets response mannually.

-// Beego (http://beego.me)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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 httplib
 package httplib
 
 
 import (
 import (
-	"fmt"
 	"io/ioutil"
 	"io/ioutil"
+	"os"
+	"strings"
 	"testing"
 	"testing"
 )
 )
 
 
-func TestGetUrl(t *testing.T) {
-	resp, err := Get("http://beego.me").Debug(true).Response()
+func TestResponse(t *testing.T) {
+	req := Get("http://httpbin.org/get")
+	resp, err := req.Response()
 	if err != nil {
 	if err != nil {
 		t.Fatal(err)
 		t.Fatal(err)
 	}
 	}
-	if resp.Body == nil {
-		t.Fatal("body is nil")
+	t.Log(resp)
+}
+
+func TestGet(t *testing.T) {
+	req := Get("http://httpbin.org/get")
+	b, err := req.Bytes()
+	if err != nil {
+		t.Fatal(err)
 	}
 	}
-	data, err := ioutil.ReadAll(resp.Body)
-	defer resp.Body.Close()
+	t.Log(b)
+
+	s, err := req.String()
 	if err != nil {
 	if err != nil {
 		t.Fatal(err)
 		t.Fatal(err)
 	}
 	}
-	if len(data) == 0 {
-		t.Fatal("data is no")
+	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 := Get("http://beego.me").String()
+	str, err := req.String()
 	if err != nil {
 	if err != nil {
 		t.Fatal(err)
 		t.Fatal(err)
 	}
 	}
-	if len(str) == 0 {
-		t.Fatal("has no info")
+	t.Log(str)
+
+	n := strings.Index(str, v)
+	if n == -1 {
+		t.Fatal(v + " not found in post")
 	}
 	}
 }
 }
 
 
-func ExamplePost(t *testing.T) {
-	b := Post("http://beego.me/").Debug(true)
-	b.Param("username", "astaxie")
-	b.Param("password", "hello")
-	b.PostFile("uploadfile", "httplib_test.go")
-	str, err := b.String()
+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()
 	if err != nil {
 	if err != nil {
 		t.Fatal(err)
 		t.Fatal(err)
 	}
 	}
-	fmt.Println(str)
+	t.Log(str)
+
+	n := strings.Index(str, v)
+	if n == -1 {
+		t.Fatal(v + " not found in post")
+	}
 }
 }
 
 
-func TestSimpleGetString(t *testing.T) {
-	fmt.Println("TestSimpleGetString==========================================")
-	html, err := Get("http://httpbin.org/headers").SetAgent("beegoooooo").String()
+func TestSimplePut(t *testing.T) {
+	str, err := Put("http://httpbin.org/put").String()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(str)
+}
+
+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) {
+	v := "smallfish"
+	str, err := Get("http://httpbin.org/cookies/set?k1=" + v).SetEnableCookie(true).String()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(str)
+
+	str, err = Get("http://httpbin.org/cookies").SetEnableCookie(true).String()
 	if err != nil {
 	if err != nil {
 		t.Fatal(err)
 		t.Fatal(err)
 	}
 	}
-	fmt.Println(html)
-	fmt.Println("TestSimpleGetString==========================================")
+	t.Log(str)
+
+	n := strings.Index(str, v)
+	if n == -1 {
+		t.Fatal(v + " not found in cookie")
+	}
 }
 }
 
 
-func TestSimpleGetStringWithDefaultCookie(t *testing.T) {
-	fmt.Println("TestSimpleGetStringWithDefaultCookie==========================================")
-	html, err := Get("http://httpbin.org/cookies/set?k1=v1").SetEnableCookie(true).String()
+func TestWithUserAgent(t *testing.T) {
+	v := "beego"
+	str, err := Get("http://httpbin.org/headers").SetUserAgent(v).String()
 	if err != nil {
 	if err != nil {
 		t.Fatal(err)
 		t.Fatal(err)
 	}
 	}
-	fmt.Println(html)
-	html, err = Get("http://httpbin.org/cookies").SetEnableCookie(true).String()
+	t.Log(str)
+
+	n := strings.Index(str, v)
+	if n == -1 {
+		t.Fatal(v + " not found in user-agent")
+	}
+}
+
+func TestWithSetting(t *testing.T) {
+	v := "beego"
+	var setting BeegoHttpSettings
+	setting.EnableCookie = true
+	setting.UserAgent = v
+	setting.Transport = nil
+	SetDefaultSetting(setting)
+
+	str, err := Get("http://httpbin.org/get").String()
 	if err != nil {
 	if err != nil {
 		t.Fatal(err)
 		t.Fatal(err)
 	}
 	}
-	fmt.Println(html)
-	fmt.Println("TestSimpleGetStringWithDefaultCookie==========================================")
+	t.Log(str)
+
+	n := strings.Index(str, v)
+	if n == -1 {
+		t.Fatal(v + " not found in user-agent")
+	}
 }
 }
 
 
-func TestDefaultSetting(t *testing.T) {
-	fmt.Println("TestDefaultSetting==========================================")
-	var def BeegoHttpSettings
-	def.EnableCookie = true
-	//def.ShowDebug = true
-	def.UserAgent = "UserAgent"
-	//def.ConnectTimeout = 60*time.Second
-	//def.ReadWriteTimeout = 60*time.Second
-	def.Transport = nil //http.DefaultTransport
-	SetDefaultSetting(def)
-
-	html, err := Get("http://httpbin.org/headers").String()
+func TestToJson(t *testing.T) {
+	req := Get("http://httpbin.org/ip")
+	resp, err := req.Response()
 	if err != nil {
 	if err != nil {
 		t.Fatal(err)
 		t.Fatal(err)
 	}
 	}
-	fmt.Println(html)
-	html, err = Get("http://httpbin.org/headers").String()
+	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 {
 	if err != nil {
 		t.Fatal(err)
 		t.Fatal(err)
 	}
 	}
-	fmt.Println(html)
-	fmt.Println("TestDefaultSetting==========================================")
+	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)
+	}
 }
 }

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package beego
 
 
@@ -14,12 +22,14 @@ import (
 
 
 // Log levels to control the logging output.
 // Log levels to control the logging output.
 const (
 const (
-	LevelTrace = iota
-	LevelDebug
-	LevelInfo
-	LevelWarning
-	LevelError
+	LevelEmergency = iota
+	LevelAlert
 	LevelCritical
 	LevelCritical
+	LevelError
+	LevelWarning
+	LevelNotice
+	LevelInformational
+	LevelDebug
 )
 )
 
 
 // SetLogLevel sets the global log level used by the simple
 // SetLogLevel sets the global log level used by the simple
@@ -45,34 +55,57 @@ func SetLogger(adaptername string, config string) error {
 	return nil
 	return nil
 }
 }
 
 
-// Trace logs a message at trace level.
-func Trace(v ...interface{}) {
-	BeeLogger.Trace(generateFmtStr(len(v)), v...)
+func Emergency(v ...interface{}) {
+	BeeLogger.Emergency(generateFmtStr(len(v)), v...)
 }
 }
 
 
-// Debug logs a message at debug level.
-func Debug(v ...interface{}) {
-	BeeLogger.Debug(generateFmtStr(len(v)), v...)
+func Alert(v ...interface{}) {
+	BeeLogger.Alert(generateFmtStr(len(v)), v...)
 }
 }
 
 
-// Info logs a message at info level.
-func Info(v ...interface{}) {
-	BeeLogger.Info(generateFmtStr(len(v)), v...)
+// Critical logs a message at critical level.
+func Critical(v ...interface{}) {
+	BeeLogger.Critical(generateFmtStr(len(v)), v...)
+}
+
+// Error logs a message at error level.
+func Error(v ...interface{}) {
+	BeeLogger.Error(generateFmtStr(len(v)), v...)
 }
 }
 
 
 // Warning logs a message at warning level.
 // Warning logs a message at warning level.
+func Warning(v ...interface{}) {
+	BeeLogger.Warning(generateFmtStr(len(v)), v...)
+}
+
+// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0.
 func Warn(v ...interface{}) {
 func Warn(v ...interface{}) {
-	BeeLogger.Warn(generateFmtStr(len(v)), v...)
+	Warning(v...)
 }
 }
 
 
-// Error logs a message at error level.
-func Error(v ...interface{}) {
-	BeeLogger.Error(generateFmtStr(len(v)), v...)
+func Notice(v ...interface{}) {
+	BeeLogger.Notice(generateFmtStr(len(v)), v...)
 }
 }
 
 
-// Critical logs a message at critical level.
-func Critical(v ...interface{}) {
-	BeeLogger.Critical(generateFmtStr(len(v)), v...)
+// Info logs a message at info level.
+func Informational(v ...interface{}) {
+	BeeLogger.Informational(generateFmtStr(len(v)), v...)
+}
+
+// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0.
+func Info(v ...interface{}) {
+	Informational(v...)
+}
+
+// Debug logs a message at debug level.
+func Debug(v ...interface{}) {
+	BeeLogger.Debug(generateFmtStr(len(v)), v...)
+}
+
+// Trace logs a message at trace level.
+// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0.
+func Trace(v ...interface{}) {
+	BeeLogger.Trace(generateFmtStr(len(v)), v...)
 }
 }
 
 
 func generateFmtStr(n int) string {
 func generateFmtStr(n int) string {

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
 package logs
 package logs
 
 
@@ -45,7 +53,7 @@ func (c *ConnWriter) Init(jsonconfig string) error {
 // write message in connection.
 // write message in connection.
 // if connection is down, try to re-connect.
 // if connection is down, try to re-connect.
 func (c *ConnWriter) WriteMsg(msg string, level int) error {
 func (c *ConnWriter) WriteMsg(msg string, level int) error {
-	if level < c.Level {
+	if level > c.Level {
 		return nil
 		return nil
 	}
 	}
 	if c.neddedConnectOnMsg() {
 	if c.neddedConnectOnMsg() {

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
 package logs
 package logs
 
 
@@ -13,5 +21,5 @@ import (
 func TestConn(t *testing.T) {
 func TestConn(t *testing.T) {
 	log := NewLogger(1000)
 	log := NewLogger(1000)
 	log.SetLogger("conn", `{"net":"tcp","addr":":7020"}`)
 	log.SetLogger("conn", `{"net":"tcp","addr":":7020"}`)
-	log.Info("info")
+	log.Informational("informational")
 }
 }

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
 package logs
 package logs
 
 
@@ -24,12 +32,14 @@ func NewBrush(color string) Brush {
 }
 }
 
 
 var colors = []Brush{
 var colors = []Brush{
-	NewBrush("1;36"), // Trace      cyan
-	NewBrush("1;34"), // Debug      blue
-	NewBrush("1;32"), // Info       green
-	NewBrush("1;33"), // Warn       yellow
+	NewBrush("1;37"), // Emergency	white
+	NewBrush("1;36"), // Alert			cyan
+	NewBrush("1;35"), // Critical   magenta
 	NewBrush("1;31"), // Error      red
 	NewBrush("1;31"), // Error      red
-	NewBrush("1;35"), // Critical   purple
+	NewBrush("1;33"), // Warning    yellow
+	NewBrush("1;32"), // Notice			green
+	NewBrush("1;34"), // Informational	blue
+	NewBrush("1;34"), // Debug      blue
 }
 }
 
 
 // ConsoleWriter implements LoggerInterface and writes messages to terminal.
 // ConsoleWriter implements LoggerInterface and writes messages to terminal.
@@ -42,7 +52,7 @@ type ConsoleWriter struct {
 func NewConsole() LoggerInterface {
 func NewConsole() LoggerInterface {
 	cw := new(ConsoleWriter)
 	cw := new(ConsoleWriter)
 	cw.lg = log.New(os.Stdout, "", log.Ldate|log.Ltime)
 	cw.lg = log.New(os.Stdout, "", log.Ldate|log.Ltime)
-	cw.Level = LevelTrace
+	cw.Level = LevelDebug
 	return cw
 	return cw
 }
 }
 
 
@@ -61,7 +71,7 @@ func (c *ConsoleWriter) Init(jsonconfig string) error {
 
 
 // write message in console.
 // write message in console.
 func (c *ConsoleWriter) WriteMsg(msg string, level int) error {
 func (c *ConsoleWriter) WriteMsg(msg string, level int) error {
-	if level < c.Level {
+	if level > c.Level {
 		return nil
 		return nil
 	}
 	}
 	if goos := runtime.GOOS; goos == "windows" {
 	if goos := runtime.GOOS; goos == "windows" {

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
 package logs
 package logs
 
 
@@ -10,22 +18,29 @@ import (
 	"testing"
 	"testing"
 )
 )
 
 
+// Try each log level in decreasing order of priority.
+func testConsoleCalls(bl *BeeLogger) {
+	bl.Emergency("emergency")
+	bl.Alert("alert")
+	bl.Critical("critical")
+	bl.Error("error")
+	bl.Warning("warning")
+	bl.Notice("notice")
+	bl.Informational("informational")
+	bl.Debug("debug")
+}
+
+// Test console logging by visually comparing the lines being output with and
+// without a log level specification.
 func TestConsole(t *testing.T) {
 func TestConsole(t *testing.T) {
-	log := NewLogger(10000)
-	log.EnableFuncCallDepth(true)
-	log.SetLogger("console", "")
-	log.Trace("trace")
-	log.Info("info")
-	log.Warn("warning")
-	log.Debug("debug")
-	log.Critical("critical")
+	log1 := NewLogger(10000)
+	log1.EnableFuncCallDepth(true)
+	log1.SetLogger("console", "")
+	testConsoleCalls(log1)
+
 	log2 := NewLogger(100)
 	log2 := NewLogger(100)
-	log2.SetLogger("console", `{"level":1}`)
-	log.Trace("trace")
-	log.Info("info")
-	log.Warn("warning")
-	log.Debug("debug")
-	log.Critical("critical")
+	log2.SetLogger("console", `{"level":3}`)
+	testConsoleCalls(log2)
 }
 }
 
 
 func BenchmarkConsole(b *testing.B) {
 func BenchmarkConsole(b *testing.B) {
@@ -33,6 +48,6 @@ func BenchmarkConsole(b *testing.B) {
 	log.EnableFuncCallDepth(true)
 	log.EnableFuncCallDepth(true)
 	log.SetLogger("console", "")
 	log.SetLogger("console", "")
 	for i := 0; i < b.N; i++ {
 	for i := 0; i < b.N; i++ {
-		log.Trace("trace")
+		log.Debug("debug")
 	}
 	}
 }
 }

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
 package logs
 package logs
 
 
@@ -138,7 +146,7 @@ func (w *FileLogWriter) docheck(size int) {
 
 
 // write logger message into file.
 // write logger message into file.
 func (w *FileLogWriter) WriteMsg(msg string, level int) error {
 func (w *FileLogWriter) WriteMsg(msg string, level int) error {
-	if level < w.Level {
+	if level > w.Level {
 		return nil
 		return nil
 	}
 	}
 	n := 24 + len(msg) // 24 stand for the length "2013/06/23 21:00:22 [T] "
 	n := 24 + len(msg) // 24 stand for the length "2013/06/23 21:00:22 [T] "

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
 package logs
 package logs
 
 
@@ -10,6 +18,7 @@ import (
 	"bufio"
 	"bufio"
 	"fmt"
 	"fmt"
 	"os"
 	"os"
+	"strconv"
 	"testing"
 	"testing"
 	"time"
 	"time"
 )
 )
@@ -17,12 +26,14 @@ import (
 func TestFile(t *testing.T) {
 func TestFile(t *testing.T) {
 	log := NewLogger(10000)
 	log := NewLogger(10000)
 	log.SetLogger("file", `{"filename":"test.log"}`)
 	log.SetLogger("file", `{"filename":"test.log"}`)
-	log.Trace("test")
-	log.Info("info")
 	log.Debug("debug")
 	log.Debug("debug")
-	log.Warn("warning")
+	log.Informational("info")
+	log.Notice("notice")
+	log.Warning("warning")
 	log.Error("error")
 	log.Error("error")
+	log.Alert("alert")
 	log.Critical("critical")
 	log.Critical("critical")
+	log.Emergency("emergency")
 	time.Sleep(time.Second * 4)
 	time.Sleep(time.Second * 4)
 	f, err := os.Open("test.log")
 	f, err := os.Open("test.log")
 	if err != nil {
 	if err != nil {
@@ -39,21 +50,24 @@ func TestFile(t *testing.T) {
 			linenum++
 			linenum++
 		}
 		}
 	}
 	}
-	if linenum != 6 {
-		t.Fatal(linenum, "not line 6")
+	var expected = LevelDebug + 1
+	if linenum != expected {
+		t.Fatal(linenum, "not "+strconv.Itoa(expected)+" lines")
 	}
 	}
 	os.Remove("test.log")
 	os.Remove("test.log")
 }
 }
 
 
 func TestFile2(t *testing.T) {
 func TestFile2(t *testing.T) {
 	log := NewLogger(10000)
 	log := NewLogger(10000)
-	log.SetLogger("file", `{"filename":"test2.log","level":2}`)
-	log.Trace("test")
-	log.Info("info")
+	log.SetLogger("file", fmt.Sprintf(`{"filename":"test2.log","level":%d}`, LevelError))
 	log.Debug("debug")
 	log.Debug("debug")
-	log.Warn("warning")
+	log.Info("info")
+	log.Notice("notice")
+	log.Warning("warning")
 	log.Error("error")
 	log.Error("error")
+	log.Alert("alert")
 	log.Critical("critical")
 	log.Critical("critical")
+	log.Emergency("emergency")
 	time.Sleep(time.Second * 4)
 	time.Sleep(time.Second * 4)
 	f, err := os.Open("test2.log")
 	f, err := os.Open("test2.log")
 	if err != nil {
 	if err != nil {
@@ -70,8 +84,9 @@ func TestFile2(t *testing.T) {
 			linenum++
 			linenum++
 		}
 		}
 	}
 	}
-	if linenum != 4 {
-		t.Fatal(linenum, "not line 4")
+	var expected = LevelError + 1
+	if linenum != expected {
+		t.Fatal(linenum, "not "+strconv.Itoa(expected)+" lines")
 	}
 	}
 	os.Remove("test2.log")
 	os.Remove("test2.log")
 }
 }
@@ -79,17 +94,19 @@ func TestFile2(t *testing.T) {
 func TestFileRotate(t *testing.T) {
 func TestFileRotate(t *testing.T) {
 	log := NewLogger(10000)
 	log := NewLogger(10000)
 	log.SetLogger("file", `{"filename":"test3.log","maxlines":4}`)
 	log.SetLogger("file", `{"filename":"test3.log","maxlines":4}`)
-	log.Trace("test")
-	log.Info("info")
 	log.Debug("debug")
 	log.Debug("debug")
-	log.Warn("warning")
+	log.Info("info")
+	log.Notice("notice")
+	log.Warning("warning")
 	log.Error("error")
 	log.Error("error")
+	log.Alert("alert")
 	log.Critical("critical")
 	log.Critical("critical")
+	log.Emergency("emergency")
 	time.Sleep(time.Second * 4)
 	time.Sleep(time.Second * 4)
 	rotatename := "test3.log" + fmt.Sprintf(".%s.%03d", time.Now().Format("2006-01-02"), 1)
 	rotatename := "test3.log" + fmt.Sprintf(".%s.%03d", time.Now().Format("2006-01-02"), 1)
 	b, err := exists(rotatename)
 	b, err := exists(rotatename)
 	if !b || err != nil {
 	if !b || err != nil {
-		t.Fatal("rotate not gen")
+		t.Fatal("rotate not generated")
 	}
 	}
 	os.Remove(rotatename)
 	os.Remove(rotatename)
 	os.Remove("test3.log")
 	os.Remove("test3.log")
@@ -110,7 +127,7 @@ func BenchmarkFile(b *testing.B) {
 	log := NewLogger(100000)
 	log := NewLogger(100000)
 	log.SetLogger("file", `{"filename":"test4.log"}`)
 	log.SetLogger("file", `{"filename":"test4.log"}`)
 	for i := 0; i < b.N; i++ {
 	for i := 0; i < b.N; i++ {
-		log.Trace("trace")
+		log.Debug("debug")
 	}
 	}
 	os.Remove("test4.log")
 	os.Remove("test4.log")
 }
 }

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
+// Usage:
+//
+// import "github.com/astaxie/beego/logs"
+//
+//	log := NewLogger(10000)
+//	log.SetLogger("console", "")
+//
+//	> the first params stand for how many channel
+//
+// Use it like this:
+//
+//	log.Trace("trace")
+//	log.Info("info")
+//	log.Warn("warning")
+//	log.Debug("debug")
+//	log.Critical("critical")
+//
+//  more docs http://beego.me/docs/module/logs.md
 package logs
 package logs
 
 
 import (
 import (
@@ -13,14 +39,25 @@ import (
 	"sync"
 	"sync"
 )
 )
 
 
+// RFC5424 log message levels.
 const (
 const (
-	// log message levels
-	LevelTrace = iota
-	LevelDebug
-	LevelInfo
-	LevelWarn
-	LevelError
+	LevelEmergency = iota
+	LevelAlert
 	LevelCritical
 	LevelCritical
+	LevelError
+	LevelWarning
+	LevelNotice
+	LevelInformational
+	LevelDebug
+)
+
+// Legacy loglevel constants to ensure backwards compatibility.
+//
+// Deprecated: will be removed in 1.5.0.
+const (
+	LevelInfo  = LevelInformational
+	LevelTrace = LevelDebug
+	LevelWarn  = LevelWarning
 )
 )
 
 
 type loggerType func() LoggerInterface
 type loggerType func() LoggerInterface
@@ -69,6 +106,7 @@ type logMsg struct {
 // if the buffering chan is full, logger adapters write to file or other way.
 // if the buffering chan is full, logger adapters write to file or other way.
 func NewLogger(channellen int64) *BeeLogger {
 func NewLogger(channellen int64) *BeeLogger {
 	bl := new(BeeLogger)
 	bl := new(BeeLogger)
+	bl.level = LevelDebug
 	bl.loggerFuncCallDepth = 2
 	bl.loggerFuncCallDepth = 2
 	bl.msg = make(chan *logMsg, channellen)
 	bl.msg = make(chan *logMsg, channellen)
 	bl.outputs = make(map[string]LoggerInterface)
 	bl.outputs = make(map[string]LoggerInterface)
@@ -110,7 +148,7 @@ func (bl *BeeLogger) DelLogger(adaptername string) error {
 }
 }
 
 
 func (bl *BeeLogger) writerMsg(loglevel int, msg string) error {
 func (bl *BeeLogger) writerMsg(loglevel int, msg string) error {
-	if bl.level > loglevel {
+	if loglevel > bl.level {
 		return nil
 		return nil
 	}
 	}
 	lm := new(logMsg)
 	lm := new(logMsg)
@@ -130,8 +168,10 @@ func (bl *BeeLogger) writerMsg(loglevel int, msg string) error {
 	return nil
 	return nil
 }
 }
 
 
-// set log message level.
-// if message level (such as LevelTrace) is less than logger level (such as LevelWarn), ignore message.
+// Set log message level.
+//
+// If message level (such as LevelDebug) is higher than logger level (such as LevelWarning),
+// log providers will not even be sent the message.
 func (bl *BeeLogger) SetLevel(l int) {
 func (bl *BeeLogger) SetLevel(l int) {
 	bl.level = l
 	bl.level = l
 }
 }
@@ -147,7 +187,7 @@ func (bl *BeeLogger) EnableFuncCallDepth(b bool) {
 }
 }
 
 
 // start logger chan reading.
 // start logger chan reading.
-// when chan is full, write logs.
+// when chan is not empty, write logs.
 func (bl *BeeLogger) startLogger() {
 func (bl *BeeLogger) startLogger() {
 	for {
 	for {
 		select {
 		select {
@@ -159,40 +199,73 @@ func (bl *BeeLogger) startLogger() {
 	}
 	}
 }
 }
 
 
-// log trace level message.
-func (bl *BeeLogger) Trace(format string, v ...interface{}) {
-	msg := fmt.Sprintf("[T] "+format, v...)
-	bl.writerMsg(LevelTrace, msg)
+// Log EMERGENCY level message.
+func (bl *BeeLogger) Emergency(format string, v ...interface{}) {
+	msg := fmt.Sprintf("[D] "+format, v...)
+	bl.writerMsg(LevelEmergency, msg)
 }
 }
 
 
-// log debug level message.
-func (bl *BeeLogger) Debug(format string, v ...interface{}) {
+// Log ALERT level message.
+func (bl *BeeLogger) Alert(format string, v ...interface{}) {
 	msg := fmt.Sprintf("[D] "+format, v...)
 	msg := fmt.Sprintf("[D] "+format, v...)
-	bl.writerMsg(LevelDebug, msg)
+	bl.writerMsg(LevelAlert, msg)
 }
 }
 
 
-// log info level message.
-func (bl *BeeLogger) Info(format string, v ...interface{}) {
+// Log CRITICAL level message.
+func (bl *BeeLogger) Critical(format string, v ...interface{}) {
+	msg := fmt.Sprintf("[C] "+format, v...)
+	bl.writerMsg(LevelCritical, msg)
+}
+
+// Log ERROR level message.
+func (bl *BeeLogger) Error(format string, v ...interface{}) {
+	msg := fmt.Sprintf("[E] "+format, v...)
+	bl.writerMsg(LevelError, msg)
+}
+
+// Log WARNING level message.
+func (bl *BeeLogger) Warning(format string, v ...interface{}) {
+	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...)
+	bl.writerMsg(LevelNotice, msg)
+}
+
+// Log INFORMATIONAL level message.
+func (bl *BeeLogger) Informational(format string, v ...interface{}) {
 	msg := fmt.Sprintf("[I] "+format, v...)
 	msg := fmt.Sprintf("[I] "+format, v...)
-	bl.writerMsg(LevelInfo, msg)
+	bl.writerMsg(LevelInformational, msg)
 }
 }
 
 
-// log warn level message.
+// Log DEBUG level message.
+func (bl *BeeLogger) Debug(format string, v ...interface{}) {
+	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.
 func (bl *BeeLogger) Warn(format string, v ...interface{}) {
 func (bl *BeeLogger) Warn(format string, v ...interface{}) {
-	msg := fmt.Sprintf("[W] "+format, v...)
-	bl.writerMsg(LevelWarn, msg)
+	bl.Warning(format, v...)
 }
 }
 
 
-// log error level message.
-func (bl *BeeLogger) Error(format string, v ...interface{}) {
-	msg := fmt.Sprintf("[E] "+format, v...)
-	bl.writerMsg(LevelError, msg)
+// Log INFO level message.
+//
+// Deprecated: compatibility alias for Informational(), Will be removed in 1.5.0.
+func (bl *BeeLogger) Info(format string, v ...interface{}) {
+	bl.Informational(format, v...)
 }
 }
 
 
-// log critical level message.
-func (bl *BeeLogger) Critical(format string, v ...interface{}) {
-	msg := fmt.Sprintf("[C] "+format, v...)
-	bl.writerMsg(LevelCritical, msg)
+// Log TRACE level message.
+//
+// Deprecated: compatibility alias for Debug(), Will be removed in 1.5.0.
+func (bl *BeeLogger) Trace(format string, v ...interface{}) {
+	bl.Debug(format, v...)
 }
 }
 
 
 // flush all chan data.
 // flush all chan data.

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
 package logs
 package logs
 
 
@@ -51,22 +59,30 @@ func (s *SmtpWriter) Init(jsonconfig string) error {
 	return nil
 	return nil
 }
 }
 
 
+func (s *SmtpWriter) GetSmtpAuth(host string) smtp.Auth {
+	if len(strings.Trim(s.Username, " ")) == 0 && len(strings.Trim(s.Password, " ")) == 0 {
+		return nil
+	}
+	return smtp.PlainAuth(
+		"",
+		s.Username,
+		s.Password,
+		host,
+	)
+}
+
 // write message in smtp writer.
 // write message in smtp writer.
 // it will send an email with subject and only this message.
 // it will send an email with subject and only this message.
 func (s *SmtpWriter) WriteMsg(msg string, level int) error {
 func (s *SmtpWriter) WriteMsg(msg string, level int) error {
-	if level < s.Level {
+	if level > s.Level {
 		return nil
 		return nil
 	}
 	}
 
 
 	hp := strings.Split(s.Host, ":")
 	hp := strings.Split(s.Host, ":")
 
 
 	// Set up authentication information.
 	// Set up authentication information.
-	auth := smtp.PlainAuth(
-		"",
-		s.Username,
-		s.Password,
-		hp[0],
-	)
+	auth := s.GetSmtpAuth(hp[0])
+
 	// Connect to the server, authenticate, set the sender and recipient,
 	// Connect to the server, authenticate, set the sender and recipient,
 	// and send the email all in one step.
 	// and send the email all in one step.
 	content_type := "Content-Type: text/plain" + "; charset=UTF-8"
 	content_type := "Content-Type: text/plain" + "; charset=UTF-8"

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
 package logs
 package logs
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package beego
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package middleware
 
 
@@ -311,6 +319,7 @@ func Exception(errcode string, w http.ResponseWriter, r *http.Request, msg strin
 		if err != nil {
 		if err != nil {
 			isint = 500
 			isint = 500
 		}
 		}
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
 		w.WriteHeader(isint)
 		w.WriteHeader(isint)
 		h(w, r)
 		h(w, r)
 		return
 		return

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
+// 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
 package middleware
 
 

-// Beego (http://beego.me/)
-// @description beego is an open-source, high-performance web framework for the Go programming language.
-// @link        http://github.com/astaxie/beego for the canonical source repository
-// @license     http://github.com/astaxie/beego/blob/master/LICENSE
-// @authors     astaxie
-
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Usage:
+//
+// import "github.com/astaxie/beego/middleware"
+//
+// I18N = middleware.NewLocale("conf/i18n.conf", beego.AppConfig.String("language"))
+//
+// more docs: http://beego.me/docs/module/i18n.md
 package middleware
 package middleware
 
 
-//import (
-//	"github.com/astaxie/beego/config"
-//	"os"
-//	"path"
-//)
-
-//type Translation struct {
-//	filetype     string
-//	CurrentLocal string
-//	Locales      map[string]map[string]string
-//}
-
-//func NewLocale(filetype string) *Translation {
-//	return &Translation{
-//		filetype:     filetype,
-//		CurrentLocal: "zh",
-//		Locales:      make(map[string]map[string]string),
-//	}
-//}
-
-//func (t *Translation) loadTranslations(dirPath string) error {
-//	dir, err := os.Open(dirPath)
-//	if err != nil {
-//		return err
-//	}
-//	defer dir.Close()
-
-//	names, err := dir.Readdirnames(-1)
-//	if err != nil {
-//		return err
-//	}
-
-//	for _, name := range names {
-//		fullPath := path.Join(dirPath, name)
-
-//		fi, err := os.Stat(fullPath)
-//		if err != nil {
-//			return err
-//		}
-
-//		if fi.IsDir() {
-//			continue
-//		} else {
-//			if err := t.loadTranslation(fullPath, name); err != nil {
-//				return err
-//			}
-//		}
-//	}
-
-//	return nil
-//}
-
-//func (t *Translation) loadTranslation(fullPath, locale string) error {
-
-//	sourceKey2Trans, ok := t.Locales[locale]
-//	if !ok {
-//		sourceKey2Trans = make(map[string]string)
-
-//		t.Locales[locale] = sourceKey2Trans
-//	}
-
-//	for _, m := range trf.Messages {
-//		if m.Translation != "" {
-//			sourceKey2Trans[sourceKey(m.Source, m.Context)] = m.Translation
-//		}
-//	}
-
-//	return nil
-//}
-
-//func (t *Translation) SetLocale(local string) {
-//	t.CurrentLocal = local
-//}
-
-//func (t *Translation) Translate(key string) string {
-//	if ct, ok := t.Locales[t.CurrentLocal]; ok {
-//		if v, o := ct[key]; o {
-//			return v
-//		}
-//	}
-//	return key
-//}
+import (
+	"encoding/json"
+	"io/ioutil"
+	"os"
+)
+
+type Translation struct {
+	filepath     string
+	CurrentLocal string
+	Locales      map[string]map[string]string
+}
+
+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())
+	}
+	data, err := ioutil.ReadAll(file)
+	if err != nil {
+		panic("read " + filepath + " err :" + err.Error())
+	}
+	err = json.Unmarshal(data, &i18n)
+	if err != nil {
+		panic("json.Unmarshal " + filepath + " err :" + err.Error())
+	}
+	return &Translation{
+		filepath:     filepath,
+		CurrentLocal: defaultlocal,
+		Locales:      i18n,
+	}
+}
+
+func (t *Translation) SetLocale(local string) {
+	t.CurrentLocal = local
+}
+
+func (t *Translation) Translate(key string, local string) string {
+	if local == "" {
+		local = t.CurrentLocal
+	}
+	if ct, ok := t.Locales[key]; ok {
+		if v, o := ct[local]; o {
+			return v
+		}
+	}
+	return key
+}

+// 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.
+
+// migration package for migration
+//
+// The table structure is as follow:
+//
+//	CREATE TABLE `migrations` (
+//		`id_migration` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'surrogate key',
+//		`name` varchar(255) DEFAULT NULL COMMENT 'migration name, unique',
+//		`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT 'date migrated or rolled back',
+//		`statements` longtext COMMENT 'SQL statements for this migration',
+//		`rollback_statements` longtext,
+//		`status` enum('update','rollback') DEFAULT NULL COMMENT 'update indicates it is a normal migration while rollback means this migration is rolled back',
+//		PRIMARY KEY (`id_migration`)
+//	) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+package migration
+
+import (
+	"errors"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/astaxie/beego"
+	"github.com/astaxie/beego/orm"
+)
+
+// const the data format for the bee generate migration datatype
+const (
+	M_DATE_FORMAT    = "20060102_150405"
+	M_DB_DATE_FORMAT = "2006-01-02 15:04:05"
+)
+
+// Migrationer is an interface for all Migration struct
+type Migrationer interface {
+	Up()
+	Down()
+	Reset()
+	Exec(name, status string) error
+	GetCreated() int64
+}
+
+var (
+	migrationMap map[string]Migrationer
+)
+
+func init() {
+	migrationMap = make(map[string]Migrationer)
+}
+
+// the basic type which will implement the basic type
+type Migration struct {
+	sqls    []string
+	Created string
+}
+
+// implement in the Inheritance struct for upgrade
+func (m *Migration) Up() {
+
+}
+
+// implement in the Inheritance struct for down
+func (m *Migration) Down() {
+
+}
+
+// add sql want to execute
+func (m *Migration) Sql(sql string) {
+	m.sqls = append(m.sqls, sql)
+}
+
+// Reset the sqls
+func (m *Migration) Reset() {
+	m.sqls = make([]string, 0)
+}
+
+// execute the sql already add in the sql
+func (m *Migration) Exec(name, status string) error {
+	o := orm.NewOrm()
+	for _, s := range m.sqls {
+		beego.Info("exec sql:", s)
+		r := o.Raw(s)
+		_, err := r.Exec()
+		if err != nil {
+			return err
+		}
+	}
+	return m.addOrUpdateRecord(name, status)
+}
+
+func (m *Migration) addOrUpdateRecord(name, status string) error {
+	o := orm.NewOrm()
+	if status == "down" {
+		status = "rollback"
+		p, err := o.Raw("update migrations set `status` = ?, `rollback_statements` = ?, `created_at` = ? where name = ?").Prepare()
+		if err != nil {
+			return nil
+		}
+		_, err = p.Exec(status, strings.Join(m.sqls, "; "), time.Now().Format(M_DB_DATE_FORMAT), name)
+		return err
+	} else {
+		status = "update"
+		p, err := o.Raw("insert into migrations(`name`, `created_at`, `statements`, `status`) values(?,?,?,?)").Prepare()
+		if err != nil {
+			return err
+		}
+		_, err = p.Exec(name, time.Now().Format(M_DB_DATE_FORMAT), strings.Join(m.sqls, "; "), status)
+		return err
+	}
+}
+
+// get the unixtime from the Created
+func (m *Migration) GetCreated() int64 {
+	t, err := time.Parse(M_DATE_FORMAT, m.Created)
+	if err != nil {
+		return 0
+	}
+	return t.Unix()
+}
+
+// register the Migration in the map
+func Register(name string, m Migrationer) error {
+	if _, ok := migrationMap[name]; ok {
+		return errors.New("already exist name:" + name)
+	}
+	migrationMap[name] = m
+	return nil
+}
+
+// upgrate the migration from lasttime
+func Upgrade(lasttime int64) error {
+	sm := sortMap(migrationMap)
+	i := 0
+	for _, v := range sm {
+		if v.created > lasttime {
+			beego.Info("start upgrade", v.name)
+			v.m.Reset()
+			v.m.Up()
+			err := v.m.Exec(v.name, "up")
+			if err != nil {
+				beego.Error("execute error:", err)
+				time.Sleep(2 * time.Second)
+				return err
+			}
+			beego.Info("end upgrade:", v.name)
+			i++
+		}
+	}
+	beego.Info("total success upgrade:", i, " migration")
+	time.Sleep(2 * time.Second)
+	return nil
+}
+
+//rollback the migration by the name
+func Rollback(name string) error {
+	if v, ok := migrationMap[name]; ok {
+		beego.Info("start rollback")
+		v.Reset()
+		v.Down()
+		err := v.Exec(name, "down")
+		if err != nil {
+			beego.Error("execute error:", err)
+			time.Sleep(2 * time.Second)
+			return err
+		}
+		beego.Info("end rollback")
+		time.Sleep(2 * time.Second)
+		return nil
+	} else {
+		beego.Error("not exist the migrationMap name:" + name)
+		time.Sleep(2 * time.Second)
+		return errors.New("not exist the migrationMap name:" + name)
+	}
+}
+
+// reset all migration
+// run all migration's down function
+func Reset() error {
+	sm := sortMap(migrationMap)
+	i := 0
+	for j := len(sm) - 1; j >= 0; j-- {
+		v := sm[j]
+		if isRollBack(v.name) {
+			beego.Info("skip the", v.name)
+			time.Sleep(1 * time.Second)
+			continue
+		}
+		beego.Info("start reset:", v.name)
+		v.m.Reset()
+		v.m.Down()
+		err := v.m.Exec(v.name, "down")
+		if err != nil {
+			beego.Error("execute error:", err)
+			time.Sleep(2 * time.Second)
+			return err
+		}
+		i++
+		beego.Info("end reset:", v.name)
+	}
+	beego.Info("total success reset:", i, " migration")
+	time.Sleep(2 * time.Second)
+	return nil
+}
+
+// first Reset, then Upgrade
+func Refresh() error {
+	err := Reset()
+	if err != nil {
+		beego.Error("execute error:", err)
+		time.Sleep(2 * time.Second)
+		return err
+	}
+	err = Upgrade(0)
+	return err
+}
+
+type dataSlice []data
+
+type data struct {
+	created int64
+	name    string
+	m       Migrationer
+}
+
+// Len is part of sort.Interface.
+func (d dataSlice) Len() int {
+	return len(d)
+}
+
+// Swap is part of sort.Interface.
+func (d dataSlice) Swap(i, j int) {
+	d[i], d[j] = d[j], d[i]
+}
+
+// Less is part of sort.Interface. We use count as the value to sort by
+func (d dataSlice) Less(i, j int) bool {
+	return d[i].created < d[j].created
+}
+
+func sortMap(m map[string]Migrationer) dataSlice {
+	s := make(dataSlice, 0, len(m))
+	for k, v := range m {
+		d := data{}
+		d.created = v.GetCreated()
+		d.name = k
+		d.m = v
+		s = append(s, d)
+	}
+	sort.Sort(s)
+	return s
+}
+
+func isRollBack(name string) bool {
+	o := orm.NewOrm()
+	var maps []orm.Params
+	num, err := o.Raw("select * from migrations where `name` = ? order by id_migration desc", name).Values(&maps)
+	if err != nil {
+		beego.Info("get name has error", err)
+		return false
+	}
+	if num <= 0 {
+		return false
+	}
+	if maps[0]["status"] == "rollback" {
+		return true
+	}
+	return false
+}